Use the JavaScript SDK with cross-platform apps

npm install @comapi/sdk-js-foundation --save

import { Foundation, ComapiConfig, IAuthChallengeOptions } from "@comapi/sdk-js-foundation";

<!-- Full version -->
<script src="scripts/comapi-foundation.js"></script>

<!-- Minified version -->
<script src="scripts/comapi-foundation.min.js"></script>

<allow-navigation href="https://*.comapi.com/*" />

<meta http-equiv="Content-Security-Policy" content="default-src 'self' data: gap: https://ssl.gstatic.com 'unsafe-eval'; style-src 'self' 'unsafe-inline'; media-src *; img-src 'self' data: content:;connect-src https://api.comapi.com:*">

var comapiConfig = new COMAPI.ComapiConfig();

var comapiConfig = new COMAPI.ComapiConfig()
    .withApiSpace(appConfig.apiSpaceId);

var comapiConfig = new COMAPI.ComapiConfig()
    .withApiSpace(appConfig.apiSpaceId)
    .withAuthChallenge(challengeHandler);

var comapiConfig = new COMAPI.ComapiConfig()
    .withApiSpace(appConfig.apiSpaceId)
    .withAuthChallenge(challengeHandler)
    .withLogLevel(COMAPI.LogLevels.Warn);

COMAPI.Foundation.initialise(comapiConfig)
    .then(function (sdk) {
        console.log("Foundation interface created", sdk);
    })
    .catch(function (error) {
        console.error("Failed to initialise", error);
    });

import { PushNotifications } from '@capacitor/push-notifications';

async function registerForPush() {
    let status = await PushNotifications.checkPermissions();

    if (status.receive === 'prompt') {
        status = await PushNotifications.requestPermissions();
    }

    if (status.receive !== 'granted') {
        // The user declined. Do not register.
        return;
    }

    // This triggers the 'registration' listener with the native device token.
    await PushNotifications.register();
}

function ensureAndroidNotificationPermission(onComplete) {
    // Only Android 13 (API 33) and later need this permission.
    if (!cordova.plugins || !cordova.plugins.permissions) {
        onComplete();
        return;
    }

    var permissions = cordova.plugins.permissions;
    var permission = permissions.POST_NOTIFICATIONS;

    permissions.checkPermission(permission, function (status) {
        if (status.hasPermission) {
            onComplete();
        } else {
            permissions.requestPermission(permission, onComplete, onComplete);
        }
    }, onComplete);
}

import { Environment } from "@comapi/sdk-js-foundation";
import { Push } from 'ionic-native';

const NATIVE_PUSH_TOKEN = "app.nativePushToken";

// Set the APNS environment from your build configuration, not by hand.
const APNS_ENVIRONMENT = isProductionBuild ? Environment.production : Environment.development;

// Platform ready event handler
platform.ready().then(() => {
    // Initialise the Ionic push plugin, or the equivalent for your framework.
    let push = Push.init({
        // For Android apps
        android: { senderID: 'Your_Project_ID' },
        // For iOS apps
        ios: {
            alert: "true",
            badge: true,
            sound: 'false'
        }
    });

    // Handle the native push tokens that arrive asynchronously.
    push.on('registration', (data) => {
        console.log("Got a native push token: ", data.registrationId);

        // Store the native token, so that you can reuse it at each launch.
        localStorage.setItem(NATIVE_PUSH_TOKEN, data.registrationId);

        // Register the push token with the SDK.
        registerNativeToken();
    });

    // Error handling for the push plugin
    push.on('error', (error) => {
        console.error('Error with Push plugin', error);
    });

    // Your own push notification handling, if you need it.
    push.on('notification', (data) => {
        console.log("got a push notification", data);
    });

    // Try to register a native push token.
    registerNativeToken();
});

function registerNativeToken() {
    // Retrieve the stored native push token.
    let registrationId = localStorage.getItem(NATIVE_PUSH_TOKEN);

    // Skip if the registrationId has not arrived yet.
    if (!registrationId) {
        console.log("No native push token available yet");
        return;
    }

    // Call a different method for each operating system.
    if (platform.is('ios')) {
        // The bundle ID must match the value in your push notification profile
        // in Dotdigital Marketing, and the environment must match your build type.
        sdk.device.setAPNSPushDetails("<Bundle Id>", APNS_ENVIRONMENT, registrationId)
            .then(result => {
                console.log("setAPNSPushDetails() succeeded", result);
            })
            .catch(error => {
                console.error("setAPNSPushDetails() failed", error);
            });

    } else if (platform.is('android')) {
        // The package name must match the value in your push notification profile
        // in Dotdigital Marketing.
        sdk.device.setFCMPushDetails("<Package Name>", registrationId)
            .then(result => {
                console.log("setFCMPushDetails() succeeded", result);
            })
            .catch(error => {
                console.error("setFCMPushDetails() failed", error);
            });
    }
}

const NATIVE_PUSH_TOKEN = "app.nativePushToken";

// Set the APNS environment from your build configuration, not by hand.
var APNS_ENVIRONMENT = isProductionBuild ? COMAPI.Environment.production : COMAPI.Environment.development;

// Platform ready event handler
platform.ready().then(function () {
    // Initialise the push plugin, or the equivalent for your framework.
    var push = PushNotification.init({
        // For Android apps
        android: { senderID: 'Your_Project_ID' },
        // For iOS apps
        ios: {
            alert: "true",
            badge: true,
            sound: 'false'
        }
    });

    // Handle the native push tokens that arrive asynchronously.
    push.on('registration', function (data) {
        console.log("Got a native push token: ", data.registrationId);

        // Store the native token, so that you can reuse it at each launch.
        localStorage.setItem(NATIVE_PUSH_TOKEN, data.registrationId);

        // Register the push token with the SDK.
        registerNativeToken();
    });

    // Error handling for the push plugin
    push.on('error', function (error) {
        console.error('Error with Push plugin', error);
    });

    // Your own push notification handling, if you need it.
    push.on('notification', function (data) {
        console.log("got a push notification", data);
    });

    // Try to register a native push token.
    registerNativeToken();
});

function registerNativeToken() {
    // Retrieve the stored native push token.
    var registrationId = localStorage.getItem(NATIVE_PUSH_TOKEN);

    // Skip if the registrationId has not arrived yet.
    if (!registrationId) {
        console.log("No native push token available yet");
        return;
    }

    // Call a different method for each operating system.
    if (platform.is('ios')) {
        sdk.device.setAPNSPushDetails("<Bundle Id>", APNS_ENVIRONMENT, registrationId)
            .then(function (result) {
                console.log("setAPNSPushDetails() succeeded", result);
            })
            .catch(function (error) {
                console.error("setAPNSPushDetails() failed", error);
            });

    } else if (platform.is('android')) {
        sdk.device.setFCMPushDetails("<Package Name>", registrationId)
            .then(function (result) {
                console.log("setFCMPushDetails() succeeded", result);
            })
            .catch(function (error) {
                console.error("setFCMPushDetails() failed", error);
            });
    }
}

import { PushNotifications } from '@capacitor/push-notifications';
import { Capacitor } from '@capacitor/core';
import { Environment } from '@comapi/sdk-js-foundation';

const NATIVE_PUSH_TOKEN = 'app.nativePushToken';

// Set the APNS environment from your build configuration, not by hand.
const APNS_ENVIRONMENT = isProductionBuild ? Environment.production : Environment.development;

// token.value is the native APNS or FCM token, already formatted correctly.
PushNotifications.addListener('registration', (token) => {
    localStorage.setItem(NATIVE_PUSH_TOKEN, token.value);
    registerNativeToken();
});

PushNotifications.addListener('registrationError', (error) => {
    console.error('Push registration failed', error);
});

async function registerNativeToken() {
    const registrationId = localStorage.getItem(NATIVE_PUSH_TOKEN);
    if (!registrationId) {
        return;
    }

    try {
        if (Capacitor.getPlatform() === 'ios') {
            await sdk.device.setAPNSPushDetails('<Bundle Id>', APNS_ENVIRONMENT, registrationId);
        } else if (Capacitor.getPlatform() === 'android') {
            await sdk.device.setFCMPushDetails('<Package Name>', registrationId);
        }
    } catch (error) {
        console.error('Failed to register push token with the SDK', error);
    }
}

PushNotifications.addListener('pushNotificationActionPerformed', (action) => {
    // Pass the whole notification, not action.notification.data.
    sdk.handlePushAndGetMessageDetails(action.notification)
        .then((details) => {
            if (details.ddOriginated && details.url) {
                // Report done. Your app must open the link itself.
            }
        })
        .catch((error) => console.error(error));
});

import * as Notifications from 'expo-notifications';
import { Platform } from 'react-native';
import { Environment } from '@comapi/sdk-js-foundation';

const APNS_ENVIRONMENT = isProductionBuild ? Environment.production : Environment.development;

async function registerNativeToken() {
    const { status } = await Notifications.requestPermissionsAsync();
    if (status !== 'granted') {
        return;
    }

    // getDevicePushTokenAsync returns the native token. Do not use
    // getExpoPushTokenAsync here.
    const devicePushToken = await Notifications.getDevicePushTokenAsync();
    const registrationId = devicePushToken.data;

    try {
        if (Platform.OS === 'ios') {
            await sdk.device.setAPNSPushDetails('<Bundle Id>', APNS_ENVIRONMENT, registrationId);
        } else if (Platform.OS === 'android') {
            await sdk.device.setFCMPushDetails('<Package Name>', registrationId);
        }
    } catch (error) {
        console.error('Failed to register push token with the SDK', error);
    }
}

import { PushNotifications } from '@capacitor/push-notifications';
import { Capacitor } from '@capacitor/core';

async function createDefaultChannel() {
    if (Capacitor.getPlatform() !== 'android') {
        return;
    }

    await PushNotifications.createChannel({
        id: 'default',
        name: 'Default',
        description: 'Default push notifications',
        importance: 4,
        visibility: 1
    });
}

// some app specific imports
import { AppSettings } from "../settings";
import { AuthService } from "./auth";

// Comapi class and interface imports
import { Foundation, ComapiConfig, IAuthChallengeOptions } from "@comapi/sdk-js-foundation"

export class ComapiService {

    public sdk: Foundation;

    private challengeHandler(options: IAuthChallengeOptions, answerAuthenticationChallenge) {
        this._authService.getToken(options.nonce)
            .then((token) => {
                answerAuthenticationChallenge(token);
            });
    }

    constructor(private _authService: AuthService) { }

    /**
     * Public method that encapsulates the initialisation of Comapi
     */
    public initialise(): Promise<Foundation> {

        return new Promise((resolve, reject) => {

            if (this._authService.isAuthenticated()) {

                let comapiConfig = new ComapiConfig()
                    .withApiSpace(AppSettings.APP_SPACE_ID)
                    // Bind this pointer, so that the authChallenge callback can
                    // access this._authService.
                    .withAuthChallenge(this.challengeHandler.bind(this));

                Foundation.initialise(comapiConfig)
                    .then((sdk) => {
                        this.sdk = sdk;
                        console.log("foundation interface created");
                        resolve(sdk);
                    })
                    .catch((error) => {
                        console.error("initialise failed", error);
                        reject(error);
                    });
            } else {
                reject("Not logged in");
            }
        });
    }
}

push.on('notification', (data) => {
    sdk.handlePushAndGetMessageDetails(data)
        .then((details) => {
            if (!details.ddOriginated) {
                // Another system sent this message. Handle it your own way.
                return;
            }
            if (details.url) {
                // The tap is now reported. Your app must open the link itself.
                console.log("Deep link: ", details.url);
            }
        })
        .catch((error) => {
            console.error("Failed to handle push message", error);
        });
});

import { Push } from 'ionic-native';

let push = Push.init({
    // For Android apps
    android: {
        senderID: 'Your_Project_ID',
        forceShow: true
    }
});

const push = PushNotification.init({
    // For Android apps
    android: {
        senderID: 'Your_Project_ID',
        forceShow: true
    }
});

cordova plugin add @comapi/cordova-plugin-dotdigital-pushutils

push.on('notification', (data) => {
    // Is there a deep link to process?
    if (cordova && cordova.plugins && cordova.plugins.dotdigitalPlugin) {
        // You do not need to call containsLink. It is safe to call handleLink for
        // all notifications. containsLink is available if you want to apply your
        // own logic first.

        if (cordova.plugins.dotdigitalPlugin.containsLink(data)) {
            cordova.plugins.dotdigitalPlugin.handleLink(data)
                .then(() => {
                    console.log("Deep link handled");
                })
                .catch((error) => {
                    console.log("Issue handling deep link", error);
                });
        }
    }
});

cordova plugin add cordova-plugin-customurlscheme --variable URL_SCHEME=yourUrlScheme

function handleOpenURL(url) {
    setTimeout(function() {
      console.log(`handleOpenUrl(${url})`);
      // Route to the correct screen in your app.
    }, 0);
}

<intent-filter>
  <data android:scheme="yourUrlScheme"/>
  <action android:name="android.intent.action.VIEW" />
  <category android:name="android.intent.category.DEFAULT" />
  <category android:name="android.intent.category.BROWSABLE" />
</intent-filter>

<platform name="android">
   <allow-intent href="yourUrlScheme:*" />
</platform>