cordova-plugin-mserviceinterface-2.0 1.0.99 → 1.0.100

package/scripts/mservice-deeplink-setup.js

@@ -0,0 +1,1182 @@
+"use strict";
+
+var fs = require("fs");
+var path = require("path");
+
+function getPreferenceValue(configXml, preferenceName) {
+    var escapedName;
+    var pattern;
+    var match;
+
+    escapedName = preferenceName.replace(
+        /[.*+?^${}()|[\]\\]/g,
+        "\\$&"
+    );
+
+    pattern = new RegExp(
+        "<preference\\s+" +
+        "(?=[^>]*\\bname\\s*=\\s*[\"']" + escapedName + "[\"'])" +
+        "(?=[^>]*\\bvalue\\s*=\\s*[\"']([^\"']*)[\"'])" +
+        "[^>]*/?>",
+        "i"
+    );
+
+    match = configXml.match(pattern);
+
+    return match !== null ? match[1].trim() : "";
+}
+
+function normalizePath(deepLinkPath) {
+    if (deepLinkPath === "") {
+        return "/";
+    }
+
+    if (deepLinkPath.charAt(0) !== "/") {
+        return "/" + deepLinkPath;
+    }
+
+    return deepLinkPath;
+}
+
+function validateConfiguration(configuration) {
+    var errors = [];
+
+    if (configuration.scheme === "") {
+        errors.push(
+            "MServiceDeepLinkScheme is missing in config.xml"
+        );
+    }
+
+    if (configuration.host === "") {
+        errors.push(
+            "MServiceDeepLinkHost is missing in config.xml"
+        );
+    }
+
+    if (configuration.path === "") {
+        errors.push(
+            "MServiceDeepLinkPath is missing in config.xml"
+        );
+    }
+
+    if (
+        configuration.scheme !== "" &&
+        configuration.scheme !== "https"
+    ) {
+        errors.push(
+            "MServiceDeepLinkScheme must be https for verified App Links and Universal Links"
+        );
+    }
+
+    if (
+        configuration.host.indexOf("http://") === 0 ||
+        configuration.host.indexOf("https://") === 0
+    ) {
+        errors.push(
+            "MServiceDeepLinkHost must contain only the hostname, without https://"
+        );
+    }
+
+    if (
+        configuration.iosAssociatedDomain !== "" &&
+        configuration.iosAssociatedDomain.indexOf("applinks:") !== 0
+    ) {
+        errors.push(
+            "MServiceIOSAssociatedDomain must start with applinks:"
+        );
+    }
+
+    if (errors.length !== 0) {
+        throw new Error(
+            "Invalid deep-link configuration:\n- " +
+            errors.join("\n- ")
+        );
+    }
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function escapeXmlAttribute(value) {
+    return String(value)
+        .replace(/&/g, "&amp;")
+        .replace(/"/g, "&quot;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;");
+}
+
+function getAndroidManifestPath(projectRoot) {
+    var possiblePaths = [
+        path.join(
+            projectRoot,
+            "platforms",
+            "android",
+            "app",
+            "src",
+            "main",
+            "AndroidManifest.xml"
+        ),
+        path.join(
+            projectRoot,
+            "platforms",
+            "android",
+            "AndroidManifest.xml"
+        )
+    ];
+
+    var index;
+
+    for (index = 0; index < possiblePaths.length; index += 1) {
+        if (fs.existsSync(possiblePaths[index])) {
+            return possiblePaths[index];
+        }
+    }
+
+    return "";
+}
+
+function setActivityAttribute(openingTag, attributeName, attributeValue) {
+    var attributePattern;
+
+    attributePattern = new RegExp(
+        "\\s+" +
+        escapeRegExp(attributeName) +
+        "\\s*=\\s*[\"'][^\"']*[\"']",
+        "i"
+    );
+
+    if (attributePattern.test(openingTag)) {
+        return openingTag.replace(
+            attributePattern,
+            " " +
+            attributeName +
+            "=\"" +
+            escapeXmlAttribute(attributeValue) +
+            "\""
+        );
+    }
+
+    return openingTag.replace(
+        />$/,
+        " " +
+        attributeName +
+        "=\"" +
+        escapeXmlAttribute(attributeValue) +
+        "\">"
+    );
+}
+
+function configureAndroidAppLink(projectRoot, configuration) {
+    var manifestPath;
+    var manifestContent;
+    var activityPattern;
+    var activityMatch;
+    var activityBlock;
+    var updatedActivityBlock;
+    var markerPattern;
+    var intentFilter;
+
+    manifestPath = getAndroidManifestPath(projectRoot);
+
+    if (manifestPath === "") {
+        throw new Error(
+            "AndroidManifest.xml could not be found under platforms/android."
+        );
+    }
+
+    manifestContent = fs.readFileSync(manifestPath, "utf8");
+
+    activityPattern =
+        /<activity\b[^>]*android:name\s*=\s*["'][^"']*MainActivity["'][^>]*>[\s\S]*?<\/activity>/i;
+
+    activityMatch = manifestContent.match(activityPattern);
+
+    if (activityMatch === null) {
+        throw new Error(
+            "MainActivity declaration could not be found in AndroidManifest.xml."
+        );
+    }
+
+    activityBlock = activityMatch[0];
+
+    /*
+     * Ensure the activity receives App Links when the app is already open.
+     */
+    updatedActivityBlock = activityBlock.replace(
+        /^<activity\b[^>]*>/i,
+        function (openingTag) {
+            var updatedOpeningTag;
+
+            updatedOpeningTag = setActivityAttribute(
+                openingTag,
+                "android:exported",
+                "true"
+            );
+
+            updatedOpeningTag = setActivityAttribute(
+                updatedOpeningTag,
+                "android:launchMode",
+                "singleTask"
+            );
+
+            return updatedOpeningTag;
+        }
+    );
+
+    intentFilter =
+        "\n        <!-- MService App Link - START -->\n" +
+        "        <intent-filter android:autoVerify=\"true\">\n" +
+        "            <action android:name=\"android.intent.action.VIEW\" />\n" +
+        "            <category android:name=\"android.intent.category.DEFAULT\" />\n" +
+        "            <category android:name=\"android.intent.category.BROWSABLE\" />\n" +
+        "            <data\n" +
+        "                android:scheme=\"" +
+        escapeXmlAttribute(configuration.scheme) +
+        "\"\n" +
+        "                android:host=\"" +
+        escapeXmlAttribute(configuration.host) +
+        "\"\n" +
+        "                android:path=\"" +
+        escapeXmlAttribute(configuration.path) +
+        "\" />\n" +
+        "        </intent-filter>\n" +
+        "        <!-- MService App Link - END -->\n";
+
+    markerPattern =
+        /\s*<!-- MService App Link - START -->[\s\S]*?<!-- MService App Link - END -->\s*/i;
+
+    /*
+     * Replace an existing hook-generated filter when configuration changes.
+     */
+    if (markerPattern.test(updatedActivityBlock)) {
+        updatedActivityBlock = updatedActivityBlock.replace(
+            markerPattern,
+            intentFilter
+        );
+    } else {
+        updatedActivityBlock = updatedActivityBlock.replace(
+            /<\/activity>\s*$/i,
+            intentFilter + "    </activity>"
+        );
+    }
+
+    manifestContent = manifestContent.replace(
+        activityPattern,
+        updatedActivityBlock
+    );
+
+    fs.writeFileSync(
+        manifestPath,
+        manifestContent,
+        "utf8"
+    );
+
+    console.log(
+        "[MService Deep Link] Android App Link configured: " +
+        configuration.scheme +
+        "://" +
+        configuration.host +
+        configuration.path
+    );
+
+    console.log(
+        "[MService Deep Link] Android manifest updated: " +
+        manifestPath
+    );
+}
+
+function findFileRecursively(directoryPath, fileName) {
+    var entries;
+    var index;
+    var entryPath;
+    var status;
+    var result;
+
+    if (!fs.existsSync(directoryPath)) {
+        return "";
+    }
+
+    entries = fs.readdirSync(directoryPath);
+
+    for (index = 0; index < entries.length; index += 1) {
+        entryPath = path.join(directoryPath, entries[index]);
+        status = fs.statSync(entryPath);
+
+        if (status.isFile() && entries[index] === fileName) {
+            return entryPath;
+        }
+
+        if (status.isDirectory()) {
+            result = findFileRecursively(entryPath, fileName);
+
+            if (result !== "") {
+                return result;
+            }
+        }
+    }
+
+    return "";
+}
+
+function ensureJavaImport(
+    javaContent,
+    importStatement,
+    newLine
+) {
+    var importPattern;
+    var importMatch;
+    var lastImportMatch;
+    var packageMatch;
+    var insertionIndex;
+
+    if (javaContent.indexOf(importStatement) !== -1) {
+        return javaContent;
+    }
+
+    importPattern = /^import[^\r\n]+;$/gm;
+    lastImportMatch = null;
+
+    while (
+        (importMatch = importPattern.exec(javaContent)) !== null
+    ) {
+        lastImportMatch = importMatch;
+    }
+
+    if (lastImportMatch !== null) {
+        insertionIndex =
+            lastImportMatch.index +
+            lastImportMatch[0].length;
+
+        return (
+            javaContent.substring(0, insertionIndex) +
+            newLine +
+            importStatement +
+            javaContent.substring(insertionIndex)
+        );
+    }
+
+    packageMatch =
+        /^package[^\r\n]+;$/m.exec(javaContent);
+
+    if (packageMatch === null) {
+        throw new Error(
+            "Package declaration was not found in MainActivity.java."
+        );
+    }
+
+    insertionIndex =
+        packageMatch.index +
+        packageMatch[0].length;
+
+    return (
+        javaContent.substring(0, insertionIndex) +
+        newLine +
+        newLine +
+        importStatement +
+        javaContent.substring(insertionIndex)
+    );
+}
+
+function insertBeforeFinalClassBrace(
+    javaContent,
+    javaBlock,
+    newLine
+) {
+    var finalBraceIndex;
+
+    finalBraceIndex = javaContent.lastIndexOf("}");
+
+    if (finalBraceIndex === -1) {
+        throw new Error(
+            "Final class closing brace was not found in MainActivity.java."
+        );
+    }
+
+    return (
+        javaContent.substring(0, finalBraceIndex) +
+        javaBlock +
+        newLine +
+        javaContent.substring(finalBraceIndex)
+    );
+}
+
+function configureAndroidMainActivity(projectRoot) {
+    var javaRoot;
+    var mainActivityPath;
+    var javaContent;
+    var originalContent;
+    var newLine;
+    var onCreateCall;
+    var onNewIntentBlock;
+    var helperMethodsBlock;
+    var loadUrlPattern;
+    var existingOnNewIntentPattern;
+    var updatedExistingMethod;
+
+    javaRoot = path.join(
+        projectRoot,
+        "platforms",
+        "android",
+        "app",
+        "src",
+        "main",
+        "java"
+    );
+
+    mainActivityPath = findFileRecursively(
+        javaRoot,
+        "MainActivity.java"
+    );
+
+    if (mainActivityPath === "") {
+        throw new Error(
+            "MainActivity.java could not be found under: " +
+            javaRoot
+        );
+    }
+
+    javaContent = fs.readFileSync(
+        mainActivityPath,
+        "utf8"
+    );
+
+    originalContent = javaContent;
+
+    newLine =
+        javaContent.indexOf("\r\n") !== -1
+            ? "\r\n"
+            : "\n";
+
+    /*
+     * Ensure required imports.
+     */
+    javaContent = ensureJavaImport(
+        javaContent,
+        "import android.content.Intent;",
+        newLine
+    );
+
+    javaContent = ensureJavaImport(
+        javaContent,
+        "import android.net.Uri;",
+        newLine
+    );
+
+    javaContent = ensureJavaImport(
+        javaContent,
+        "import org.json.JSONObject;",
+        newLine
+    );
+
+    /*
+     * Cold-start handling:
+     * App closed -> App Link opens the app.
+     */
+    if (
+        !/handleAppLinkIntent\s*\(\s*getIntent\s*\(\s*\)\s*\)\s*;/.test(
+            javaContent
+        )
+    ) {
+        onCreateCall =
+            newLine +
+            newLine +
+            "        // MService App Link onCreate - START" +
+            newLine +
+            "        handleAppLinkIntent(getIntent());" +
+            newLine +
+            "        // MService App Link onCreate - END";
+
+        loadUrlPattern =
+            /loadUrl\s*\(\s*launchUrl\s*\)\s*;/;
+
+        if (!loadUrlPattern.test(javaContent)) {
+            throw new Error(
+                "loadUrl(launchUrl) was not found in MainActivity.java."
+            );
+        }
+
+        javaContent = javaContent.replace(
+            loadUrlPattern,
+            function (loadUrlStatement) {
+                return loadUrlStatement + onCreateCall;
+            }
+        );
+    }
+
+    /*
+     * Background/running handling:
+     * App already open -> App Link arrives through onNewIntent.
+     */
+    if (
+        javaContent.indexOf(
+            "protected void onNewIntent(Intent intent)"
+        ) === -1
+    ) {
+        onNewIntentBlock =
+            newLine +
+            "    // MService App Link onNewIntent - START" +
+            newLine +
+            "    @Override" +
+            newLine +
+            "    protected void onNewIntent(Intent intent) {" +
+            newLine +
+            "        super.onNewIntent(intent);" +
+            newLine +
+            "        setIntent(intent);" +
+            newLine +
+            newLine +
+            "        handleAppLinkIntent(intent);" +
+            newLine +
+            "    }" +
+            newLine +
+            "    // MService App Link onNewIntent - END" +
+            newLine;
+
+        javaContent = insertBeforeFinalClassBrace(
+            javaContent,
+            onNewIntentBlock,
+            newLine
+        );
+    } else if (
+        javaContent.indexOf(
+            "handleAppLinkIntent(intent);"
+        ) === -1
+    ) {
+        existingOnNewIntentPattern =
+            /(protected\s+void\s+onNewIntent\s*\(\s*Intent\s+intent\s*\)\s*\{[\s\S]*?setIntent\s*\(\s*intent\s*\)\s*;)/;
+
+        if (existingOnNewIntentPattern.test(javaContent)) {
+            javaContent = javaContent.replace(
+                existingOnNewIntentPattern,
+                function (methodStart) {
+                    return (
+                        methodStart +
+                        newLine +
+                        newLine +
+                        "        handleAppLinkIntent(intent);"
+                    );
+                }
+            );
+        } else {
+            updatedExistingMethod = javaContent.replace(
+                /(protected\s+void\s+onNewIntent\s*\(\s*Intent\s+intent\s*\)\s*\{[\s\S]*?super\.onNewIntent\s*\(\s*intent\s*\)\s*;)/,
+                function (methodStart) {
+                    return (
+                        methodStart +
+                        newLine +
+                        "        setIntent(intent);" +
+                        newLine +
+                        newLine +
+                        "        handleAppLinkIntent(intent);"
+                    );
+                }
+            );
+
+            if (updatedExistingMethod === javaContent) {
+                throw new Error(
+                    "Existing onNewIntent method could not be updated safely."
+                );
+            }
+
+            javaContent = updatedExistingMethod;
+        }
+    }
+
+    /*
+     * Add the common native-to-JavaScript bridge.
+     */
+    if (
+        javaContent.indexOf(
+            "private void handleAppLinkIntent(Intent intent)"
+        ) === -1
+    ) {
+        helperMethodsBlock =
+            newLine +
+            "    // MService App Link Methods - START" +
+            newLine +
+            "    private void handleAppLinkIntent(Intent intent) {" +
+            newLine +
+            "        if (intent == null) {" +
+            newLine +
+            "            return;" +
+            newLine +
+            "        }" +
+            newLine +
+            newLine +
+            "        if (!Intent.ACTION_VIEW.equals(intent.getAction())) {" +
+            newLine +
+            "            return;" +
+            newLine +
+            "        }" +
+            newLine +
+            newLine +
+            "        Uri data = intent.getData();" +
+            newLine +
+            newLine +
+            "        if (data == null) {" +
+            newLine +
+            "            return;" +
+            newLine +
+            "        }" +
+            newLine +
+            newLine +
+            "        sendAppLinkToJavaScript(data.toString(), 0);" +
+            newLine +
+            "    }" +
+            newLine +
+            newLine +
+            "    private void sendAppLinkToJavaScript(" +
+            newLine +
+            "            final String appLinkUrl," +
+            newLine +
+            "            final int retryCount) {" +
+            newLine +
+            newLine +
+            "        if (" +
+            newLine +
+            "                appView == null ||" +
+            newLine +
+            "                appView.getView() == null ||" +
+            newLine +
+            "                appView.getEngine() == null) {" +
+            newLine +
+            newLine +
+            "            if (retryCount < 30) {" +
+            newLine +
+            "                getWindow().getDecorView().postDelayed(" +
+            newLine +
+            "                        new Runnable() {" +
+            newLine +
+            "                            @Override" +
+            newLine +
+            "                            public void run() {" +
+            newLine +
+            "                                sendAppLinkToJavaScript(" +
+            newLine +
+            "                                        appLinkUrl," +
+            newLine +
+            "                                        retryCount + 1" +
+            newLine +
+            "                                );" +
+            newLine +
+            "                            }" +
+            newLine +
+            "                        }," +
+            newLine +
+            "                        300" +
+            newLine +
+            "                );" +
+            newLine +
+            "            }" +
+            newLine +
+            newLine +
+            "            return;" +
+            newLine +
+            "        }" +
+            newLine +
+            newLine +
+            "        appView.getView().postDelayed(" +
+            newLine +
+            "                new Runnable() {" +
+            newLine +
+            "                    @Override" +
+            newLine +
+            "                    public void run() {" +
+            newLine +
+            "                        String quotedUrl =" +
+            newLine +
+            "                                JSONObject.quote(appLinkUrl);" +
+            newLine +
+            newLine +
+            "                        String js =" +
+            newLine +
+            "                                \"window.mServicePendingUniversalLink = \" +" +
+            newLine +
+            "                                quotedUrl +" +
+            newLine +
+            "                                \";\" +" +
+            newLine +
+            "                                \"try {\"" +
+            newLine +
+            "                                + \"window.localStorage.setItem(\"" +
+            newLine +
+            "                                + \"'mServicePendingUniversalLink', \"" +
+            newLine +
+            "                                + quotedUrl" +
+            newLine +
+            "                                + \");\"" +
+            newLine +
+            "                                + \"} catch(e) {}\"" +
+            newLine +
+            "                                + \"if (window.handleOpenURL) {\"" +
+            newLine +
+            "                                + \"window.handleOpenURL(\"" +
+            newLine +
+            "                                + quotedUrl" +
+            newLine +
+            "                                + \");\"" +
+            newLine +
+            "                                + \"window.mServicePendingUniversalLink = '';\"" +
+            newLine +
+            "                                + \"try {\"" +
+            newLine +
+            "                                + \"window.localStorage.removeItem(\"" +
+            newLine +
+            "                                + \"'mServicePendingUniversalLink'\"" +
+            newLine +
+            "                                + \");\"" +
+            newLine +
+            "                                + \"} catch(e) {}\"" +
+            newLine +
+            "                                + \"}\";" +
+            newLine +
+            newLine +
+            "                        appView.getEngine()" +
+            newLine +
+            "                                .evaluateJavascript(js, null);" +
+            newLine +
+            "                    }" +
+            newLine +
+            "                }," +
+            newLine +
+            "                300" +
+            newLine +
+            "        );" +
+            newLine +
+            "    }" +
+            newLine +
+            "    // MService App Link Methods - END" +
+            newLine;
+
+        javaContent = insertBeforeFinalClassBrace(
+            javaContent,
+            helperMethodsBlock,
+            newLine
+        );
+    }
+
+    if (javaContent !== originalContent) {
+        fs.writeFileSync(
+            mainActivityPath,
+            javaContent,
+            "utf8"
+        );
+
+        console.log(
+            "[MService Deep Link] MainActivity.java configured: " +
+            mainActivityPath
+        );
+    } else {
+        console.log(
+            "[MService Deep Link] MainActivity.java already configured."
+        );
+    }
+}
+function escapeXmlText(value) {
+    return String(value)
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;");
+}
+
+function getIOSEntitlementPaths(projectRoot) {
+    var iosRoot;
+    var debugEntitlementPath;
+    var releaseEntitlementPath;
+
+    iosRoot = path.join(
+        projectRoot,
+        "platforms",
+        "ios"
+    );
+
+    if (!fs.existsSync(iosRoot)) {
+        throw new Error(
+            "The iOS platform directory was not found: " +
+            iosRoot
+        );
+    }
+
+    /*
+     * findFileRecursively was added during the Android
+     * MainActivity automation step.
+     */
+    debugEntitlementPath = findFileRecursively(
+        iosRoot,
+        "Entitlements-Debug.plist"
+    );
+
+    releaseEntitlementPath = findFileRecursively(
+        iosRoot,
+        "Entitlements-Release.plist"
+    );
+
+    if (debugEntitlementPath === "") {
+        throw new Error(
+            "Entitlements-Debug.plist was not found under " +
+            iosRoot
+        );
+    }
+
+    if (releaseEntitlementPath === "") {
+        throw new Error(
+            "Entitlements-Release.plist was not found under " +
+            iosRoot
+        );
+    }
+
+    return [
+        debugEntitlementPath,
+        releaseEntitlementPath
+    ];
+}
+
+function updateAssociatedDomainsEntitlement(
+    entitlementPath,
+    associatedDomain
+) {
+    var plistContent;
+    var originalContent;
+    var newLine;
+    var entitlementBlock;
+    var entitlementPattern;
+    var closingDictIndex;
+
+    plistContent = fs.readFileSync(
+        entitlementPath,
+        "utf8"
+    );
+
+    originalContent = plistContent;
+
+    newLine =
+        plistContent.indexOf("\r\n") !== -1
+            ? "\r\n"
+            : "\n";
+
+    if (
+        plistContent.indexOf("<plist") === -1 ||
+        plistContent.indexOf("<dict>") === -1
+    ) {
+        throw new Error(
+            "Invalid entitlement plist format: " +
+            entitlementPath
+        );
+    }
+
+    entitlementBlock =
+        "    <key>" +
+        "com.apple.developer.associated-domains" +
+        "</key>" +
+        newLine +
+        "    <array>" +
+        newLine +
+        "        <string>" +
+        escapeXmlText(associatedDomain) +
+        "</string>" +
+        newLine +
+        "    </array>";
+
+    /*
+     * Replace an existing Associated Domains entitlement.
+     * This prevents duplicates when cordova prepare runs again.
+     */
+    entitlementPattern =
+        /[ \t]*<key>\s*com\.apple\.developer\.associated-domains\s*<\/key>\s*<array>[\s\S]*?<\/array>/i;
+
+    if (entitlementPattern.test(plistContent)) {
+        plistContent = plistContent.replace(
+            entitlementPattern,
+            entitlementBlock
+        );
+    } else {
+        closingDictIndex = plistContent.lastIndexOf(
+            "</dict>"
+        );
+
+        if (closingDictIndex === -1) {
+            throw new Error(
+                "The closing </dict> was not found in: " +
+                entitlementPath
+            );
+        }
+
+        plistContent =
+            plistContent.substring(
+                0,
+                closingDictIndex
+            ) +
+            entitlementBlock +
+            newLine +
+            plistContent.substring(
+                closingDictIndex
+            );
+    }
+
+    if (plistContent !== originalContent) {
+        fs.writeFileSync(
+            entitlementPath,
+            plistContent,
+            "utf8"
+        );
+
+        console.log(
+            "[MService Deep Link] iOS entitlement updated: " +
+            entitlementPath
+        );
+    } else {
+        console.log(
+            "[MService Deep Link] iOS entitlement already configured: " +
+            entitlementPath
+        );
+    }
+}
+
+function configureIOSAssociatedDomains(
+    projectRoot,
+    configuration
+) {
+    var entitlementPaths;
+    var index;
+
+    if (
+        configuration.iosAssociatedDomain === undefined ||
+        configuration.iosAssociatedDomain === ""
+    ) {
+        throw new Error(
+            "MServiceIOSAssociatedDomain is required " +
+            "when preparing the iOS platform."
+        );
+    }
+
+    if (
+        configuration.iosAssociatedDomain.indexOf(
+            "applinks:"
+        ) !== 0
+    ) {
+        throw new Error(
+            "MServiceIOSAssociatedDomain must start " +
+            "with applinks:."
+        );
+    }
+
+    entitlementPaths = getIOSEntitlementPaths(
+        projectRoot
+    );
+
+    for (
+        index = 0;
+        index < entitlementPaths.length;
+        index += 1
+    ) {
+        updateAssociatedDomainsEntitlement(
+            entitlementPaths[index],
+            configuration.iosAssociatedDomain
+        );
+    }
+
+    console.log(
+        "[MService Deep Link] iOS Associated Domain configured: " +
+        configuration.iosAssociatedDomain
+    );
+}
+function configureIOSSceneDelegate(projectRoot) {
+    var pluginRoot;
+    var templatePath;
+    var iosRoot;
+    var sceneDelegatePath;
+    var templateContent;
+    var existingContent;
+
+    /*
+     * The hook file is located under:
+     * plugin-root/scripts/mservice-deeplink-setup.js
+     */
+    pluginRoot = path.resolve(
+        __dirname,
+        ".."
+    );
+
+    templatePath = path.join(
+        pluginRoot,
+        "templates",
+        "ios",
+        "SceneDelegate.swift"
+    );
+
+    if (!fs.existsSync(templatePath)) {
+        throw new Error(
+            "SceneDelegate.swift template was not found: " +
+            templatePath
+        );
+    }
+
+    iosRoot = path.join(
+        projectRoot,
+        "platforms",
+        "ios"
+    );
+
+    sceneDelegatePath = findFileRecursively(
+        iosRoot,
+        "SceneDelegate.swift"
+    );
+
+    if (sceneDelegatePath === "") {
+        throw new Error(
+            "Generated SceneDelegate.swift was not found under: " +
+            iosRoot
+        );
+    }
+
+    templateContent = fs.readFileSync(
+        templatePath,
+        "utf8"
+    );
+
+    existingContent = fs.readFileSync(
+        sceneDelegatePath,
+        "utf8"
+    );
+
+    if (existingContent === templateContent) {
+        console.log(
+            "[MService Deep Link] SceneDelegate.swift " +
+            "already configured: " +
+            sceneDelegatePath
+        );
+
+        return;
+    }
+
+    fs.writeFileSync(
+        sceneDelegatePath,
+        templateContent,
+        "utf8"
+    );
+
+    console.log(
+        "[MService Deep Link] SceneDelegate.swift configured: " +
+        sceneDelegatePath
+    );
+}
+module.exports = function (context) {
+    var options;
+    var cordovaOptions;
+    var platforms;
+    var projectRoot;
+    var configXmlPath;
+    var configXml;
+    var configuration;
+
+    try {
+        options = context.opts || {};
+        cordovaOptions = options.cordova || {};
+
+        platforms =
+            options.platforms ||
+            cordovaOptions.platforms ||
+            [];
+
+        projectRoot = options.projectRoot || "";
+
+        if (projectRoot === "") {
+            throw new Error(
+                "Cordova project root could not be determined."
+            );
+        }
+
+        configXmlPath = path.join(projectRoot, "config.xml");
+
+        if (!fs.existsSync(configXmlPath)) {
+            throw new Error(
+                "config.xml was not found at: " + configXmlPath
+            );
+        }
+
+        configXml = fs.readFileSync(configXmlPath, "utf8");
+
+        configuration = {
+            scheme: getPreferenceValue(
+                configXml,
+                "MServiceDeepLinkScheme"
+            ),
+            host: getPreferenceValue(
+                configXml,
+                "MServiceDeepLinkHost"
+            ),
+            path: normalizePath(
+                getPreferenceValue(
+                    configXml,
+                    "MServiceDeepLinkPath"
+                )
+            ),
+            iosAssociatedDomain: getPreferenceValue(
+                configXml,
+                "MServiceIOSAssociatedDomain"
+            )
+        };
+
+        validateConfiguration(configuration);
+
+        if (platforms.indexOf("android") !== -1) {
+            configureAndroidAppLink(
+                projectRoot,
+                configuration
+            );
+
+            configureAndroidMainActivity(
+                projectRoot
+            );
+        }
+        if (platforms.indexOf("ios") !== -1) {
+            configureIOSAssociatedDomains(
+                projectRoot,
+                configuration
+            );
+
+            configureIOSSceneDelegate(
+                projectRoot
+            );
+        }
+        console.log("");
+        console.log("================================================");
+        console.log("[MService Deep Link] Configuration validated");
+        console.log(
+            "[MService Deep Link] Platforms: " +
+            platforms.join(", ")
+        );
+        console.log(
+            "[MService Deep Link] Scheme: " +
+            configuration.scheme
+        );
+        console.log(
+            "[MService Deep Link] Host: " +
+            configuration.host
+        );
+        console.log(
+            "[MService Deep Link] Path: " +
+            configuration.path
+        );
+        console.log(
+            "[MService Deep Link] iOS Associated Domain: " +
+            (
+                configuration.iosAssociatedDomain ||
+                "Not configured"
+            )
+        );
+        console.log("================================================");
+        console.log("");
+
+        return Promise.resolve();
+    } catch (exception) {
+        console.error("");
+        console.error(
+            "[MService Deep Link] Hook failed: " +
+            exception.message
+        );
+        console.error("");
+
+        return Promise.reject(exception);
+    }
+};