@selligent-marketing-cloud/selligent-react-native 3.5.1 → 3.7.0

package/README.md

@@ -10,7 +10,7 @@ This module supports the following SDK and tools:
 
 | SDK                                                                            | Version |
 | ------------------------------------------------------------------------------ | ------- |
-| [Android SDK](https://github.com/SelligentMarketingCloud/MobileSDK-Android)    | 4.4.0   |
+| [Android SDK](https://github.com/SelligentMarketingCloud/MobileSDK-Android)    | 4.4.1   |
 | [iOS SDK](https://github.com/SelligentMarketingCloud/MobileSDK-iOS)            | 3.8.1   |
 | ReactNative                                                                    | 0.72.4  |
 | Expo SDK                                                                       | 49      |
@@ -186,6 +186,8 @@ This module supports the following SDK and tools:
 
     ```objective-c
     @import RNSelligentMobileSDK;
+    // OR
+    // #import <RNSelligentMobileSDK/RNSelligentMobileSDK-Swift.h>
     
     // You can alternatively specify a different file name (without the extension) from where to load the Marigold Engage configs (defaults to 'selligent')
     // if (!launchOptions) {
@@ -193,6 +195,7 @@ This module supports the following SDK and tools:
     // }
     // [launchOptions setValue:@"alternativeFileName" forKey:@"RN_SELLIGENT_JSON"];
 
+    // At the end of application:didFinishLaunchingWithOptions:
     [RNSelligent configureWithLaunchOptions:launchOptions];
     ```
 
@@ -214,6 +217,12 @@ This module supports the following SDK and tools:
     // OR
     // #import <RNSelligentMobileSDK/RNSelligentMobileSDK-Swift.h>
     
+    // You can alternatively specify a different file name (without the extension) from where to load the Marigold Engage configs (defaults to 'selligent')
+    // if (!launchOptions) {
+    //    launchOptions = [NSMutableDictionary new];
+    // }
+    // [launchOptions setValue:@"alternativeFileName" forKey:@"RN_SELLIGENT_JSON"];
+
     // At the end of application:didFinishLaunchingWithOptions:
     [RNSelligent configureWithLaunchOptions:launchOptions];
     ```

package/android/build.gradle

@@ -55,7 +55,6 @@ repositories {
         url "$projectDir/../node_modules/react-native/android"
     }
     google()
-    maven { url 'https://developer.huawei.com/repo/' }
 }
 
 dependencies {
@@ -63,7 +62,7 @@ dependencies {
         exclude group:'com.facebook.fbjni'
         exclude group:'com.facebook.yoga'
     }
-    implementation 'com.selligent.sdk:selligent_mobile_sdk:4.4.0'
+    implementation 'com.selligent.sdk:selligent_mobile_sdk:4.4.1'
     implementation 'com.google.code.gson:gson:2.9.0'
     implementation 'com.google.firebase:firebase-messaging:23.2.1'
     implementation 'androidx.work:work-runtime:2.8.1'

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

@@ -3,16 +3,12 @@ package com.selligent;
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
-import android.text.TextUtils;
 
-import com.facebook.react.bridge.WritableMap;
 import com.facebook.react.modules.core.DeviceEventManagerModule.RCTDeviceEventEmitter;
 import com.selligent.rnmobilesdk.BroadcastDataFactory;
 
-
 class EventReceiver extends BroadcastReceiver {
-
-    private RCTDeviceEventEmitter rctDeviceEventEmitter;
+    private final RCTDeviceEventEmitter rctDeviceEventEmitter;
 
     public EventReceiver(RCTDeviceEventEmitter rctDeviceEventEmitter) {
         this.rctDeviceEventEmitter = rctDeviceEventEmitter;
@@ -20,13 +16,13 @@ class EventReceiver extends BroadcastReceiver {
 
     @Override
     public void onReceive(Context context, Intent intent) {
-        final String smBroadcastEventType = intent.getAction();
-        if (TextUtils.isEmpty(smBroadcastEventType)) return;
+        String smBroadcastEventType = intent.getAction();
 
-        final WritableMap broadcastData = BroadcastDataFactory.getBroadcastData(smBroadcastEventType, intent);
-        final String eventName = broadcastData.getString("broadcastEventType");
+        if (smBroadcastEventType == null || smBroadcastEventType.isEmpty()) return;
 
-        rctDeviceEventEmitter.emit(eventName, broadcastData);
+        this.rctDeviceEventEmitter.emit(
+            smBroadcastEventType,
+            BroadcastDataFactory.getBroadcastData(smBroadcastEventType, intent)
+        );
     }
-
 }

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

@@ -0,0 +1,59 @@
+package com.selligent;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+
+import java.util.List;
+import java.util.Map;
+
+final class RNHelpers {
+    private RNHelpers() { }
+
+    static WritableArray convertListToWritableArray(List<Map<String, Object>> list) {
+        WritableArray array = Arguments.createArray();
+
+        if (list.isEmpty()) { return array; }
+
+        for (Map<String, Object> map : list) {
+            array.pushMap(RNHelpers.convertMapToWritableMap(map));
+        }
+
+        return array;
+    }
+
+    static WritableMap convertMapToWritableMap(Map<String, Object> map) {
+        WritableMap writableMap = Arguments.createMap();
+
+        if (map.entrySet().isEmpty()) { return writableMap; }
+
+        for (Map.Entry<String, Object> entry : map.entrySet()) {
+            Object value = entry.getValue();
+            String key = entry.getKey();
+
+            if (value instanceof Map) {
+                writableMap.putMap(key, RNHelpers.convertMapToWritableMap((Map<String, Object>) value));
+            }
+            else if (value instanceof List) {
+                writableMap.putArray(key, RNHelpers.convertListToWritableArray((List<Map<String, Object>>) value));
+            }
+            else if (value instanceof Boolean) {
+                writableMap.putBoolean(key, (Boolean) value);
+            }
+            else if (value instanceof Integer) {
+                writableMap.putInt(key, (Integer) value);
+            }
+            else if (value instanceof Double) {
+                writableMap.putDouble(key, (Double) value);
+            }
+            else if (value instanceof String) {
+                writableMap.putString(key, (String) value);
+            }
+            else {
+                writableMap.putNull(key);
+            }
+        }
+
+        return writableMap;
+    }
+}

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

@@ -1,19 +1,15 @@
-
 package com.selligent;
 
+import android.annotation.SuppressLint;
 import android.app.Activity;
 import android.app.Application;
+import android.content.Context;
 import android.content.Intent;
-import android.content.IntentFilter;
-import android.content.res.Resources;
 
+import androidx.annotation.NonNull;
 import androidx.appcompat.app.AppCompatActivity;
-import androidx.lifecycle.Observer;
 import androidx.localbroadcastmanager.content.LocalBroadcastManager;
 
-import android.graphics.Color;
-import android.util.Log;
-
 import com.facebook.react.bridge.ActivityEventListener;
 import com.facebook.react.bridge.Callback;
 import com.facebook.react.bridge.LifecycleEventListener;
@@ -23,601 +19,259 @@ import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.ReadableArray;
 import com.facebook.react.bridge.ReadableMap;
 import com.facebook.react.bridge.ReadableType;
-import com.facebook.react.bridge.WritableArray;
-import com.facebook.react.bridge.WritableMap;
-import com.facebook.react.bridge.WritableNativeArray;
-import com.facebook.react.bridge.WritableNativeMap;
 import com.facebook.react.modules.core.DeviceEventManagerModule;
-import com.google.gson.Gson;
-import com.google.gson.reflect.TypeToken;
-import com.selligent.rnmobilesdk.BroadcastEventType;
-import com.selligent.rnmobilesdk.ButtonBroadcastEventDataParser;
-import com.selligent.rnmobilesdk.DeviceIdBroadcastEventDataParser;
-import com.selligent.rnmobilesdk.Event;
-import com.selligent.rnmobilesdk.GCMTokenBroadcastEventDataParser;
-import com.selligent.rnmobilesdk.InAppMessageBroadcastEventDataParser;
-import com.selligent.rnmobilesdk.InAppMessageRefreshType;
-import com.selligent.rnmobilesdk.NotificationMessageBroadcastEventDataParser;
-import com.selligent.rnmobilesdk.RemoteMessageDisplayType;
-import com.selligent.rnmobilesdk.SMEventFactory;
-import com.selligent.rnmobilesdk.SMSettingsFactory;
-import com.selligent.rnmobilesdk.Settings;
-import com.selligent.sdk.SMCallback;
-import com.selligent.sdk.SMEvent;
+import com.selligent.rnmobilesdk.Manager;
 import com.selligent.sdk.SMForegroundGcmBroadcastReceiver;
-import com.selligent.sdk.SMInAppMessage;
-import com.selligent.sdk.SMInAppRefreshType;
-import com.selligent.sdk.SMManager;
-import com.selligent.sdk.SMNotificationButton;
-import com.selligent.sdk.SMNotificationMessage;
-import com.selligent.sdk.SMObserverManager;
-import com.selligent.sdk.SMRemoteMessageDisplayType;
-import com.selligent.sdk.SMSettings;
 
-import java.util.HashMap;
+import java.util.Map;
 
 public class RNSelligent extends ReactContextBaseJavaModule implements LifecycleEventListener, ActivityEventListener {
-
-    private static final String RN_SELLIGENT_NAME = "RNSelligent";
     private final ReactApplicationContext reactContext;
-    private final SMManager smManager;
+    private final Manager manager;
     EventReceiver eventReceiver;
     SMForegroundGcmBroadcastReceiver receiver;
-    private static SMInAppRefreshType inAppMessageRefreshType;
-
-    public static final String REACT_CLASS = "SelligentReactNative"; // for logging purposes
-
-    boolean areObserverStarted = false;
 
-    //region getter
-    static SMManager getSMManager()
-    {
-        return SMManager.getInstance();
+    static Manager getManager() {
+        return Manager.getInstance();
     }
 
-    static String getSelligentSettings()
-    {
+    static String getSelligentSettings() {
         return BuildConfig.SELLIGENT_SETTINGS;
     }
 
-    static Class<? extends Activity> getActivityClass(String notificationActivityName) throws Exception
-    {
-        return (Class<? extends Activity>) Class.forName(notificationActivityName);
-    }
-    //endregion
-
-
     public RNSelligent(ReactApplicationContext reactContext) {
         super(reactContext);
+
         this.reactContext = reactContext;
         reactContext.addLifecycleEventListener(this);
         reactContext.addActivityEventListener(this);
-        this.smManager = getSMManager();
+        this.manager = RNSelligent.getManager();
     }
 
+    @NonNull
     @Override
     public String getName() {
-        return RN_SELLIGENT_NAME;
+        return Manager.RN_SELLIGENT_NAME;
     }
 
     public static void configure(Application application) {
-        try {
-            final HashMap<String, Object> settingsHashMap = new Gson().fromJson(
-                    getSelligentSettings(), new TypeToken<HashMap<String, Object>>() {}.getType()
-            );
-            final Settings settings = Settings.fromHashMap(settingsHashMap);
-            final SMSettings smSettings = SMSettingsFactory.getSMSettings(settings);
-            final String notificationActivityName = settings.getActivityName();
-
-            SMManager.NOTIFICATION_ACTIVITY = getActivityClass(notificationActivityName);
-            inAppMessageRefreshType = settings.getInAppMessageRefreshType().getSmInAppRefreshType();
-
-            final SMManager smManager = getSMManager();
-            SMManager.DEBUG = BuildConfig.BUILD_TYPE.equals("debug") || settings.getEnableAndroidLogging();
-            smManager.start(smSettings, application);
-
-            final Resources resources = application.getResources();
-
-            if (settings.getNotificationSmallIcon() != null && !settings.getNotificationSmallIcon().isEmpty()) {
-                final int smallIconResourceId = resources.getIdentifier(settings.getNotificationSmallIcon(), "drawable", application.getPackageName());
-                if(smallIconResourceId != 0) {
-                    smManager.setNotificationSmallIcon(smallIconResourceId);
-                }
-            }
-
-            if (settings.getNotificationLargeIcon() != null && !settings.getNotificationLargeIcon().isEmpty()) {
-                final int largeIconResourceId = resources.getIdentifier(settings.getNotificationLargeIcon(), "drawable", application.getPackageName());
-                if (largeIconResourceId != 0) {
-                    smManager.setNotificationLargeIcon(largeIconResourceId);
-                }
-            }
-
-            if (settings.getNotificationIconColor() != null && !settings.getNotificationIconColor().isEmpty()) {
-                try {
-                    final int color = Color.parseColor(settings.getNotificationIconColor());
-                    smManager.setNotificationIconColor(color);
-                } catch (IllegalArgumentException e) {
-                    Log.e(RN_SELLIGENT_NAME, "notificationIconColor must be a color hex string.");
-                }
-            }
-
-        } catch (Exception e) {
-            Log.e(RN_SELLIGENT_NAME, "SMManager start failed: an error occurred while setting the NotificationActivity", e);
-        }
+        RNSelligent.getManager().configure(application, RNSelligent.getSelligentSettings(), BuildConfig.BUILD_TYPE.equals("debug"));
     }
 
-    /* Our methods: */
-
     @ReactMethod
     public void getVersionLib(Callback successCallback) {
-        final String versionLib = SMManager.VERSION_LIB;
-        successCallback.invoke(versionLib);
+        successCallback.invoke(manager.getVersionLib());
     }
 
     @ReactMethod
     public void enableInAppMessages(ReadableMap enabled) {
-        final String enabledProperty = "enabled";
-        final ReadableType enabledType = enabled.getType(enabledProperty);
+        String enabledProperty = "enabled";
+        ReadableType enabledType = enabled.getType(enabledProperty);
 
         if (enabledType == ReadableType.Boolean) {
-            enableInAppMessages(enabled.getBoolean(enabledProperty));
-        } 
-        else if (enabledType == ReadableType.Number) {
-            enableInAppMessages(enabled.getInt(enabledProperty));
+            this.manager.enableInAppMessages(enabled.getBoolean(enabledProperty));
         }
-    }
-
-    private void enableInAppMessages(boolean enable) {
-        if (enable) {
-            smManager.enableInAppMessages(inAppMessageRefreshType);
-        } else {
-            smManager.disableInAppMessages();
+        else if (enabledType == ReadableType.Number) {
+            this.manager.enableInAppMessages(enabled.getInt(enabledProperty));
         }
     }
 
-    private void enableInAppMessages(Integer inAppMessageRefreshTypeIndex) {
-        final InAppMessageRefreshType refreshType = InAppMessageRefreshType.valueOf(inAppMessageRefreshTypeIndex);
-        final SMInAppRefreshType smInAppRefreshType = refreshType.getSmInAppRefreshType();
-
-        smManager.enableInAppMessages(smInAppRefreshType);
-    }
-
     @ReactMethod
     public void areInAppMessagesEnabled(Callback successCallback) {
-        final Boolean areInAppMessagesEnabled = smManager.areInAppMessagesEnabled();
-        successCallback.invoke(areInAppMessagesEnabled);
+        successCallback.invoke(this.manager.areInAppMessagesEnabled());
     }
 
     @ReactMethod
     public void displayMessage(String messageId) {
-        final Activity currentActivity = getCurrentActivity();
-
-        if (currentActivity != null) {
-            smManager.displayInAppMessage(messageId, currentActivity);
-        }
+        this.manager.displayMessage(messageId, this.getCurrentActivity());
     }
 
     @ReactMethod
-    public void getInAppMessages(final Callback successCallback) {
-        smManager.getInAppMessages(inAppMessages -> {
-            WritableArray resultingMessagesArray = new WritableNativeArray();
-
-            for (SMInAppMessage message : inAppMessages) {
-                WritableMap messageMap = new WritableNativeMap();
-
-                messageMap.putString("id", message.id);
-                messageMap.putString("title", message.title);
-                messageMap.putString("body", message.getBody());
-                messageMap.putDouble("creationDate", message.getCreationDate());
-                messageMap.putDouble("expirationDate", message.getExpirationDate());
-                messageMap.putDouble("receptionDate", message.getReceptionDate());
-                messageMap.putBoolean("hasBeenSeen", message.hasBeenSeen());
-                messageMap.putDouble("type", message.getType().getValue());
-
-                WritableArray buttonsArray = new WritableNativeArray();
-
-                SMNotificationButton[] buttons = message.getButtons();
-
-                if(buttons != null) {
-                    for(SMNotificationButton button : buttons) {
-                        WritableMap buttonMap = new WritableNativeMap();
-
-                        buttonMap.putString("id", button.id);
-                        buttonMap.putString("value", button.value);
-                        buttonMap.putString("label", button.label);
-                        buttonMap.putInt("type", button.type);
-
-                        buttonsArray.pushMap(buttonMap);
-                    }
-                }
-
-                messageMap.putArray("buttons", buttonsArray);
-
-                resultingMessagesArray.pushMap(messageMap);
-            }
-
-            successCallback.invoke(resultingMessagesArray);
-        });
+    public void getInAppMessages(Callback successCallback) {
+        this.manager.getInAppMessages(list ->
+            successCallback.invoke(RNHelpers.convertListToWritableArray(list))
+        );
     }
 
     @ReactMethod
-    public void setInAppMessageAsSeen(final String messageId, final Callback successCallback, final Callback errorCallback) {
-        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));
-        });
+    public void setInAppMessageAsSeen(String messageId, Callback successCallback, Callback errorCallback) {
+        this.manager.setInAppMessageAsSeen(messageId, error ->
+            processErrorStringToCallback(error, successCallback, errorCallback)
+        );
     }
 
     @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));
-        });
+    public void setInAppMessageAsUnseen(String messageId, Callback successCallback, Callback errorCallback) {
+        this.manager.setInAppMessageAsUnseen(messageId, error ->
+            processErrorStringToCallback(error, successCallback, errorCallback)
+        );
     }
 
     @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));
-        });
+    public void setInAppMessageAsDeleted(String messageId, Callback successCallback, Callback errorCallback) {
+        this.manager.setInAppMessageAsDeleted(messageId, error ->
+            processErrorStringToCallback(error, successCallback, errorCallback)
+        );
     }
 
     @ReactMethod
-    public void executeButtonAction(final String buttonId, final String messageId, final Callback successCallback, final Callback errorCallback) {
-        smManager.getInAppMessages(inAppMessages -> {
-            for(SMInAppMessage message : inAppMessages) {
-                if(message.id.equals(messageId))
-                {
-                    SMNotificationButton[] buttons = message.getButtons();
-                    if (buttons != null)
-                    {
-                        for (SMNotificationButton button : message.getButtons())
-                        {
-                            if (button.id.equals(buttonId))
-                            {
-                                smManager.executeButtonAction(reactContext, button, message);
-                                successCallback.invoke();
-                                return;
-                            }
-                        }
-                    }
-                    errorCallback.invoke("buttonId does not exist in message.");
-                    return;
-                }
-            }
-            errorCallback.invoke(String.format("No message with id %s found", messageId));
-        });
+    public void executeButtonAction(String buttonId, String messageId, Callback successCallback, Callback errorCallback) {
+        this.manager.executeButtonAction(this.reactContext, buttonId, messageId, error ->
+            processErrorStringToCallback(error, successCallback, errorCallback)
+        );
     }
 
     @ReactMethod
     public void setDebug(Boolean enable) {
-        SMManager.DEBUG = enable;
+        Manager.setDebug(enable);
     }
 
     @ReactMethod
-    public void sendEvent(ReadableMap eventMap, final Callback successCallback, final Callback errorCallback) {
-        final Event event = Event.fromHashMap(eventMap.toHashMap());
-        final SMEvent smEvent = SMEventFactory.getSMEvent(event, new SMCallback() {
-            @Override
-            public void onSuccess(String message) {
-                successCallback.invoke(message);
-            }
-
-            @Override
-            public void onError(int responseCode, Exception e) {
-                errorCallback.invoke(responseCode);
-            }
-        });
-
-        smManager.sendSMEvent(smEvent);
+    public void sendEvent(ReadableMap eventMap, Callback successCallback, Callback errorCallback) {
+        this.manager.sendEvent(eventMap.toHashMap(), successCallback::invoke, errorCallback::invoke);
     }
 
     @ReactMethod
     public void getDeviceId(Callback successCallback) {
-        final String deviceId = smManager.getDeviceId();
-        successCallback.invoke(deviceId);
+        successCallback.invoke(this.manager.getDeviceId());
     }
 
     @ReactMethod
     public void enableNotifications(Boolean enable) {
-        if (Boolean.TRUE.equals(enable)) {
-            smManager.enableNotifications();
-        } else {
-            smManager.disableNotifications();
-        }
+        this.manager.enableNotifications(enable);
     }
 
     public static void enableNotifications() {
-        SMManager.getInstance().enableNotifications();
+        RNSelligent.getManager().enableNotifications(true);
     }
 
     @ReactMethod
+    @SuppressWarnings("unused")
     public void displayLastReceivedRemotePushNotification(String templateId) {
-        final Activity currentActivity = getCurrentActivity();
-
-        if (currentActivity != null) {
-            smManager.displayLastReceivedNotificationContent(currentActivity);
-        }
+        this.manager.displayLastReceivedRemotePushNotification(this.getCurrentActivity());
     }
 
     @ReactMethod
-    public void displayLastReceivedNotification()
-    {
-        smManager.displayLastReceivedNotification();
+    public void displayLastReceivedNotification() {
+        this.manager.displayLastReceivedNotification();
     }
 
     @ReactMethod
     public void getLastRemotePushNotification(Callback successCallback) {
-        final SMNotificationMessage notification = smManager.retrieveLastReceivedNotificationContent();
-
-        WritableMap resultingNotificationMap = new WritableNativeMap();
-        
-        if (notification != null) {
-            resultingNotificationMap.putString("id", notification.getId());
-            resultingNotificationMap.putString("title", notification.getNotificationTitle());
-        }
-
-        successCallback.invoke(resultingNotificationMap);
+        successCallback.invoke(
+            RNHelpers.convertMapToWritableMap(this.manager.getLastRemotePushNotification())
+        );
     }
 
     @ReactMethod
     public void setNotificationSmallIcon(String iconName) {
-        final int resourceId = processNotificationIcon(iconName);
-        smManager.setNotificationSmallIcon(resourceId);
+        this.manager.setNotificationSmallIcon(this.reactContext, iconName);
     }
 
     @ReactMethod
     public void setNotificationLargeIcon(String iconName) {
-        final int resourceId = processNotificationIcon(iconName);
-
-        smManager.setNotificationLargeIcon(resourceId);
-    }
-
-    private int processNotificationIcon(String iconName) {
-        final Resources resources = reactContext.getResources();
-        final int resourceId = resources.getIdentifier(iconName, "drawable", reactContext.getPackageName());
-
-        if (resourceId == 0) {
-            throw new IllegalArgumentException("Could not find a drawable with the name " + iconName);
-        }
-
-        return resourceId;
+        this.manager.setNotificationLargeIcon(this.reactContext, iconName);
     }
 
     @ReactMethod
-    public void setNotificationIconColor(final String colorString, final Callback successCallback, final Callback errorCallback) {
-        try {
-            final int color = Color.parseColor(colorString);
-            smManager.setNotificationIconColor(color);
-            successCallback.invoke();
-        } catch (IllegalArgumentException e) {
-            errorCallback.invoke("color must be a color hex string.");
-        }
+    public void setNotificationIconColor(String colorString, Callback successCallback, Callback errorCallback) {
+        processErrorStringToCallback(
+            this.manager.setNotificationIconColor(colorString),
+            successCallback,
+            errorCallback
+        );
     }
 
     @ReactMethod
-    public void setNotificationActivity(final String activityName, final Callback successCallback, final Callback errorCallback) {
-        try {
-            SMManager.NOTIFICATION_ACTIVITY = (Class<? extends Activity>) Class.forName(activityName);
-            successCallback.invoke();
-        } catch (ClassNotFoundException e) {
-            errorCallback.invoke(String.format("Activity %s not found.", activityName));
-        }
+    public void setNotificationActivity(String activityName, Callback successCallback, Callback errorCallback) {
+        processErrorStringToCallback(
+            Manager.setNotificationActivity(activityName),
+            successCallback,
+            errorCallback
+        );
     }
 
     @ReactMethod
     public void getGCMToken(Callback callback) {
-        final String gcmToken = smManager.getGCMToken();
-        callback.invoke(gcmToken);
+        callback.invoke(this.manager.getGCMToken());
     }
 
     @ReactMethod
     public void getRemoteMessagesDisplayType(Callback successCallback) {
-        final SMRemoteMessageDisplayType smRemoteMessageDisplayType = smManager.getRemoteMessagesDisplayType();
-        final RemoteMessageDisplayType remoteMessageDisplayType = RemoteMessageDisplayType.valueOf(smRemoteMessageDisplayType);
-        final Integer resultingRemoteMessageDisplayTypeIndex = remoteMessageDisplayType.getIndex();
-
-        successCallback.invoke(resultingRemoteMessageDisplayTypeIndex);
+        successCallback.invoke(this.manager.getRemoteMessagesDisplayType());
     }
 
     @ReactMethod
     public void areNotificationsEnabled(Callback successCallback) {
-        final Boolean areNotificationsEnabled = smManager.areNotificationEnabled();
-
-        successCallback.invoke(areNotificationsEnabled);
+        successCallback.invoke(this.manager.areNotificationsEnabled());
     }
 
     @ReactMethod
     public void subscribeToEvents(ReadableArray customEvents) {
-        final Activity currentActivity = getCurrentActivity();
-
-        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(RN_SELLIGENT_NAME, "Instantiating the observers on the UI thread");
-                        SMObserverManager observerManager = smManager.getObserverManager();
-
-                        // 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));
-                        };
-                        observerManager.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));
-                        };
-                        observerManager.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));
-                            }
-                        };
-                        observerManager.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));
-                            }
-                        };
-                        observerManager.observeClickedButton(thisActivity, clickedButtonObserver);
-
-                        // Message dismissed
-                        final Observer<Void> dismissedMessageObserver = object -> {
-                            String eventName = BroadcastEventType.WillDismissNotification.getBroadcastEventType();
-                            rctDeviceEventEmitter.emit(eventName, getBroadcastData(eventName, null));
-                        };
-                        observerManager.observeDismissedMessage(thisActivity, dismissedMessageObserver);
-
-                        // Message displayed
-                        final Observer<Void> displayedMessageObserver = object -> {
-                            String eventName = BroadcastEventType.WillDisplayNotification.getBroadcastEventType();
-                            rctDeviceEventEmitter.emit(eventName, getBroadcastData(eventName, null));
-                        };
-                        observerManager.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));
-                            }
-                        };
-                        observerManager.observePushReceived(thisActivity, pushReceivedObserver);
-
-                        // Custom events
-                        final Observer<String> customEventObserver = event -> rctDeviceEventEmitter.emit(BroadcastEventType.TriggeredCustomEvent.getBroadcastEventType(), getBroadcastData(event, null));
-                        observerManager.observeEvent(thisActivity, customEventObserver);
-
-                        areObserverStarted = true;
-                    }
-                    else
-                    {
-                        Log.d(RN_SELLIGENT_NAME, "Observers already instantiated");
-                    }
-                });
-            }
-            else
-            {
-                final LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance(currentActivity);
-
-                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);
-
-                for (int i = 0; i < customEvents.size(); i++) {
-                    filter.addAction(customEvents.getString(i));
-                }
-
-                localBroadcastManager.registerReceiver(eventReceiver, filter);
-            }
+        Activity currentActivity = this.getCurrentActivity();
+
+        if (currentActivity == null) { return; }
+
+        if (currentActivity instanceof AppCompatActivity) {
+            AppCompatActivity activity = (AppCompatActivity)currentActivity;
+
+            activity.runOnUiThread(() ->
+                this.manager.initializeObservers(activity, this::broadcastEvent)
+            );
+
+            return;
         }
-    }
 
-    WritableMap getBroadcastData(String eventName, WritableMap data)
-    {
-        final WritableMap broadcastData = new WritableNativeMap();
+        LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance(currentActivity);
 
-        broadcastData.putString("broadcastEventType", eventName);
-        broadcastData.putMap("data", data);
+        if (this.eventReceiver == null) {
+            this.eventReceiver = new EventReceiver(
+                reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class
+            ));
+        }
+        else {
+            localBroadcastManager.unregisterReceiver(this.eventReceiver);
+        }
 
-        return broadcastData;
+        localBroadcastManager.registerReceiver(
+            this.eventReceiver,
+            Manager.eventsIntentFilter(customEvents.toArrayList())
+        );
     }
 
     @ReactMethod
     public void setFirebaseToken(String token) {
-        smManager.setFirebaseToken(token);
+        this.manager.setFirebaseToken(token);
     }
 
+    @SuppressLint("UnspecifiedRegisterReceiverFlag")
     @Override
     public void onHostResume() {
-        final Activity currentActivity = getCurrentActivity();
+        Activity currentActivity = this.getCurrentActivity();
 
-        if (currentActivity != null) {
-            if (receiver == null)
-            {
-                receiver = new SMForegroundGcmBroadcastReceiver(currentActivity);
-            }
-            currentActivity.registerReceiver(receiver, receiver.getIntentFilter());
+        if (currentActivity == null) { return; }
+
+        if (this.receiver == null) {
+            this.receiver = new SMForegroundGcmBroadcastReceiver(currentActivity);
+        }
 
-            smManager.checkAndDisplayMessage(currentActivity.getIntent(), currentActivity);
+        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.TIRAMISU) {
+            currentActivity.registerReceiver(this.receiver, this.receiver.getIntentFilter(), Context.RECEIVER_NOT_EXPORTED);
         }
+        else {
+            currentActivity.registerReceiver(this.receiver, this.receiver.getIntentFilter());
+        }
+
+        this.manager.checkAndDisplayMessage(currentActivity.getIntent(), currentActivity, this::broadcastEvent);
     }
 
     @Override
     public void onHostPause() {
-        final Activity currentActivity = getCurrentActivity();
+        Activity currentActivity = this.getCurrentActivity();
 
-        if (currentActivity != null) {
-            currentActivity.unregisterReceiver(receiver);
-        }
+        if (currentActivity == null) { return; }
+
+        currentActivity.unregisterReceiver(this.receiver);
     }
 
     @Override
@@ -625,14 +279,30 @@ public class RNSelligent extends ReactContextBaseJavaModule implements Lifecycle
 
     @Override
     public void onNewIntent(Intent intent) {
-        final Activity currentActivity = getCurrentActivity();
+        Activity currentActivity = this.getCurrentActivity();
 
-        if (currentActivity != null) {
-            currentActivity.setIntent(intent);
-            smManager.checkAndDisplayMessage(intent, currentActivity);
-        }
+        if (currentActivity == null) { return; }
+
+        currentActivity.setIntent(intent);
+        this.manager.checkAndDisplayMessage(intent, currentActivity, this::broadcastEvent);
     }
 
     @Override
     public void onActivityResult(Activity activity, int requestCode, int resultCode, Intent data) { }
+
+    private void broadcastEvent(String eventName, Map<String, Object> data) {
+        this.reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class).emit(
+            eventName,
+            RNHelpers.convertMapToWritableMap(data)
+        );
+    }
+
+    private void processErrorStringToCallback(String error, Callback successCallback, Callback errorCallback) {
+        if (error == null) {
+            successCallback.invoke();
+            return;
+        }
+
+        errorCallback.invoke(error);
+    }
 }

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

@@ -1,7 +1,7 @@
-
 package com.selligent;
 
-import java.util.Arrays;
+import androidx.annotation.NonNull;
+
 import java.util.Collections;
 import java.util.List;
 
@@ -10,19 +10,22 @@ import com.facebook.react.bridge.NativeModule;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.uimanager.ViewManager;
 import com.facebook.react.bridge.JavaScriptModule;
+
 public class RNSelligentPackage implements ReactPackage {
+    @NonNull
     @Override
-    public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
-      return Arrays.<NativeModule>asList(new RNSelligent(reactContext));
+    public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+        return Collections.singletonList(new RNSelligent(reactContext));
     }
 
-    // Deprecated from RN 0.47
     public List<Class<? extends JavaScriptModule>> createJSModules() {
-      return Collections.emptyList();
+        return Collections.emptyList();
     }
 
+    @NonNull
     @Override
-    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
-      return Collections.emptyList();
+    @SuppressWarnings("rawtypes")
+    public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+        return Collections.emptyList();
     }
 }

package/constants.d.ts

@@ -74,4 +74,5 @@ export namespace BroadcastEventType {
   const RECEIVED_REMOTE_NOTIFICATION = "ReceivedRemoteNotification";
   const UNIVERSAL_LINK_EXECUTED = "UniversalLinkExecuted";
   const TRIGGERED_CUSTOM_EVENT = "TriggeredCustomEvent";
+  const DISPLAYING_IN_APP_MESSAGE = "DisplayingInAppMessage";
 }

package/constants.js

@@ -174,7 +174,9 @@ const SelligentConstants = {
 		/** Received an universal link execution */
 		UNIVERSAL_LINK_EXECUTED: "UniversalLinkExecuted",
 		/** A custom event has been triggered */
-		TRIGGERED_CUSTOM_EVENT: "TriggeredCustomEvent"
+		TRIGGERED_CUSTOM_EVENT: "TriggeredCustomEvent",
+		/** An IAM is about to be displayed (when `customInAppUi` is set to `true` in `selligent.json`) */
+		DISPLAYING_IN_APP_MESSAGE: "DisplayingInAppMessage"
 	},
 
 };

package/documentation/README.md

@@ -66,6 +66,7 @@ The following properties can be used in the `selligent.json` to further configur
 | url                                         | string | The Marigold Engage webservice url to be used to integrate with your Marigold Engage platform |
 | clientId                                    | string | The Marigold Engage client id to be used to integrate with your Marigold Engage platform |
 | privateKey                                  | string | The Marigold Engage private key to be used to integrate with your Marigold Engage platform |
+| customInAppUi                               | boolean| When this is enabled and a "push + inapp" notification is clicked, the SDK will NOT display the inApp message and instead a `SelligentConstants.BroadcastEventType.DISPLAYING_IN_APP_MESSAGE` event will be sent |
 | delayedPushAction                           | boolean| (iOS Only) Optin for a specific push action handling (wait for React UI to be ready) when coming from a push message and having the app killed |
 | interceptSelligentUniversalLinks            | boolean| (iOS Only) Optin to customly handle the execution of universal links coming from a Push/IAM [more information](#universal-linking---ios) |
 | clearCacheIntervalValue                     | [enum](#clearcacheintervalvalue) | How much time the SDK will keep things in cache |  
@@ -482,7 +483,7 @@ The `data` property is an object itself containing more information specific to
 
     | Property | Type   | Description        |
     | -------- | ------ | ------------------ |
-    | id       | string | Internal id of the message    |
+    | id       | string | Internal id of the message |
     | title    | string | Title of the message |
 
 ```javascript
@@ -512,7 +513,7 @@ The response of the success callback is an array of objects which contain the in
 | -------------- | ------------------------------------------------------------------------------- | ---------------------------------------------------------- |
 | id             | string                                                                          | Internal id of the IAM                                 |
 | title          | string                                                                          | Title of the IAM                               |
-| body           | string                                                                          | Body of the IAM                          |
+| body           | string                                                                          | Body of the IAM. For message of type `ALERT` it will be the text corresponding to the body of the Alert, for type `HTML` it will be the html code, for type `URL`, `IMAGE` and `PASSBOOK` it will be an URL.                          |
 | type           | [enum](#inappmessagetype) | Type of the IAM                                  |
 | creationDate   | number                                                                          | Creation date of the IAM in unix time            |
 | expirationDate | number                                                                          | Expiration date of the IAM in unix time         |
@@ -529,6 +530,36 @@ The `buttons` property is an array of button-objects which contain the informati
 | value    | string | Value of the button of the in app message  | Both         |
 | type     | number | Type of the button of the in app message   | Both         |
 
+- When the IAM is linked to a push notification, you can set `customInAppUi` to `true` in `selligent.json` and subscribe to `SelligentConstants.BroadcastEventType.DISPLAYING_IN_APP_MESSAGE` events through the `Selligent.subscribeToEvents`, to know when messages are about to be displayed.
+You will also need to set `addInAppMessageFromPushToInAppMessageList` to `true` in `selligent.json` to be able to retrieve the full object calling `Selligent.getInAppMessages` and do not forget to use the [IAM Helper methods](#iam-helper-methods) to properly track Open and Click interactions.
+For Android, to avoid the SDK directly displaying the IAM if the App is in foreground, do also set `remoteMessageDisplayType` to `22` (NOTIFICATION) in `selligent.json`.
+The response of the success callback is an object which contains information on the type of broadcast event and the data attached to it.
+
+| Property           | Type                                                    | Description                                                       |
+| ------------------ | ------------------------------------------------------- | ----------------------------------------------------------------- |
+| broadcastEventType | [enum](#broadcasteventtype)                             | The type of broadcast event                                       |
+| data               | object                                                  | Contains more information specific to the type of broadcast event |
+
+The `data` property is an object itself containing more information specific to the type of the broadcast event:
+
+- DISPLAYING_IN_APP_MESSAGE
+
+    | Property | Type   | Description        |
+    | -------- | ------ | ------------------ |
+    | id       | string | Internal id of the message |
+    | title    | string | Title of the message |
+
+```javascript
+Selligent.subscribeToEvents(
+    () => {}, 
+    () => {},
+    (response) => {
+      if (response?.broadcastEventType === SelligentConstants.BroadcastEventType.DISPLAYING_IN_APP_MESSAGE) {
+      }
+    }
+)
+```
+
 To display any of these messages, you can call `Selligent.displayMessage`:
 
 ### Selligent.displayMessage
@@ -596,7 +627,7 @@ In the other hand, you can also use the native methods `RNSelligent/willPresentN
 
 ### IAM Helper methods
 
-If you decide to display the AIM on your own (without `Selligent.displayMessage` and `Selligent.displayNotification`), listening for new messages with the `Selligent.subscribeToEvents` and/or getting the full list with `Selligent.getInAppMessages`. You will be able to build your own layout with the object provided from the mentioned functions and then you can use the helper methods described here to still push KPI statistics to the Marigold Engage platform:
+If you decide to display the IAM on your own (without `Selligent.displayMessage` and `Selligent.displayNotification`), listening for new messages with the `Selligent.subscribeToEvents` and/or getting the full list with `Selligent.getInAppMessages`. You will be able to build your own layout with the object provided from the mentioned functions and then you can use the helper methods described here to still push KPI statistics to the Marigold Engage platform:
 
 - setInAppMessageAsSeen: sets an IAM as seen and sends the corresponding `Opened` event to the Marigold Engage platform
 
@@ -905,3 +936,4 @@ Defines the type of a broadcast event.
 | RECEIVED_REMOTE_NOTIFICATION     | string | ReceivedRemoteNotification | A remote notification has been received               |
 | iOS.UNIVERSAL_LINK_EXECUTED      | string | UniversalLinkExecuted      | An universal link has been executed                   |
 | TRIGGERED_CUSTOM_EVENT           | string | TriggeredCustomEvent       | A custom event has been triggered                     |
+| DISPLAYING_IN_APP_MESSAGE        | string | DisplayingInAppMessage     | An IAM is about to be displayed (when `customInAppUi` is set to `true` in `selligent.json`) |

package/index.js

@@ -306,6 +306,7 @@ export default Object.assign(
 			RNSEventEmitter.addListener(SelligentConstants.BroadcastEventType.RECEIVED_DEVICE_ID, eventCallback);
 			RNSEventEmitter.addListener(SelligentConstants.BroadcastEventType.RECEIVED_REMOTE_NOTIFICATION, eventCallback);
 			RNSEventEmitter.addListener(SelligentConstants.BroadcastEventType.TRIGGERED_CUSTOM_EVENT, eventCallback);
+			RNSEventEmitter.addListener(SelligentConstants.BroadcastEventType.DISPLAYING_IN_APP_MESSAGE, eventCallback);
 
 			if (Platform.OS === "ios") {
 				RNSEventEmitter.addListener(SelligentConstants.BroadcastEventType.UNIVERSAL_LINK_EXECUTED, eventCallback);

package/ios/RNSelligentMapper.m

@@ -148,7 +148,8 @@ RCT_EXPORT_METHOD(subscribeToEvents:(NSArray<NSString *> *)events) {
         @"ReceivedRemoteNotification",
         @"ReceivedDeviceId",
         @"UniversalLinkExecuted",
-        @"TriggeredCustomEvent"
+        @"TriggeredCustomEvent",
+        @"DisplayingInAppMessage"
      ];
 }
 

package/package.json

@@ -4,7 +4,7 @@
   },
   "name": "@selligent-marketing-cloud/selligent-react-native",
   "title": "Marigold Engage React Native",
-  "version": "3.5.1",
+  "version": "3.7.0",
   "description": "React Native wrapper for the Marigold Engage Android and iOS SDKs",
   "main": "index.js",
   "repository": {