react-native-swrve-plugin/lib/SwrveSDK.js

React Native Plugin for Swrve

import { NativeModules, NativeEventEmitter } from 'react-native';
const { SwrvePlugin } = NativeModules;

class SwrveSDK {
    static PUSH_EVENT_NAME = 'PushNotification';
    static SILENT_PUSH_EVENT_NAME = 'SilentPushNotification';
    static PUSH_EVENT_PAYLOAD = 'PushEventPayload';
    static CALLBACK_KEY_EMBEDDED_MESSAGE_PERSONALIZATION_PROPERTIES_MAP = "embeddedMessagePersonalizationProperties";
    static CALLBACK_KEY_EMBEDDED_MESSAGE_MAP = "embeddedMessage";
    static CALLBACK_KEY_EMBEDDED_CONTROL_ACTION = 'embeddedMessageIsControl';

    static CALLBACK_KEY_MESSAGE_DETAIL_MAP = "messageDetail";
    static CALLBACK_KEY_MESSAGE_DETAIL_SELECTED_BUTTON = 'messageDetailSelectedButton';
    static CALLBACK_KEY_MESSAGE_DETAIL_ACTION = 'messageDetailAction';

    static CALLBACK_KEY_DEEPLINK_ACTION_STRING = 'deeplinkDelegateActionString';

    static RESOURCES_UPDATED_EVENT_NAME = 'SwrveUserResourcesUpdated';
    static EMBEDDED_CALLBACK_EVENT_NAME = 'SwrveEmbeddedCallback';
    static MESSAGE_DETAILS_DELEGATE_EVENT_NAME = 'SwrveMessageDetailsDelegate';
    static DEEPLINK_DELEGATE_EVENT_NAME = 'SwrveMessageDeeplinkDelegate';
    static PUSHINBOX_UPDATE_EVENT_NAME = 'SwrvePushInboxUpdate'; 
    
    Notifications = {
        // Notification types
    };

    _eventEmitter;
    _eventHandlers = {};
    _pushListener = null;
    _silentPushListener = null;
    _userResourcesListener = null;
    _embeddedCampaignListener = null;
    _inAppMessageListener = null;
    _deeplinkListener = null;
    _pushInboxUpdateListener = null;

    constructor(listener) {
        this._eventEmitter = new NativeEventEmitter(NativeModules.SwrvePluginEventEmitter);
    }

    // This method doesn't get passed to the native-side
    setListeners(listeners,
        pushListeners) {
        // Remove any pre-existing handlers in case this function has been called already
        if (this._eventHandlers.pushEventHandler) {
            this._eventHandlers.pushEventHandler.remove();
        }

        if (this._eventHandlers.silentPushEventHandler) {
            this._eventHandlers.silentPushEventHandler.remove();
        }

        if (this._eventHandlers.resourceUpdatedEventHandler) {
            this._eventHandlers.resourceUpdatedEventHandler.remove();
        }

        if (listeners) {
            // SwrveListeners
            this._userResourcesListener = listeners.userResourcesUpdatedListener;
            if (listeners.userResourcesUpdatedListener) {
                this._eventHandlers.resourceUpdatedEventHandler = this._eventEmitter.addListener(
                    SwrveSDK.RESOURCES_UPDATED_EVENT_NAME,
                    (event) => {
                        if (this._pushListener) {
                            console.log('SwrveSDK - pushListener - push');
                            this._userResourcesListener();
                        }
                    }
                );
            }            
        }

        if (pushListeners) {
            // PushListeners
            this._pushListener = pushListeners.pushListener;
            this._silentPushListener = pushListeners.silentPushListener;

            if (pushListeners.pushListener) {
                this._eventHandlers.pushEventHandler = this._eventEmitter.addListener(
                    SwrveSDK.PUSH_EVENT_NAME,
                    (event) => {
                        if (this._pushListener) {
                            console.log('SwrveSDK - pushListener - push');
                            this._pushListener(event[SwrveSDK.PUSH_EVENT_PAYLOAD]);
                        }
                    }
                );
            }

            if (pushListeners.silentPushListener) {
                this._eventHandlers.silentPushEventHandler = this._eventEmitter.addListener(
                    SwrveSDK.SILENT_PUSH_EVENT_NAME,
                    (event) => {
                        if (this._silentPushListener) {
                            console.log('SwrveSDK - pushListener - silent push');
                            this._silentPushListener(event[SwrveSDK.PUSH_EVENT_PAYLOAD]);
                        }
                    }
                );
            }
        }

        SwrvePlugin.startedListening();
    }

    setEmbeddedCampaignListener(embeddedCampaignListeners) {
        if (this._eventHandlers.embeddedCampaignListener) {
            this._eventHandlers.embeddedCampaignListener.remove();
        }

        if (embeddedCampaignListeners) {
            this._embeddedCampaignListener = embeddedCampaignListeners.embeddedCampaignListener

            if (embeddedCampaignListeners.embeddedCampaignListener) {
                this._eventHandlers.embeddedCampaignListener = this._eventEmitter.addListener(
                    SwrveSDK.EMBEDDED_CALLBACK_EVENT_NAME,
                    (event) => {
                        console.log('SwrveSDK - embeddedCampaignListener');
                        this._embeddedCampaignListener(
                            event[SwrveSDK.CALLBACK_KEY_EMBEDDED_MESSAGE_MAP],
                            event[SwrveSDK.CALLBACK_KEY_EMBEDDED_MESSAGE_PERSONALIZATION_PROPERTIES_MAP],
                            event[SwrveSDK.CALLBACK_KEY_EMBEDDED_CONTROL_ACTION]
                        );
                    }
                );
            }

            SwrvePlugin.startedEmbeddedListening();
        }
    }

    setInAppMessageListener(inAppMessageListeners) {
        if (this._eventHandlers.inAppMessageListener) {
            this._eventHandlers.inAppMessageListener.remove();
        }

        if (inAppMessageListeners) {
            this._inAppMessageListener = inAppMessageListeners.inAppMessageListener
            if (inAppMessageListeners.inAppMessageListener) {
                this._eventHandlers.inAppMessageListener = this._eventEmitter.addListener(
                    SwrveSDK.MESSAGE_DETAILS_DELEGATE_EVENT_NAME,
                    (event) => {
                        console.log('SwrveSDK - inAppMessageListener');
                        this._inAppMessageListener(
                            event[SwrveSDK.CALLBACK_KEY_MESSAGE_DETAIL_ACTION],
                            event[SwrveSDK.CALLBACK_KEY_MESSAGE_DETAIL_MAP],
                            event[SwrveSDK.CALLBACK_KEY_MESSAGE_DETAIL_SELECTED_BUTTON]
                        );
                    }
                );
            }
        }
    }

    setDeeplinkListener(deeplinkListeners) {
        if (this._eventHandlers.deeplinkListener) {
            this._eventHandlers.deeplinkListener.remove();
        }

        if (deeplinkListeners !== null) {
            this._deeplinkListener = deeplinkListeners.deeplinkListener

            if (deeplinkListeners.deeplinkListener) {

                SwrvePlugin.listeningDeeplink();
    
                this._eventHandlers.deeplinkListener = this._eventEmitter.addListener(
                    SwrveSDK.DEEPLINK_DELEGATE_EVENT_NAME,
                    (event) => {
                        console.log('SwrveSDK - deeplinkListener');
                        this._deeplinkListener(
                            event[SwrveSDK.CALLBACK_KEY_DEEPLINK_ACTION_STRING],
                        );
                    }
                );
            }
        }
    }

    setPushInboxUpdateListener(pushInboxUpdateListeners) {
        if (this._eventHandlers.pushInboxUpdateListener) {
            this._eventHandlers.pushInboxUpdateListener.remove();
        }

        if (pushInboxUpdateListeners !== null) {
            this._pushInboxUpdateListener = pushInboxUpdateListeners.pushInboxUpdateListener;

            if (pushInboxUpdateListeners.pushInboxUpdateListener) {

                SwrvePlugin.listeningPushInboxUpdate();

                this._eventHandlers.pushInboxUpdateListener = this._eventEmitter.addListener(
                    SwrveSDK.PUSHINBOX_UPDATE_EVENT_NAME,
                    (event) => {
                        if (this._pushInboxUpdateListener) {
                            console.log('SwrveSDK - pushInboxUpdateListener');
                            this._pushInboxUpdateListener();
                        }
                    }
                );
            }
        }
    }

    start(userId) {
        if (userId && userId !== '') {
            SwrvePlugin.start(userId);
        } else {
            SwrvePlugin.start(null);
        }
    }

    async identify(userIdentity) {
        return SwrvePlugin.identify(userIdentity);
    }

    userUpdate(attributes) {
        SwrvePlugin.userUpdate(attributes);
    }

    userUpdateDate(name, date) {
        SwrvePlugin.userUpdateDate(name, date.toISOString());
    }

    event(eventName, eventPayload = null) {
        SwrvePlugin.event(eventName, eventPayload);
    }

    sendQueuedEvents() {
        SwrvePlugin.sendQueuedEvents();
    }

    refreshCampaignsAndResources() {
        SwrvePlugin.refreshCampaignsAndResources();
    }

    currencyGiven(currency, quantity) {
        SwrvePlugin.currencyGiven(currency, quantity);
    }

    purchase(itemName, currency, quantity, cost) {
        SwrvePlugin.purchase(itemName, currency, quantity, cost);
    }

    unvalidatedIap(localCost, localCurrency, productId, quantity) {
        SwrvePlugin.unvalidatedIap(localCost, localCurrency, productId, quantity);
    }

    unvalidatedIapWithReward(localCost, localCurrency, productId, quantity, reward) {
        SwrvePlugin.unvalidatedIapWithReward(localCost, localCurrency, productId, quantity, reward);
    }

    async isStarted() {
        return SwrvePlugin.isStarted();
    }

    async getApiKey() {
        return SwrvePlugin.getApiKey();
    }

    async getUserId() {
        return SwrvePlugin.getUserId();
    }

    async getExternalUserId() {
        return SwrvePlugin.getExternalUserId();
    }

    async getUserResources() {
        return SwrvePlugin.getUserResources();
    }

    async getUserResourcesDiff() {
        return SwrvePlugin.getUserResourcesDiff();
    }

    async getRealTimeUserProperties() {
        return SwrvePlugin.getRealTimeUserProperties();
    }

    async getMessageCenterCampaigns(personalization) {
        return SwrvePlugin.getMessageCenterCampaigns(personalization);
    }

    async getMessageCenterCampaign(campaignId, personalization) {
        return SwrvePlugin.getMessageCenterCampaign(campaignId, personalization);
    }

    async getPersonalizedText(text, personalizationProperties) {
        return SwrvePlugin.getPersonalizedText(text, personalizationProperties);
    }

    async getPersonalizedEmbeddedMessageData(campaignId, personalizationProperties) {
        return SwrvePlugin.getPersonalizedEmbeddedMessageData(campaignId, personalizationProperties);
    }

    async showMessageCenterCampaign(campaignId, personalization) {
        return SwrvePlugin.showMessageCenterCampaign(campaignId, personalization);
    }

    async removeMessageCenterCampaign(campaignId) {
        return SwrvePlugin.removeMessageCenterCampaign(campaignId);
    }

    async markMessageCenterCampaignAsSeen(campaignId) {
        return SwrvePlugin.markMessageCenterCampaignAsSeen(campaignId);
    }

    async markEmbeddedMessageCampaignAsSeen(campaignId) {
        return SwrvePlugin.markEmbeddedMessageCampaignAsSeen(campaignId);
    }

    async embeddedControlMessageImpressionEvent(campaignId) {
        return SwrvePlugin.embeddedControlMessageImpressionEvent(campaignId)
    }

    async markEmbeddedMessageButtonAsPressed(campaignId, button) {
        return SwrvePlugin.markEmbeddedMessageButtonAsPressed(campaignId, button);
    }

    async stopTracking() {
        return SwrvePlugin.stopTracking();
    }

    async getPushInboxMessages() {
        return SwrvePlugin.getPushInboxMessages();
    }

    async engagePushInboxMessage(messageId) {
        return SwrvePlugin.engagePushInboxMessage(messageId);
    }

    async readPushInboxMessage(messageId) {
        return SwrvePlugin.readPushInboxMessage(messageId);
    }

    async deletePushInboxMessage(messageId) {
        return SwrvePlugin.deletePushInboxMessage(messageId);
    }
}

module.exports = new SwrveSDK();