@selligent-marketing-cloud/selligent-react-native 3.0.0 → 3.2.6

package/android/src/main/java/com/selligent/RNSelligent.java

@@ -6,6 +6,9 @@ import android.app.Application;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.content.res.Resources;
+
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.lifecycle.Observer;
 import androidx.localbroadcastmanager.content.LocalBroadcastManager;
 
 import android.graphics.Color;
@@ -28,7 +31,6 @@ import com.facebook.react.modules.core.DeviceEventManagerModule;
 import com.google.gson.Gson;
 import com.google.gson.reflect.TypeToken;
 import com.selligent.sdk.SMCallback;
-import com.selligent.sdk.SMDeviceInfos;
 import com.selligent.sdk.SMEvent;
 import com.selligent.sdk.SMForegroundGcmBroadcastReceiver;
 import com.selligent.sdk.SMInAppMessage;
@@ -36,6 +38,7 @@ import com.selligent.sdk.SMInAppMessageReturn;
 import com.selligent.sdk.SMInAppRefreshType;
 import com.selligent.sdk.SMManager;
 import com.selligent.sdk.SMNotificationButton;
+import com.selligent.sdk.SMNotificationMessage;
 import com.selligent.sdk.SMRemoteMessageDisplayType;
 import com.selligent.sdk.SMSettings;
 
@@ -48,9 +51,12 @@ public class RNSelligent extends ReactContextBaseJavaModule implements Lifecycle
     private final SMManager smManager;
     private EventReceiver eventReceiver;
     private SMForegroundGcmBroadcastReceiver receiver;
+    private static SMInAppRefreshType inAppMessageRefreshType;
 
     public static final String REACT_CLASS = "SelligentReactNative"; // for logging purposes
 
+    private boolean areObserverStarted = false;
+
 
     public RNSelligent(ReactApplicationContext reactContext) {
         super(reactContext);
@@ -75,8 +81,10 @@ public class RNSelligent extends ReactContextBaseJavaModule implements Lifecycle
             final String notificationActivityName = settings.getActivityName();
 
             SMManager.NOTIFICATION_ACTIVITY = (Class<? extends Activity>) Class.forName(notificationActivityName);
+            inAppMessageRefreshType = settings.getInAppMessageRefreshType().getSmInAppRefreshType();
 
             final SMManager smManager = SMManager.getInstance();
+            SMManager.DEBUG = BuildConfig.BUILD_TYPE.equals("debug");
             smManager.start(smSettings, application);
 
             final Resources resources = application.getResources();
@@ -120,16 +128,18 @@ public class RNSelligent extends ReactContextBaseJavaModule implements Lifecycle
     @ReactMethod
     public void enableInAppMessages(ReadableMap enabled) {
         final ReadableType enabledType = enabled.getType("enabled");
+
         if (enabledType == ReadableType.Boolean) {
             enableInAppMessages(enabled.getBoolean("enabled"));
-        } else if (enabledType == ReadableType.Number) {
+        } 
+        else if (enabledType == ReadableType.Number) {
             enableInAppMessages(enabled.getInt("enabled"));
         }
     }
 
     private void enableInAppMessages(Boolean enable) {
         if (enable) {
-            smManager.enableInAppMessages(SMInAppRefreshType.Daily);
+            smManager.enableInAppMessages(inAppMessageRefreshType);
         } else {
             smManager.disableInAppMessages();
         }
@@ -153,7 +163,7 @@ public class RNSelligent extends ReactContextBaseJavaModule implements Lifecycle
         final Activity currentActivity = getCurrentActivity();
 
         if (currentActivity != null) {
-            smManager.displayMessage(messageId, currentActivity);
+            smManager.displayInAppMessage(messageId, currentActivity);
         }
     }
 
@@ -187,7 +197,6 @@ public class RNSelligent extends ReactContextBaseJavaModule implements Lifecycle
                             buttonMap.putString("id", button.id);
                             buttonMap.putString("value", button.value);
                             buttonMap.putString("label", button.label);
-                            buttonMap.putInt("action", button.action.getValue());
                             buttonMap.putInt("type", button.type);
 
                             buttonsArray.pushMap(buttonMap);
@@ -206,18 +215,54 @@ public class RNSelligent extends ReactContextBaseJavaModule implements Lifecycle
 
     @ReactMethod
     public void setInAppMessageAsSeen(final String messageId, final Callback successCallback, final Callback errorCallback) {
-        smManager.getInAppMessages(new SMInAppMessageReturn() {
-            @Override
-            public void onRetrieve(ArrayList<SMInAppMessage> inAppMessages) {
-                for(SMInAppMessage message : inAppMessages) {
-                    if(message.id.equals(messageId)) {
-                        smManager.setInAppMessageAsSeen(message);
-                        successCallback.invoke();
-                        return;
-                    }
+        smManager.getInAppMessages(inAppMessages ->
+        {
+            for(SMInAppMessage message : inAppMessages)
+            {
+                if(message.id.equals(messageId))
+                {
+                    smManager.setInAppMessageAsSeen(message);
+                    successCallback.invoke();
+                    return;
                 }
-                errorCallback.invoke(String.format("No message with id %s found", messageId));
             }
+            errorCallback.invoke(String.format("No message with id %s found", messageId));
+        });
+    }
+
+    @ReactMethod
+    public void setInAppMessageAsUnseen(final String messageId, final Callback successCallback, final Callback errorCallback)
+    {
+        smManager.getInAppMessages(inAppMessages ->
+        {
+            for(SMInAppMessage message : inAppMessages)
+            {
+                if(message.id.equals(messageId))
+                {
+                    smManager.setInAppMessageAsUnseen(message);
+                    successCallback.invoke();
+                    return;
+                }
+            }
+            errorCallback.invoke(String.format("No message with id %s found", messageId));
+        });
+    }
+
+    @ReactMethod
+    public void setInAppMessageAsDeleted(final String messageId, final Callback successCallback, final Callback errorCallback)
+    {
+        smManager.getInAppMessages(inAppMessages ->
+        {
+            for(SMInAppMessage message : inAppMessages)
+            {
+                if(message.id.equals(messageId))
+                {
+                    smManager.deleteInAppMessage(messageId);
+                    successCallback.invoke();
+                    return;
+                }
+            }
+            errorCallback.invoke(String.format("No message with id %s found", messageId));
         });
     }
 
@@ -249,21 +294,6 @@ public class RNSelligent extends ReactContextBaseJavaModule implements Lifecycle
         SMManager.DEBUG = enable;
     }
 
-    @ReactMethod
-    public void enableGeolocation(Boolean enable) {
-        if (enable) {
-            smManager.enableGeolocation();
-        } else {
-            smManager.disableGeolocation();
-        }
-    }
-
-    @ReactMethod
-    public void isGeolocationEnabled(Callback successCallback) {
-        final Boolean isGeolocationEnabled = smManager.isGeolocationEnabled();
-        successCallback.invoke(isGeolocationEnabled);
-    }
-
     @ReactMethod
     public void sendEvent(ReadableMap eventMap, final Callback successCallback, final Callback errorCallback) {
         final Event event = Event.fromHashMap(eventMap.toHashMap());
@@ -298,25 +328,29 @@ public class RNSelligent extends ReactContextBaseJavaModule implements Lifecycle
     }
 
     @ReactMethod
-    public void displayLastReceivedRemotePushNotification() {
+    public void displayLastReceivedRemotePushNotification(String templateId) {
         final Activity currentActivity = getCurrentActivity();
 
         if (currentActivity != null) {
-            smManager.displayLastReceivedRemotePushNotification(currentActivity);
+            smManager.displayLastReceivedNotificationContent(currentActivity);
         }
     }
 
+    @ReactMethod
+    public void displayLastReceivedNotification()
+    {
+        smManager.displayLastReceivedNotification();
+    }
+
     @ReactMethod
     public void getLastRemotePushNotification(Callback successCallback) {
-        final HashMap<String, String> notificationMap = smManager.getLastRemotePushNotification();
+        final SMNotificationMessage notification = smManager.retrieveLastReceivedNotificationContent();
 
         WritableMap resultingNotificationMap = new WritableNativeMap();
-        if (notificationMap != null) {
-            final String id = notificationMap.get("id");
-            final String title = notificationMap.get("title");
-
-            resultingNotificationMap.putString("id", id);
-            resultingNotificationMap.putString("title", title);
+        
+        if (notification != null) {
+            resultingNotificationMap.putString("id", notification.getId());
+            resultingNotificationMap.putString("title", notification.getNotificationTitle());
         }
 
         successCallback.invoke(resultingNotificationMap);
@@ -393,31 +427,136 @@ public class RNSelligent extends ReactContextBaseJavaModule implements Lifecycle
     public void subscribeToEvents(ReadableArray customEvents) {
         final Activity currentActivity = getCurrentActivity();
 
-        if (currentActivity != null) {
+        if (currentActivity != null)
+        {
+            if (currentActivity instanceof AppCompatActivity)
+            {
+                AppCompatActivity thisActivity = (AppCompatActivity)currentActivity;
+                DeviceEventManagerModule.RCTDeviceEventEmitter rctDeviceEventEmitter = reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class);
+
+                thisActivity.runOnUiThread(() -> {
+                    if (!areObserverStarted)
+                    {
+                        Log.d("RNSelligent", "Instantiating the observers on the UI thread");
+
+                        // Token received
+                        final Observer<String> tokenObserver = token -> {
+                            String eventName = BroadcastEventType.ReceivedGCMToken.getBroadcastEventType();
+                            GCMTokenBroadcastEventDataParser broadcastEventDataParser = new GCMTokenBroadcastEventDataParser();
+                            final WritableMap data = broadcastEventDataParser.wrap(token);
+                            rctDeviceEventEmitter.emit(eventName, getBroadcastData(eventName, data));
+                        };
+                        SMManager.getInstance().getObserverManager().observeToken(thisActivity, tokenObserver);
+
+                        // Device id received
+                        final Observer<String> deviceIdObserver = deviceId -> {
+                            String eventName = BroadcastEventType.ReceivedDeviceId.getBroadcastEventType();
+                            DeviceIdBroadcastEventDataParser broadcastEventDataParser = new DeviceIdBroadcastEventDataParser();
+                            final WritableMap data = broadcastEventDataParser.wrap(deviceId);
+                            rctDeviceEventEmitter.emit(eventName, getBroadcastData(eventName, data));
+                        };
+                        SMManager.getInstance().getObserverManager().observeDeviceId(thisActivity, deviceIdObserver);
+
+                        // InApp messages received
+                        final Observer<SMInAppMessage[]> inAppMessageObserver = inAppMessages -> {
+                            if (inAppMessages != null)
+                            {
+                                String eventName = BroadcastEventType.ReceivedInAppMessage.getBroadcastEventType();
+                                InAppMessageBroadcastEventDataParser broadcastEventDataParser = new InAppMessageBroadcastEventDataParser();
+                                final WritableMap data = broadcastEventDataParser.wrap(inAppMessages);
+                                rctDeviceEventEmitter.emit(eventName, getBroadcastData(eventName, data));
+                            }
+                        };
+                        SMManager.getInstance().getObserverManager().observeInAppMessages(thisActivity, inAppMessageObserver);
+
+                        // Button clicked
+                        final Observer<SMNotificationButton> clickedButtonObserver = button -> {
+                            if (button != null)
+                            {
+                                String eventName = BroadcastEventType.ButtonClicked.getBroadcastEventType();
+                                ButtonBroadcastEventDataParser broadcastEventDataParser = new ButtonBroadcastEventDataParser();
+                                final WritableMap data = broadcastEventDataParser.wrap(button);
+                                rctDeviceEventEmitter.emit(eventName, getBroadcastData(eventName, data));
+                            }
+                        };
+                        SMManager.getInstance().getObserverManager().observeClickedButton(thisActivity, clickedButtonObserver);
+
+                        // Message dismissed
+                        final Observer<Void> dismissedMessageObserver = object -> {
+                            String eventName = BroadcastEventType.WillDismissNotification.getBroadcastEventType();
+                            rctDeviceEventEmitter.emit(eventName, getBroadcastData(eventName, null));
+                        };
+                        SMManager.getInstance().getObserverManager().observeDismissedMessage(thisActivity, dismissedMessageObserver);
+
+                        // Message displayed
+                        final Observer<Void> displayedMessageObserver = object -> {
+                            String eventName = BroadcastEventType.WillDisplayNotification.getBroadcastEventType();
+                            rctDeviceEventEmitter.emit(eventName, getBroadcastData(eventName, null));
+                        };
+                        SMManager.getInstance().getObserverManager().observeDisplayedMessage(thisActivity, displayedMessageObserver);
+
+                        // Push received
+                        final Observer<SMNotificationMessage> pushReceivedObserver = notificationMessage -> {
+                            if (notificationMessage != null)
+                            {
+                                String eventName = BroadcastEventType.ReceivedNotification.getBroadcastEventType();
+                                NotificationMessageBroadcastEventDataParser broadcastEventDataParser = new NotificationMessageBroadcastEventDataParser();
+                                final WritableMap data = broadcastEventDataParser.wrap(notificationMessage);
+                                rctDeviceEventEmitter.emit(eventName, getBroadcastData(eventName, data));
+                            }
+                        };
+                        SMManager.getInstance().getObserverManager().observePushReceived(thisActivity, pushReceivedObserver);
 
-            final LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance(currentActivity);
+                        // Custom events
+                        final Observer<String> customEventObserver = event -> {
+                            rctDeviceEventEmitter.emit(BroadcastEventType.TriggeredCustomEvent.getBroadcastEventType(), getBroadcastData(event, null));
+                        };
+                        SMManager.getInstance().getObserverManager().observeEvent(thisActivity, customEventObserver);
 
-            if (eventReceiver == null) {
-                eventReceiver = new EventReceiver(reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class));
-            } else {
-                localBroadcastManager.unregisterReceiver(eventReceiver);
+                        areObserverStarted = true;
+                    }
+                    else
+                    {
+                        Log.d("RNSelligent", "Observers already instantiated");
+                    }
+                });
             }
+            else
+            {
+                final LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance(currentActivity);
 
-            final IntentFilter filter = new IntentFilter();
-            filter.addAction(SMManager.BROADCAST_EVENT_RECEIVED_IN_APP_MESSAGE);
-            filter.addAction(SMManager.BROADCAST_EVENT_RECEIVED_IN_APP_CONTENTS);
-            filter.addAction(SMManager.BROADCAST_EVENT_WILL_DISPLAY_NOTIFICATION);
-            filter.addAction(SMManager.BROADCAST_EVENT_WILL_DISMISS_NOTIFICATION);
-            filter.addAction(SMManager.BROADCAST_EVENT_BUTTON_CLICKED);
-            filter.addAction(SMManager.BROADCAST_EVENT_RECEIVED_GCM_TOKEN);
-            for (int i = 0; i < customEvents.size(); i++) {
-                filter.addAction(customEvents.getString(i));
-            }
+                if (eventReceiver == null) {
+                    eventReceiver = new EventReceiver(reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class));
+                } else {
+                    localBroadcastManager.unregisterReceiver(eventReceiver);
+                }
+
+                final IntentFilter filter = new IntentFilter();
+                filter.addAction(SMManager.BROADCAST_EVENT_RECEIVED_IN_APP_MESSAGE);
+                filter.addAction(SMManager.BROADCAST_EVENT_WILL_DISPLAY_NOTIFICATION);
+                filter.addAction(SMManager.BROADCAST_EVENT_WILL_DISMISS_NOTIFICATION);
+                filter.addAction(SMManager.BROADCAST_EVENT_BUTTON_CLICKED);
+                filter.addAction(SMManager.BROADCAST_EVENT_RECEIVED_GCM_TOKEN);
 
-            localBroadcastManager.registerReceiver(eventReceiver, filter);
+                for (int i = 0; i < customEvents.size(); i++) {
+                    filter.addAction(customEvents.getString(i));
+                }
+
+                localBroadcastManager.registerReceiver(eventReceiver, filter);
+            }
         }
     }
 
+    WritableMap getBroadcastData(String eventName, WritableMap data)
+    {
+        final WritableMap broadcastData = new WritableNativeMap();
+
+        broadcastData.putString("broadcastEventType", eventName);
+        broadcastData.putMap("data", data);
+
+        return broadcastData;
+    }
+
     @ReactMethod
     public void setFirebaseToken(String token) {
         smManager.setFirebaseToken(token);

package/android/src/main/java/com/selligent/SMSettingsFactory.java

@@ -9,7 +9,6 @@ class SMSettingsFactory {
         smSettings.WebServiceUrl = settings.getUrl();
         smSettings.ClientId = settings.getClientId();
         smSettings.PrivateKey = settings.getPrivateKey();
-        smSettings.ConfigureGeolocation = settings.getConfigureLocationServices();
         smSettings.AddInAppMessageFromPushToInAppMessageList = settings.getAddInAppMessageFromPushToInAppMessageList();
         smSettings.DoNotFetchTheToken = settings.getDoNotFetchTheToken();
         smSettings.DoNotListenToThePush = settings.getDoNotListenToThePush();

package/android/src/main/java/com/selligent/Settings.java

@@ -16,7 +16,6 @@ class Settings {
     private Boolean doNotFetchTheToken = false;
     private Boolean doNotListenToThePush = false;
     private Boolean loadCacheAsynchronously = false;
-    private Boolean configureLocationServices = false;
     private ClearCacheIntervalValue clearCacheIntervalValue;
     private InAppMessageRefreshType inAppMessageRefreshType;
     private RemoteMessageDisplayType remoteMessageDisplayType;
@@ -54,10 +53,6 @@ class Settings {
         return notificationIconColor;
     }
 
-    public Boolean getConfigureLocationServices() {
-        return configureLocationServices;
-    }
-
     public Boolean getDoNotListenToThePush() { return doNotListenToThePush; }
 
     public Boolean getAddInAppMessageFromPushToInAppMessageList() { return addInAppMessageFromPushToInAppMessageList; }
@@ -96,10 +91,6 @@ class Settings {
         settings.url = (String) settingsHashMap.get("url");
         settings.clientId = (String) settingsHashMap.get("clientId");
         settings.privateKey = (String) settingsHashMap.get("privateKey");
-        if (settingsHashMap.containsKey("configureLocationServices")) {
-            settings.configureLocationServices = (Boolean) settingsHashMap.get("configureLocationServices");
-
-        }
         settings.activityName = (String) settingsHashMap.get("fullyQualifiedNotificationActivityClassName");
 
         if (settingsHashMap.containsKey("notificationSmallIcon")) {

package/constants.d.ts

@@ -31,40 +31,15 @@ export namespace RemoteMessagesDisplayType {
   const NOTIFICATION = 22;
 }
 
-export namespace AndroidRemoteMessagesDisplayType {
-  const AUTOMATIC = 20;
-  const NONE = 21;
-  const NOTIFICATION = 22;
-}
-
 export namespace iOSLogLevel {
   const NONE = 50;
   const INFO = 51;
   const WARNING = 52;
   const ERROR = 53;
   const HTTP_CALL = 54;
-  const LOCATION = 55;
   const ALL = 56;
 }
 
-export namespace iOSBackgroundFetchResult {
-  const NEW_DATA = 60;
-  const NO_DATA = 61;
-  const FAILED = 62;
-}
-
-export namespace iOSLocationAuthorisationStatus {
-  const UNKNOWN = 70;
-  const REFUSED = 71;
-  const GRANTED_IN_USE = 72;
-  const GRANTED_ALWAYS = 73;
-}
-
-export namespace iOSLocationAuthorisationType {
-  const IN_USE = 80;
-  const ALWAYS = 81;
-}
-
 export namespace EventType {
   const USER_REGISTER = 90;
   const USER_UNREGISTER = 91;
@@ -73,7 +48,7 @@ export namespace EventType {
   const CUSTOM = 94;
 }
 
-export namespace iOSNotificationButtonType {
+export namespace NotificationButtonType {
   const UNKNOWN = 100;
   const SIMPLE_OPEN_PHONE_CALL = 101;
   const OPEN_SMS = 102;
@@ -82,12 +57,13 @@ export namespace iOSNotificationButtonType {
   const OPEN_APPLICATION = 105;
   const RATE_APPLICATION = 106;
   const CUSTOM_ACTION_BROADCAST_EVENT = 107;
-  const RETURN_TEXT = 108;
-  const RETURN_PHOTO = 109;
-  const RETURN_TEXT_AND_PHOTO = 110;
   const PASSBOOK = 111;
+  const DEEPLINK = 112;
+  const SIMPLE = 113;
 }
 
+export import iOSNotificationButtonType = NotificationButtonType;
+
 export namespace BroadcastEventType {
   const BUTTON_CLICKED = "ButtonClicked";
   const RECEIVED_IN_APP_MESSAGE = "ReceivedInAppMessage";
@@ -96,8 +72,6 @@ export namespace BroadcastEventType {
   const RECEIVED_GCM_TOKEN = "ReceivedGCMToken";
   const RECEIVED_DEVICE_ID = "ReceivedDeviceId";
   const RECEIVED_REMOTE_NOTIFICATION = "ReceivedRemoteNotification";
-}
-
-export namespace RemoteNotification {
-  const FETCHED_REMOTE_NOTIFICATION = "FetchedRemoteNotification";
+  const UNIVERSAL_LINK_EXECUTED = "UniversalLinkExecuted";
+  const TRIGGERED_CUSTOM_EVENT = "TriggeredCustomEvent";
 }

package/constants.js

@@ -1,9 +1,7 @@
-import { Platform } from 'react-native'
-
 /**
  * @module SelligentConstants
  */
-var SelligentConstants = {
+const SelligentConstants = {
 	/**
 	 * @description
 	 * Defines the interval value to clear the cache.
@@ -13,6 +11,8 @@ var SelligentConstants = {
 		AUTO: 1,
 		/** Don't clear cache  */
 		NONE: 2,
+		/** Clear cache daily */
+		DAY: 3,
 		/** Clear cache weekly */
 		WEEK: 4,
 		/** Clear cache monthly  */
@@ -27,6 +27,8 @@ var SelligentConstants = {
 	InAppMessageRefreshType: {
 		/** Refresh in-app messages none */
 		NONE: 10,
+		/** Refresh in-app messages minutely */
+		MINUTE: 11,
 		/** Refresh in-app messages hourly */
 		HOUR: 12,
 		/** Refresh in-app messages daily */
@@ -58,18 +60,6 @@ var SelligentConstants = {
 		/** Display remote messages as notification */
 		NOTIFICATION: 22
 	},
-	/**
-	 * @description
-	 * Defines if and how remote messages can be displayed on Android.
-	 */
-	AndroidRemoteMessagesDisplayType: {
-		/** Display remote messages automatically */
-		AUTOMATIC: 20,
-		/** Don't display remote messages */
-		NONE: 21,
-		/** Display remote messages as notification */
-		NOTIFICATION: 22
-	},
 	/**
 	 * @description
 	 * Defines the level of output of logging messages on iOS.
@@ -85,47 +75,9 @@ var SelligentConstants = {
 		ERROR: 53,
 		/** Output HTTPCall */
 		HTTP_CALL: 54,
-		/** Output location */
-		LOCATION: 55,
 		/** Output everything */
 		ALL: 56
 	},
-	/**
-	 * @description
-	 * Description of the possible results of a background fetch on iOS.
-	 */
-	iOSBackgroundFetchResult: {
-		/** Background fetch resulted in new data */
-		NEW_DATA: 60,
-		/** Background fetch resulted in no new data */
-		NO_DATA: 61,
-		/** Background fetch failed */
-		FAILED: 62
-	},
-	/**
-	 * @description
-	 * Description of the possible status of use of location services on a device.
-	 */
-	 iOSLocationAuthorisationStatus: {
-		/** Status of use of location services is unknown */
-		UNKNOWN: 70,
-		/** Use of location services is refused */
-		REFUSED: 71,
-		/** Use of location services is granted when in use */
-		GRANTED_IN_USE: 72,
-		/** Use of location services is always granted */
-		GRANTED_ALWAYS: 73
-	},
-	/**
-	 * @description
-	 * Defines the level of request for the authorisation of usage of location services on a device.
-	 */
-	iOSLocationAuthorisationType: {
-		/** Request authorisation when in location services are in use */
-		IN_USE: 80,
-		/** Always request the authorisation of the location services */
-		ALWAYS: 81
-	},
 	/**
 	 * @description
 	 * Defines the type of an event.
@@ -144,7 +96,37 @@ var SelligentConstants = {
 	},
 	/**
 	 * @description
-	 * Defines the type of button for notifications on iOS.
+	 * Defines the type of button for notifications and inapp messages.
+	 */
+	NotificationButtonType: {
+		/** Unknown button type */
+		UNKNOWN: 100,
+		/** Simple open phone call button type */
+		SIMPLE_OPEN_PHONE_CALL: 101,
+		/** Open sms button type */
+		OPEN_SMS: 102,
+		/** Open mail button type */
+		OPEN_MAIL: 103,
+		/** Open browser button type */
+		OPEN_BROWSER: 104,
+		/** Open application button type */
+		OPEN_APPLICATION: 105,
+		/** Rate application button type */
+		RATE_APPLICATION: 106,
+		/** Custom action broadcast event button type */
+		CUSTOM_ACTION_BROADCAST_EVENT: 107,
+		/** Passbook button type */
+		PASSBOOK: 111,
+		/** Deeplink button type */
+		DEEPLINK: 112,
+		/** Simple button type */
+		SIMPLE: 112
+	},
+	/**
+	 * @description
+	 * Defines the type of button for notifications and inapp messages on iOS.
+	 * 
+	 * @deprecated Use NotificationButtonType instead.
 	 */
 	iOSNotificationButtonType: {
 		/** Unknown button type */
@@ -163,14 +145,12 @@ var SelligentConstants = {
 		RATE_APPLICATION: 106,
 		/** Custom action broadcast event button type */
 		CUSTOM_ACTION_BROADCAST_EVENT: 107,
-		/** Return text button type */
-		RETURN_TEXT: 108,
-		/** Return photo button type */
-		RETURN_PHOTO: 109,
-		/** Return text and photo button type */
-		RETURN_TEXT_AND_PHOTO: 110,
 		/** Passbook button type */
-		PASSBOOK: 111
+		PASSBOOK: 111,
+		/** Deeplink button type */
+		DEEPLINK: 112,
+		/** Simple button type */
+		SIMPLE: 112
 	},
 	/**
 	 * @description
@@ -186,31 +166,17 @@ var SelligentConstants = {
 		/** A notification will be dismissed */
 		WILL_DISMISS_NOTIFICATION: "WillDismissNotification",
 		/** A device id has been received */
-		RECEIVED_DEVICE_ID: "ReceivedDeviceId"
+		RECEIVED_DEVICE_ID: "ReceivedDeviceId",
+		/** Received GCM TOKEN */
+		RECEIVED_GCM_TOKEN: "ReceivedGCMToken",
+		/** Received a remote notification */
+		RECEIVED_REMOTE_NOTIFICATION: "ReceivedRemoteNotification",
+		/** Received an universal link execution */
+		UNIVERSAL_LINK_EXECUTED: "UniversalLinkExecuted",
+		/** A custom event has been triggered */
+		TRIGGERED_CUSTOM_EVENT: "TriggeredCustomEvent"
 	},
-	/**
-	 * @description
-	 * Defines the type of a Remote Notification.
-	 */
-	RemoteNotification: {}
-};
-
-// Android specific
-if (Platform.OS === 'android') {
-	/** Clear cache daily */
-	SelligentConstants.ClearCacheIntervalValue.DAY = 3
-	/** Refresh in-app messages every minute */
-	SelligentConstants.InAppMessageRefreshType.MINUTE = 11
-	/** Received GCM TOKEN */
-	SelligentConstants.BroadcastEventType.RECEIVED_GCM_TOKEN = "ReceivedGCMToken"
-}
 
-// iOS specific
-if (Platform.OS === 'ios') {
-	/** Received a broadcast event */
-	SelligentConstants.BroadcastEventType.RECEIVED_REMOTE_NOTIFICATION = "ReceivedRemoteNotification"
-	/** Received a remote notification */
-	SelligentConstants.RemoteNotification.FETCHED_REMOTE_NOTIFICATION = "FetchedRemoteNotification"
-}
+};
 
 module.exports = SelligentConstants