infobip-mobile-messaging-react-native-plugin 14.8.3 → 14.9.1

package/android/build.gradle

@@ -66,7 +66,7 @@ repositories {
 }
 
 dependencies {
-    def mmVersion = '14.14.2'
+    def mmVersion = '15.0.0'
     implementation "org.jetbrains.kotlin:kotlin-stdlib:2.1.20"
     compileOnly "com.facebook.react:react-android"
     implementation "androidx.annotation:annotation:1.9.1"

package/android/src/main/AndroidManifest.xml

@@ -1,5 +1,4 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          xmlns:tools="http://schemas.android.com/tools">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
 
     <!-- Mobile Messaging permissions -->
 
@@ -20,10 +19,7 @@
     <uses-permission android:name="android.permission.CAMERA" />
     <!-- Infobip rtc ui permissions -->
 
-    <application
-            tools:replace="android:usesCleartextTraffic"
-                   android:usesCleartextTraffic="true"
-    >
+    <application>
         <!-- Mobile Messaging components -->
         <service
             android:name="org.infobip.mobile.messaging.platform.MobileMessagingJobService"

package/android/src/main/java/org/infobip/reactlibrary/mobilemessaging/CacheManager.java

@@ -12,23 +12,17 @@ import android.content.Context;
 import android.content.SharedPreferences;
 import android.preference.PreferenceManager;
 
-import android.util.Log;
-
-import org.infobip.mobile.messaging.api.support.http.serialization.JsonSerializer;
-import org.infobip.mobile.messaging.dal.json.JSONArrayAdapter;
-import org.infobip.mobile.messaging.dal.json.JSONObjectAdapter;
 import org.json.JSONObject;
 
 import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.HashSet;
+import java.util.Iterator;
 import java.util.List;
-import java.util.Set;
 
 class CacheManager {
-    private static final String EVENTS_KEY = Utils.TAG + ".cache.events";
+    private static final String LEGACY_EVENTS_KEY = Utils.TAG + ".cache.events";
     private static final Object cacheLock = new Object();
-    private static final JsonSerializer serializer = new JsonSerializer(false, new JSONObjectAdapter(), new JSONArrayAdapter());
+    private static final List<Event> cachedEvents = new ArrayList<>();
+    private static final int MAX_CACHE_SIZE = 100;
 
     static class Event {
         String type;
@@ -45,102 +39,57 @@ class CacheManager {
         public String toString() {
             return type;
         }
-
-    }
-
-    static void saveEvent(Context context, String event, JSONObject object, String actionId, String actionInputText) {
-        if (context == null) {
-            RNMMLogger.e(Utils.TAG, "context is null, can't cache event " + event);
-            return;
-        }
-        String serialized = serializer.serialize(new Event(event, object, actionId, actionInputText));
-        saveStringsToSet(context, EVENTS_KEY, serialized);
     }
 
-    static void saveEvent(Context context, String event, int unreadMessagesCounter) {
-        if (context == null) {
-            RNMMLogger.e(Utils.TAG, "context is null, can't cache event " + event);
-            return;
-        }
-        //int `unreadMessagesCounter` isn't a JSONObject, so it'll go as a second argument
-        String serialized = serializer.serialize(new Event(event, null, unreadMessagesCounter));
-        saveStringsToSet(context, EVENTS_KEY, serialized);
-    }
-
-    static Event[] loadEvents(Context context, String eventType) {
-        if (context == null) {
-            RNMMLogger.e(Utils.TAG, "context is null, can't load cached events " + eventType);
-            return new Event[0];
-        }
-        Set<String> serialized = getStringSet(context, EVENTS_KEY);
-        if (serialized == null || serialized.isEmpty()) {
-            return new Event[0];
-        }
-
-        List<Event> matched = new ArrayList<>();
-        Set<String> unmatchedSerialized = new HashSet<>();
-        for (String s : serialized) {
-            Event e = serializer.deserialize(s, Event.class);
-            if (eventType.equals(e.type)) {
-                matched.add(e);
-            } else {
-                unmatchedSerialized.add(s);
+    static void saveEvent(String event, JSONObject object, String actionId, String actionInputText) {
+        synchronized (cacheLock) {
+            if (cachedEvents.size() >= MAX_CACHE_SIZE) {
+                Event removed = cachedEvents.remove(0);
+                RNMMLogger.w(Utils.TAG, "Cache full, dropping oldest event: " + removed.type);
             }
+            cachedEvents.add(new Event(event, object, actionId, actionInputText));
         }
-
-        updateStringsSet(context, EVENTS_KEY, unmatchedSerialized);
-
-        return matched.toArray(new Event[matched.size()]);
     }
 
-    private static Set<String> getStringSet(Context context, String key) {
-        SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(context);
+    static void saveEvent(String event, int unreadMessagesCounter) {
         synchronized (cacheLock) {
-            return new HashSet<>(sharedPreferences.getStringSet(key, new HashSet<String>()));
+            if (cachedEvents.size() >= MAX_CACHE_SIZE) {
+                Event removed = cachedEvents.remove(0);
+                RNMMLogger.w(Utils.TAG, "Cache full, dropping oldest event: " + removed.type);
+            }
+            cachedEvents.add(new Event(event, null, unreadMessagesCounter));
         }
     }
 
-    private static Set<String> getAndRemoveStringSet(Context context, String key) {
-        SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(context);
-        Set<String> set;
+    static Event[] loadEvents(String eventType) {
         synchronized (cacheLock) {
-            set = sharedPreferences.getStringSet(key, new HashSet<String>());
-            if (set.isEmpty()) {
-                return new HashSet<String>();
+            List<Event> matched = new ArrayList<>();
+            Iterator<Event> iterator = cachedEvents.iterator();
+            while (iterator.hasNext()) {
+                Event e = iterator.next();
+                if (eventType.equals(e.type)) {
+                    matched.add(e);
+                    iterator.remove();
+                }
             }
-            sharedPreferences
-                    .edit()
-                    .remove(key)
-                    .apply();
+            return matched.toArray(new Event[0]);
         }
-        return set;
     }
 
-    @SuppressWarnings("UnusedReturnValue")
-    private static Set<String> saveStringsToSet(Context context, String key, String... strings) {
-        return saveStringSet(context, key, new HashSet<String>(Arrays.asList(strings)));
-    }
-
-    private static Set<String> saveStringSet(Context context, String key, Set<String> newSet) {
-        SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(context);
+    static void clearCache() {
         synchronized (cacheLock) {
-            Set<String> set = sharedPreferences.getStringSet(key, new HashSet<String>());
-            newSet.addAll(set);
-            sharedPreferences
-                    .edit()
-                    .putStringSet(key, newSet)
-                    .apply();
-            return set;
+            cachedEvents.clear();
         }
     }
 
-    private static void updateStringsSet(Context context, String key, Set<String> newSet) {
+    static void cleanupLegacyCache(Context context) {
+        if (context == null) {
+            return;
+        }
         SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(context);
-        synchronized (cacheLock) {
-            sharedPreferences
-                    .edit()
-                    .putStringSet(key, newSet)
-                    .apply();
+        if (sharedPreferences.contains(LEGACY_EVENTS_KEY)) {
+            sharedPreferences.edit().remove(LEGACY_EVENTS_KEY).apply();
+            RNMMLogger.d(Utils.TAG, "Cleaned up legacy SharedPreferences event cache");
         }
     }
 }

package/android/src/main/java/org/infobip/reactlibrary/mobilemessaging/RNMMChatService.kt

@@ -392,18 +392,22 @@ class RNMMChatEventReceiver : ReactNativeBroadcastReceiver() {
         emitOrCache(context, RNMMChatService.EVENT_INAPPCHAT_UNREAD_MESSAGES_COUNT_UPDATED, unreadChatMessagesCounter)
     }
 
+    // Early-exit when plugin is not initialized avoids calling getReactContext() which throws
+    // UnsupportedOperationException on new architecture when app is killed. When reactContext is
+    // null (e.g. during lifecycle transitions), events are cached regardless of jsHasListeners
+    // since sending requires a valid ReactContext. This preserves the original behavior.
     private fun emitOrCache(context: Context?, eventType: String, unreadMessagesCounter: Int) {
+        if (!pluginInitialized) {
+            CacheManager.saveEvent(eventType, unreadMessagesCounter)
+            return
+        }
         val reactContext: ReactContext? = getReactContext(context)
-        if (!pluginInitialized || reactContext == null) {
-            CacheManager.saveEvent(context, eventType, unreadMessagesCounter)
-        } else if (jsHasListeners && reactContext != null) {
+        if (reactContext == null) {
+            CacheManager.saveEvent(eventType, unreadMessagesCounter)
+        } else if (jsHasListeners) {
             ReactNativeEvent.send(eventType, reactContext, unreadMessagesCounter)
-        } else if (reactContext != null) {
-            CacheManager.saveEvent(reactContext, eventType, unreadMessagesCounter)
-        } else if (context != null) {
-            CacheManager.saveEvent(context, eventType, unreadMessagesCounter)
         } else {
-            RNMMLogger.e(TAG, "Both reactContext and androidContext are null, can't emit or cache event " + eventType)
+            CacheManager.saveEvent(eventType, unreadMessagesCounter)
         }
     }
 }

package/android/src/main/java/org/infobip/reactlibrary/mobilemessaging/ReactNativeBroadcastReceiver.kt

@@ -27,11 +27,16 @@ abstract class ReactNativeBroadcastReceiver : BroadcastReceiver() {
         get() = ReactNativeMobileMessagingService.jsHasListeners
 
     protected fun getReactContext(context: Context?): ReactContext? {
-        return ReactNativeMobileMessagingService.lastReactContext
-            ?: (context?.applicationContext as? ReactApplication)
-                ?.reactNativeHost
-                ?.reactInstanceManager
-                ?.currentReactContext
+        return try {
+            ReactNativeMobileMessagingService.lastReactContext
+                ?: (context?.applicationContext as? ReactApplication)
+                    ?.reactNativeHost
+                    ?.reactInstanceManager
+                    ?.currentReactContext
+        } catch (e: Exception) {
+            RNMMLogger.w(Utils.TAG, "Failed to get ReactContext: ${e.message}")
+            null
+        }
     }
 
 }   

package/android/src/main/java/org/infobip/reactlibrary/mobilemessaging/ReactNativeMobileMessagingService.kt

@@ -417,6 +417,7 @@ class ReactNativeMobileMessagingService(
                 ctx.userAttributes,
                 ctx.forceDepersonalize,
                 ctx.keepAsLead,
+                ctx.setDeviceAsPrimary,
                 object : MobileMessaging.ResultListener<User>() {
                     override fun onResult(result: Result<User, MobileMessagingError>) {
                         if (result.isSuccess()) {
@@ -448,6 +449,7 @@ class ReactNativeMobileMessagingService(
             mobileMessaging.depersonalize(object : MobileMessaging.ResultListener<SuccessPending>() {
                 override fun onResult(result: Result<SuccessPending, MobileMessagingError>) {
                     if (result.isSuccess) {
+                        mobileMessaging.setJwtSupplier { null }
                         val state = when (result.data) {
                             SuccessPending.Pending -> "pending"
                             SuccessPending.Success -> "success"
@@ -510,10 +512,25 @@ class ReactNativeMobileMessagingService(
         successCallback.invoke(readableMap)
     }
 
+    fun cleanup(successCallback: Callback, errorCallback: Callback) {
+        RNMMLogger.d(Utils.TAG, "Cleanup...")
+        try {
+            mobileMessaging.setJwtSupplier { null }
+            mobileMessaging.cleanup()
+            successCallback.invoke()
+        } catch (e: Exception) {
+            errorCallback.invoke(Utils.callbackError(e.message, null))
+        }
+    }
+
     fun setUserDataJwt(jwt: String?, successCallback: Callback, errorCallback: Callback) {
         RNMMLogger.d(Utils.TAG, "SetUserDataJwt...")
         try {
-            mobileMessaging.setJwtSupplier({ jwt })
+            if (jwt.isNullOrEmpty()) {
+                mobileMessaging.setJwtSupplier(null)
+            } else {
+                mobileMessaging.setJwtSupplier { jwt }
+            }
             successCallback.invoke()
         } catch (e: Exception) {
             errorCallback.invoke(Utils.callbackError(e.message, null))
@@ -951,7 +968,7 @@ class ReactNativeMobileMessagingService(
     fun addListener(eventName: String) {
         RNMMLogger.d(Utils.TAG, "addListener: $eventName")
         jsHasListeners = true
-        val events = CacheManager.loadEvents(reactContext, eventName)
+        val events = CacheManager.loadEvents(eventName)
         for (event in events) {
             if (eventName == event.type) {
                 ReactNativeEvent.send(event.type, reactContext, event.jsonObject, *event.objects)
@@ -1088,18 +1105,22 @@ class MessageEventReceiver : ReactNativeBroadcastReceiver() {
         emitOrCache(event, context, message, actionId, actionInputText)
     }
 
+    // Early-exit when plugin is not initialized avoids calling getReactContext() which throws
+    // UnsupportedOperationException on new architecture when app is killed. When reactContext is
+    // null (e.g. during lifecycle transitions), events are cached regardless of jsHasListeners
+    // since sending requires a valid ReactContext. This preserves the original behavior.
     private fun emitOrCache(eventType: String, context: Context?, message: JSONObject?, actionId: String?, actionInputText: String?) {
+        if (!pluginInitialized) {
+            CacheManager.saveEvent(eventType, message, actionId, actionInputText)
+            return
+        }
         val reactContext: ReactContext? = getReactContext(context)
-        if (!pluginInitialized || reactContext == null) {
-            CacheManager.saveEvent(context, eventType, message, actionId, actionInputText)
-        } else if (jsHasListeners && reactContext != null) {
+        if (reactContext == null) {
+            CacheManager.saveEvent(eventType, message, actionId, actionInputText)
+        } else if (jsHasListeners) {
             ReactNativeEvent.send(eventType, reactContext, message, actionId, actionInputText)
-        } else if (reactContext != null) {
-            CacheManager.saveEvent(reactContext, eventType, message, actionId, actionInputText)
-        } else if (context != null) {
-            CacheManager.saveEvent(context, eventType, message, actionId, actionInputText)
         } else {
-            RNMMLogger.e(Utils.TAG, "Both reactContext and androidContext are null, can't emit or cache event " + eventType)
+            CacheManager.saveEvent(eventType, message, actionId, actionInputText)
         }
     }
 

package/android/src/newarchitecture/java/org/infobip/reactlibrary/mobilemessaging/MobileMessagingModule.kt

@@ -27,6 +27,7 @@ class MobileMessagingModule(reactContext: ReactApplicationContext) : NativeMobil
 
     init {
         reactApplicationContext.addLifecycleEventListener(this)
+        CacheManager.cleanupLegacyCache(reactApplicationContext)
         ReactNativeMobileMessagingService.pluginInitialized = true
         service.registerBroadcastReceiver()
     }
@@ -159,6 +160,12 @@ class MobileMessagingModule(reactContext: ReactApplicationContext) : NativeMobil
         service.showDialogForError(errorCode, successCallback, errorCallback)
     }
 
+    // Cleanup
+    override fun cleanup(successCallback: Callback, errorCallback: Callback) {
+        RNMMLogger.d(TAG, "Cleanup...")
+        service.cleanup(successCallback, errorCallback)
+    }
+
     // JWT
     override fun setUserDataJwt(jwt: String?, successCallback: Callback, errorCallback: Callback) {
         RNMMLogger.d(TAG, "SetUserDataJwt...")
@@ -199,6 +206,7 @@ class MobileMessagingModule(reactContext: ReactApplicationContext) : NativeMobil
     override fun onHostDestroy() {
         ReactNativeMobileMessagingService.pluginInitialized = false
         service.unregisterBroadcastReceiver()
+        CacheManager.clearCache()
         reactApplicationContext.removeLifecycleEventListener(this)
         ReactNativeMobileMessagingService.unregisterService(reactApplicationContext)
     }

package/android/src/oldarchitecture/java/org/infobip/reactlibrary/mobilemessaging/MobileMessagingModule.kt

@@ -28,6 +28,7 @@ class MobileMessagingModule(reactContext: ReactApplicationContext) : ReactContex
 
     init {
         reactApplicationContext.addLifecycleEventListener(this)
+        CacheManager.cleanupLegacyCache(reactApplicationContext)
         ReactNativeMobileMessagingService.pluginInitialized = true
         service.registerBroadcastReceiver()
     }
@@ -186,6 +187,13 @@ class MobileMessagingModule(reactContext: ReactApplicationContext) : ReactContex
         service.submitEventImmediately(eventData, successCallback, errorCallback)
     }
 
+    // Cleanup
+    @ReactMethod
+    fun cleanup(successCallback: Callback, errorCallback: Callback) {
+        RNMMLogger.d(TAG, "Cleanup...")
+        service.cleanup(successCallback, errorCallback)
+    }
+
     // JWT
     @ReactMethod
     fun setUserDataJwt(jwt: String?, successCallback: Callback, errorCallback: Callback) {
@@ -230,6 +238,7 @@ class MobileMessagingModule(reactContext: ReactApplicationContext) : ReactContex
 
     override fun onHostDestroy() {
         service.unregisterBroadcastReceiver()
+        CacheManager.clearCache()
         reactApplicationContext.removeLifecycleEventListener(this)
         ReactNativeMobileMessagingService.pluginInitialized = false
         ReactNativeMobileMessagingService.unregisterService(reactApplicationContext)

package/infobip-mobile-messaging-react-native-plugin.podspec

@@ -1,7 +1,7 @@
 require "json"
 
 package = JSON.parse(File.read(File.join(__dir__, "package.json")))
-mmVersion = "15.0.0"
+mmVersion = "15.5.0"
 
 Pod::Spec.new do |s|
   s.name         = "infobip-mobile-messaging-react-native-plugin"
@@ -20,7 +20,9 @@ Pod::Spec.new do |s|
   s.requires_arc = true
 
   s.dependency "React-Core"
-  s.dependency "React-Core-prebuilt"
+  if ENV['RCT_USE_PREBUILT_RNCORE'] == '1'
+    s.dependency "React-Core-prebuilt"
+  end
 
   s.dependency "MobileMessaging/Core", mmVersion
   s.dependency "MobileMessaging/InAppChat", mmVersion

package/ios/MobileMessagingPlugin/RNMobileMessaging.swift

@@ -98,60 +98,109 @@ class ReactNativeMobileMessaging: RCTEventEmitter  {
     
     @objc(init:onSuccess:onError:)
     func start(config: NSDictionary, onSuccess: @escaping RCTResponseSenderBlock, onError: @escaping RCTResponseSenderBlock) {
-        guard let config = config as? [String : AnyObject], let configuration = RNMobileMessagingConfiguration(rawConfig: config) else {
+        guard var userConfigDict = config as? [String : AnyObject],
+              let applicationCode = userConfigDict.removeValue(forKey: RNMobileMessagingConfiguration.Keys.applicationCode) as? String,
+              let configuration = RNMobileMessagingConfiguration(rawConfig: userConfigDict)
+        else {
             onError([NSError(type: .InvalidArguments).reactNativeObject])
             return
         }
         
         let successCallback: RCTResponseSenderBlock = { [weak self] response in
-            RNMobileMessagingConfiguration.saveConfigToDefaults(rawConfig: config)
+            RNMobileMessagingConfiguration.saveConfigToDefaults(rawConfig: userConfigDict)
             self?.isStarted = true
             onSuccess(response)
         }
-        
+
         let cachedConfigDict = RNMobileMessagingConfiguration.getRawConfigFromDefaults()
-        if let cachedConfigDict = cachedConfigDict, (config as NSDictionary) != (cachedConfigDict as NSDictionary)
-        {
+        let keychainApplicationCode = MobileMessaging.getKeychainApplicationCode()
+        let shouldRestart = needsRestart(userConfigDict: userConfigDict, applicationCode: applicationCode)
+        let shouldStart = cachedConfigDict == nil || keychainApplicationCode == nil
+
+        if shouldRestart {
             stop {
-                self.start(configuration: configuration, onSuccess: successCallback)
+                self.startWithApplicationCode(
+                    configuration: configuration,
+                    applicationCode: applicationCode,
+                    onSuccess: successCallback,
+                    onError: onError
+                )
             }
-        } else if cachedConfigDict == nil {
-            start(configuration: configuration, onSuccess: successCallback)
+        } else if shouldStart {
+            startWithApplicationCode(
+                configuration: configuration,
+                applicationCode: applicationCode,
+                onSuccess: successCallback,
+                onError: onError
+            )
         } else {
             successCallback(nil)
         }
     }
     
     private func performEarlyStartIfPossible() {
-        if let cachedConfigDict = RNMobileMessagingConfiguration.getRawConfigFromDefaults(),
-           let configuration = RNMobileMessagingConfiguration(rawConfig: cachedConfigDict),
-           !self.isStarted,
-           !isEarlyStartPerformed
+        let cachedConfigDict = RNMobileMessagingConfiguration.getRawConfigFromDefaults()
+        let configuration = cachedConfigDict.flatMap(RNMobileMessagingConfiguration.init)
+        let applicationCode = MobileMessaging.getKeychainApplicationCode()
+
+        guard let configuration = configuration,
+              let applicationCode = applicationCode,
+              !self.isStarted,
+              !isEarlyStartPerformed else
         {
-            MMLogDebug("[RNMobileMessaging] Performing early start")
-            isEarlyStartPerformed = true
-            start(configuration: configuration) { response in }
+            return
+        }
+
+        isEarlyStartPerformed = true
+        startWithApplicationCode(configuration: configuration, applicationCode: applicationCode) { response in }
+    }
+    
+    private func startWithApplicationCode(
+        configuration: RNMobileMessagingConfiguration,
+        applicationCode: String,
+        onSuccess: @escaping RCTResponseSenderBlock,
+        onError: RCTResponseSenderBlock? = nil
+    ) {
+        guard let mobileMessaging = createMobileMessagingInstance(
+            configuration: configuration,
+            applicationCode: applicationCode
+        ) else {
+            MMLogError("[RNMobileMessaging] Failed to initialize MobileMessaging instance, SDK can't start.")
+            onError?([NSError(type: .InitializationFailed).reactNativeObject])
+            return
         }
+
+        applyConfigurationAndStart(
+            mobileMessaging,
+            configuration: configuration,
+            onSuccess: onSuccess
+        )
     }
-    
-    private func start(configuration: RNMobileMessagingConfiguration, onSuccess: @escaping RCTResponseSenderBlock) {
+
+    private func createMobileMessagingInstance(configuration: RNMobileMessagingConfiguration, applicationCode: String) -> MobileMessaging? {
+        let backendBaseURL = configuration.backendBaseURL ?? MMConsts.APIValues.prodDynamicBaseURLString
+        return MobileMessaging.withApplicationCode(
+            applicationCode,
+            notificationType: configuration.notificationType,
+            backendBaseURL: backendBaseURL
+        )
+    }
+
+    private func applyConfigurationAndStart(_ mobileMessaging: MobileMessaging, configuration: RNMobileMessagingConfiguration, onSuccess: @escaping RCTResponseSenderBlock) {
         self.eventsManager?.startObserving()
         MobileMessaging.privacySettings.systemInfoSendingDisabled = configuration.privacySettings[RNMobileMessagingConfiguration.Keys.systemInfoSendingDisabled].unwrap(orDefault: false)
         MobileMessaging.privacySettings.carrierInfoSendingDisabled = configuration.privacySettings[RNMobileMessagingConfiguration.Keys.carrierInfoSendingDisabled].unwrap(orDefault: false)
         MobileMessaging.privacySettings.userDataPersistingDisabled = configuration.privacySettings[RNMobileMessagingConfiguration.Keys.userDataPersistingDisabled].unwrap(orDefault: false)
         
-        var mobileMessaging = MobileMessaging.withApplicationCode(
-            configuration.appCode,
-            notificationType: configuration.notificationType,
-            backendBaseURL: configuration.backendBaseURL ?? MMConsts.APIValues.prodDynamicBaseURLString)
+        var mobileMessaging = mobileMessaging
         
         if let storageAdapter = messageStorageAdapter, configuration.messageStorageEnabled {
-            mobileMessaging = mobileMessaging?.withMessageStorage(storageAdapter)
+            mobileMessaging = mobileMessaging.withMessageStorage(storageAdapter)
         } else if configuration.defaultMessageStorage {
-            mobileMessaging = mobileMessaging?.withDefaultMessageStorage()
+            mobileMessaging = mobileMessaging.withDefaultMessageStorage()
         }
         if let categories = configuration.categories {
-            mobileMessaging = mobileMessaging?.withInteractiveNotificationCategories(Set(categories))
+            mobileMessaging = mobileMessaging.withInteractiveNotificationCategories(Set(categories))
         }
         MobileMessaging.userAgent.pluginVersion = "reactNative \(configuration.reactNativePluginVersion)"
         if configuration.logging {
@@ -159,22 +208,22 @@ class ReactNativeMobileMessaging: RCTEventEmitter  {
         }
 
         if configuration.inAppChatEnabled {
-            mobileMessaging = mobileMessaging?.withInAppChat()
+            mobileMessaging = mobileMessaging.withInAppChat()
         }
 
         if configuration.fullFeaturedInAppsEnabled {
-            mobileMessaging = mobileMessaging?.withFullFeaturedInApps()
+            mobileMessaging = mobileMessaging.withFullFeaturedInApps()
         }
         
         if let webViewSettings = configuration.webViewSettings {
-            mobileMessaging?.webViewSettings.configureWith(rawConfig: webViewSettings)
+            mobileMessaging.webViewSettings.configureWith(rawConfig: webViewSettings)
         }
 
         if let jwt = configuration.userDataJwt, !jwt.isEmpty {
-          mobileMessaging = mobileMessaging?.withJwtSupplier(VariableJwtSupplier(jwt: jwt))
+            mobileMessaging = mobileMessaging.withJwtSupplier(VariableJwtSupplier(jwt: jwt))
         }
 
-        mobileMessaging?.start({
+        mobileMessaging.start({
             onSuccess(nil)
         })
     }
@@ -183,6 +232,13 @@ class ReactNativeMobileMessaging: RCTEventEmitter  {
         self.eventsManager?.stop(stopObservations: stopObservations)
         MobileMessaging.stop(false, completion: completion)
     }
+
+    private func needsRestart(userConfigDict: [String: AnyObject], applicationCode: String) -> Bool {
+        let configurationChanged = RNMobileMessagingConfiguration.didConfigurationChange(userConfigDict: userConfigDict)
+        let applicationCodeChanged = MobileMessaging.didApplicationCodeChange(applicationCode: applicationCode)
+
+        return configurationChanged || applicationCodeChanged
+    }
     
     /*User Profile Management*/
     
@@ -328,7 +384,8 @@ class ReactNativeMobileMessaging: RCTEventEmitter  {
         let ua = uaDict == nil ? nil : MMUserAttributes(dictRepresentation: uaDict!)
         let keepAsLead = (context["keepAsLead"] as? Bool) ?? false
         let forceDepersonalize = context["forceDepersonalize"] as? Bool ?? false
-        MobileMessaging.personalize(forceDepersonalize: forceDepersonalize, keepAsLead: keepAsLead, userIdentity: ui, userAttributes: ua) { (error) in
+        let setDeviceAsPrimary = (context["setDeviceAsPrimary"] as? Bool) ?? false
+        MobileMessaging.personalize(forceDepersonalize: forceDepersonalize, keepAsLead: keepAsLead, setDeviceAsPrimary: setDeviceAsPrimary, userIdentity: ui, userAttributes: ua) { (error) in
             if let error = error {
                 onError([error.reactNativeObject])
             } else {
@@ -340,12 +397,15 @@ class ReactNativeMobileMessaging: RCTEventEmitter  {
     @objc(depersonalize:onError:)
     func depersonalize(onSuccess: @escaping RCTResponseSenderBlock, onError: @escaping RCTResponseSenderBlock) {
         MobileMessaging.depersonalize(completion: { (status, error) in
-            if (status == MMSuccessPending.pending) {
-                onSuccess(["pending"])
-            } else if let error = error {
+            if let error = error {
                 onError([error.reactNativeObject])
             } else {
-                onSuccess(["success"])
+                MobileMessaging.jwtSupplier = nil
+                if (status == MMSuccessPending.pending) {
+                    onSuccess(["pending"])
+                } else {
+                    onSuccess(["success"])
+                }
             }
         })
     }
@@ -472,9 +532,22 @@ class ReactNativeMobileMessaging: RCTEventEmitter  {
         onError([NSError(type: .NotSupported).reactNativeObject])
     }
 
+    @objc(cleanup:onError:)
+    func cleanup(onSuccess: @escaping RCTResponseSenderBlock, onError: @escaping RCTResponseSenderBlock) {
+        MobileMessaging.jwtSupplier = nil
+        RNMobileMessagingConfiguration.saveConfigToDefaults(rawConfig: [:])
+        MobileMessaging.cleanUpAndStop(false, completion: {
+            onSuccess([])
+        })
+    }
+
     @objc(setUserDataJwt:onSuccess:onError:)
     func setUserDataJwt(jwt: String?, onSuccess: @escaping RCTResponseSenderBlock, onError: @escaping RCTResponseSenderBlock) {
-      MobileMessaging.jwtSupplier = VariableJwtSupplier(jwt: jwt)
+      if let jwt = jwt, !jwt.isEmpty {
+          MobileMessaging.jwtSupplier = VariableJwtSupplier(jwt: jwt)
+      } else {
+          MobileMessaging.jwtSupplier = nil
+      }
       onSuccess(nil)
     }
 

package/ios/MobileMessagingPlugin/RNMobileMessagingBridge.m

@@ -54,6 +54,9 @@ RCT_EXTERN_METHOD(fetchInboxMessages:(NSString *)token externalUserId:(NSString
 RCT_EXTERN_METHOD(fetchInboxMessagesWithoutToken:(NSString *)externalUserId inboxFilterOptions:(NSDictionary *)inboxFilterOptions onSuccess:(RCTResponseSenderBlock)successCallback onError:(RCTResponseSenderBlock)errorCallback)
 RCT_EXTERN_METHOD(setInboxMessagesSeen:(NSString *)externalUserId messages:(NSArray *)messages onSuccess:(RCTResponseSenderBlock)successCallback onError:(RCTResponseSenderBlock)errorCallback)
 
+/*Cleanup*/
+RCT_EXTERN_METHOD(cleanup:(RCTResponseSenderBlock)onSuccess onError:(RCTResponseSenderBlock)onError)
+
 /*JWT*/
 RCT_EXTERN_METHOD(setUserDataJwt:(NSString *)jwt onSuccess:(RCTResponseSenderBlock)successCallback onError:(RCTResponseSenderBlock)errorCallback)
 @end

package/ios/MobileMessagingPlugin/RNMobileMessagingConfiguration.swift

@@ -11,6 +11,7 @@ import MobileMessaging
 
 class RNMobileMessagingConfiguration {
     static let userDefaultsConfigKey = "com.mobile-messaging.reactNativePluginConfiguration"
+    static let ignoreKeysWhenComparing: [String] = [Keys.reactNativePluginVersion]
 
     struct Keys {
         static let privacySettings = "privacySettings"
@@ -34,7 +35,6 @@ class RNMobileMessagingConfiguration {
         static let backendBaseURL = "backendBaseURL"
     }
 
-    let appCode: String
     let webRTCUI: [String: AnyObject]?
     let messageStorageEnabled: Bool
     let defaultMessageStorage: Bool
@@ -50,13 +50,11 @@ class RNMobileMessagingConfiguration {
     let backendBaseURL: String?
 
     init?(rawConfig: [String: AnyObject]) {
-        guard let appCode = rawConfig[RNMobileMessagingConfiguration.Keys.applicationCode] as? String,
-            let ios = rawConfig["ios"] as? [String: AnyObject] else
+        guard let ios = rawConfig["ios"] as? [String: AnyObject] else
         {
             return nil
         }
 
-        self.appCode = appCode
         self.webRTCUI = rawConfig[RNMobileMessagingConfiguration.Keys.webRTCUI] as? [String: AnyObject]
         self.logging = rawConfig[RNMobileMessagingConfiguration.Keys.logging].unwrap(orDefault: false)
         self.defaultMessageStorage = rawConfig[RNMobileMessagingConfiguration.Keys.defaultMessageStorage].unwrap(orDefault: false)
@@ -70,7 +68,6 @@ class RNMobileMessagingConfiguration {
             ps[RNMobileMessagingConfiguration.Keys.userDataPersistingDisabled] = rawPrivacySettings[RNMobileMessagingConfiguration.Keys.userDataPersistingDisabled].unwrap(orDefault: false)
             ps[RNMobileMessagingConfiguration.Keys.carrierInfoSendingDisabled] = rawPrivacySettings[RNMobileMessagingConfiguration.Keys.carrierInfoSendingDisabled].unwrap(orDefault: false)
             ps[RNMobileMessagingConfiguration.Keys.systemInfoSendingDisabled] = rawPrivacySettings[RNMobileMessagingConfiguration.Keys.systemInfoSendingDisabled].unwrap(orDefault: false)
-            ps[RNMobileMessagingConfiguration.Keys.applicationCodePersistingDisabled] = rawPrivacySettings[RNMobileMessagingConfiguration.Keys.applicationCodePersistingDisabled].unwrap(orDefault: false)
 
             privacySettings = ps
         } else {
@@ -108,17 +105,7 @@ class RNMobileMessagingConfiguration {
     }
 
     static func saveConfigToDefaults(rawConfig: [String: AnyObject]) {
-        var serializableConfig = rawConfig.compactMapValues { value -> AnyObject? in
-            if value is NSString || value is NSNumber || value is NSArray || value is NSDictionary || value is NSDate || value is NSData {
-                return value
-            }
-            return nil
-        }
-        if serializableConfig[RNMobileMessagingConfiguration.Keys.messageStorage] != nil {
-            // Temporal fix so the archiving doesn't fail (messageStorage doesn't contain codable objects).
-            // Below we overwrite it with a dummy value so messageStorageEnabled keeps working.
-            serializableConfig[RNMobileMessagingConfiguration.Keys.messageStorage] = NSString(string: "message_storage")
-        }
+        let serializableConfig = serializedConfig(from: rawConfig)
 
         do {
             let data: Data = try NSKeyedArchiver.archivedData(withRootObject: serializableConfig, requiringSecureCoding: false)
@@ -135,10 +122,71 @@ class RNMobileMessagingConfiguration {
         }
 
         do {
-            return try NSKeyedUnarchiver.unarchiveTopLevelObjectWithData(data) as? [String: AnyObject]
+            guard let rawConfig = try NSKeyedUnarchiver.unarchiveTopLevelObjectWithData(data) as? [String: AnyObject] else {
+                return nil
+            }
+
+            let normalizedConfig = serializedConfig(from: rawConfig)
+            if (normalizedConfig as NSDictionary) != (rawConfig as NSDictionary) {
+                saveConfigToDefaults(rawConfig: normalizedConfig)
+            }
+
+            return normalizedConfig
         } catch {
             MMLogError("[MobileMessaging] Failed to unarchive config from UserDefaults: \(error)")
             return nil
         }
     }
+
+    static func didConfigurationChange(userConfigDict: [String: AnyObject]) -> Bool {
+        var serializedUserConfig = serializedConfig(from: userConfigDict)
+        guard let cachedConfigDict = getRawConfigFromDefaults() else {
+            return false
+        }
+        var serializedCachedConfig = serializedConfig(from: cachedConfigDict)
+
+        removeIgnoredKeys(from: &serializedUserConfig)
+        removeIgnoredKeys(from: &serializedCachedConfig)
+
+        return (serializedUserConfig as NSDictionary) != (serializedCachedConfig as NSDictionary)
+    }
+
+    private static func serializedConfig(from rawConfig: [String: AnyObject]) -> [String: AnyObject] {
+        var rawConfig = rawConfig
+        rawConfig.removeValue(forKey: RNMobileMessagingConfiguration.Keys.applicationCode)
+        rawConfig.removeValue(forKey: RNMobileMessagingConfiguration.Keys.userDataJwt)
+        sanitizePrivacySettings(in: &rawConfig)
+
+        var serializableConfig = rawConfig.compactMapValues { value -> AnyObject? in
+            if value is NSString || value is NSNumber || value is NSArray || value is NSDictionary || value is NSDate || value is NSData {
+                return value
+            }
+            return nil
+        }
+
+        if rawConfig[RNMobileMessagingConfiguration.Keys.messageStorage] != nil {
+            // Preserve the fact that custom message storage was configured without persisting the JS callbacks.
+            serializableConfig[RNMobileMessagingConfiguration.Keys.messageStorage] = NSString(string: "message_storage")
+        }
+
+        return serializableConfig
+    }
+
+    private static func removeIgnoredKeys(from config: inout [String: AnyObject]) {
+        ignoreKeysWhenComparing.forEach { config.removeValue(forKey: $0) }
+    }
+
+    private static func sanitizePrivacySettings(in rawConfig: inout [String: AnyObject]) {
+        guard var rawPrivacySettings = rawConfig[RNMobileMessagingConfiguration.Keys.privacySettings] as? [String: Any] else {
+            return
+        }
+
+        rawPrivacySettings.removeValue(forKey: RNMobileMessagingConfiguration.Keys.applicationCodePersistingDisabled)
+
+        if rawPrivacySettings.isEmpty {
+            rawConfig.removeValue(forKey: RNMobileMessagingConfiguration.Keys.privacySettings)
+        } else {
+            rawConfig[RNMobileMessagingConfiguration.Keys.privacySettings] = rawPrivacySettings as NSDictionary
+        }
+    }
 }

package/ios/MobileMessagingPlugin/RNMobileMessagingErrorExtension.swift

@@ -16,6 +16,7 @@ public enum RNMobileMessagingErrorType: Error {
     case DefaultStorageNotInitialized
     case NotSupported
     case NoData
+    case InitializationFailed
 
     fileprivate var errorCode: Int {
         switch self {
@@ -29,6 +30,8 @@ public enum RNMobileMessagingErrorType: Error {
             return 3
         case .NoData:
             return 4
+        case .InitializationFailed:
+            return 5
         }
 
     }
@@ -47,6 +50,8 @@ public enum RNMobileMessagingErrorType: Error {
             errorDescription = NSLocalizedString("Functionality is not supported.", comment: "")
         case .NoData:
             errorDescription = NSLocalizedString("No data retrieved.", comment: "")
+        case .InitializationFailed:
+            errorDescription = NSLocalizedString("Could not initialize MobileMessaging SDK.", comment: "")
         }
         return errorDescription
     }

package/ios/MobileMessagingPlugin/RNMobileMessagingUtils.swift

@@ -39,6 +39,12 @@ extension MMInbox {
         var result = [String: Any]()
         result["countTotal"] = countTotal
         result["countUnread"] = countUnread
+        if let countTotalFiltered = countTotalFiltered {
+            result["countTotalFiltered"] = countTotalFiltered
+        }
+        if let countUnreadFiltered = countUnreadFiltered {
+            result["countUnreadFiltered"] = countUnreadFiltered
+        }
         result["messages"] = messages.map({ return $0.dictionaryRepresentation })
         return result
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "infobip-mobile-messaging-react-native-plugin",
   "title": "Infobip Mobile Messaging React Native Plugin",
-  "version": "14.8.3",
+  "version": "14.9.1",
   "description": "Infobip Mobile Messaging React Native Plugin",
   "main": "./src/index.js",
   "scripts": {

package/src/index.d.ts

@@ -64,7 +64,6 @@ declare namespace MobileMessagingReactNative {
             notificationSound?: string;
         };
         privacySettings?: {
-            applicationCodePersistingDisabled?: boolean;
             userDataPersistingDisabled?: boolean;
             carrierInfoSendingDisabled?: boolean;
             systemInfoSendingDisabled?: boolean
@@ -130,13 +129,16 @@ declare namespace MobileMessagingReactNative {
     export interface MMInbox {
         countTotal: number;
         countUnread: number;
-        messages?: [Message];
+        countTotalFiltered?: number;
+        countUnreadFiltered?: number;
+        messages?: Message[];
     }
 
     export interface MMInboxFilterOptions {
         fromDateTime?: string;
         toDateTime?: string;
         topic?: string;
+        topics?: string[];
         limit?: number;
     }
 
@@ -145,10 +147,12 @@ declare namespace MobileMessagingReactNative {
         userAttributes?: Record<string, string | number | boolean | object[]>;
         forceDepersonalize?: boolean;
         keepAsLead?: boolean;
+        setDeviceAsPrimary?: boolean;
     }
 
     export interface Message {
         messageId: string;
+        topic?: string;
         title?: string;
         body?: string;
         sound?: string;
@@ -720,6 +724,16 @@ declare namespace MobileMessagingReactNative {
          */
         setChatDomain(domain?: string): void;
 
+        /**
+         * Cleans up the SDK, removing all data and stopping all services.
+         * After cleanup, you should call init() again with a new configuration to restart the SDK.
+         * JWT supplier is also cleared during cleanup.
+         *
+         * @param onSuccess will be called on success
+         * @param onError will be called on error
+         */
+        cleanup(onSuccess: () => void, onError: (error: MobileMessagingError) => void): void;
+
         /**
          * Set JSON Web Token for user data operations and personalization.
          * @param jwt JWT token in predefined format

package/src/index.js

@@ -166,7 +166,6 @@ class MobileMessaging {
  *              notificationSound: <String>
      *	    }
      *		privacySettings: {
-     *			applicationCodePersistingDisabled: <Boolean>,
      *			userDataPersistingDisabled: <Boolean>,
      *			carrierInfoSendingDisabled: <Boolean>,
      *			systemInfoSendingDisabled: <Boolean>
@@ -285,7 +284,14 @@ class MobileMessaging {
      * @name fetchInboxMessages
      * @param token access token (JWT in a strictly predefined format) required for current user to have access to the Inbox messages
      * @param externalUserId External User ID is meant to be an ID of a user in an external (non-Infobip) service
-     * @param filterOptions filtering options applied to messages list in response. Nullable, will return default number of messages
+     * @param filterOptions filtering options applied to messages list in response.
+     * {
+     *   fromDateTime: <String; filter messages received after this datetime in ISO8601 format with timezone, e.g. "2024-03-11T12:00:00+01:00">,
+     *   toDateTime: <String; filter messages received before this datetime in ISO8601 format with timezone, e.g. "2024-03-20T12:00:00+01:00">,
+     *   topic: <String; filter messages by a single topic. Mutually exclusive with 'topics'>,
+     *   topics: <Array<String>; filter messages by multiple topics, e.g. ["topic1", "topic2"]. Mutually exclusive with 'topic'>,
+     *   limit: <Number; maximum number of messages to return. Default is 20 for standard/single-topic fetches. When using 'topics', no default limit is applied unless explicitly provided, and the limit applies to the total returned messages, not per topic>,
+     * }
      * @param onSuccess will be called on success
      * @param {Function} onError will be called on error
      */
@@ -298,7 +304,14 @@ class MobileMessaging {
      *
      * @name fetchInboxMessagesWithoutToken
      * @param externalUserId External User ID is meant to be an ID of a user in an external (non-Infobip) service
-     * @param filterOptions filtering options applied to messages list in response. Nullable, will return default number of messages
+     * @param filterOptions filtering options applied to messages list in response.
+     * {
+     *   fromDateTime: <String; filter messages received after this datetime in ISO8601 format with timezone, e.g. "2024-03-11T12:00:00+01:00">,
+     *   toDateTime: <String; filter messages received before this datetime in ISO8601 format with timezone, e.g. "2024-03-20T12:00:00+01:00">,
+     *   topic: <String; filter messages by a single topic. Mutually exclusive with 'topics'>,
+     *   topics: <Array<String>; filter messages by multiple topics, e.g. ["topic1", "topic2"]. Mutually exclusive with 'topic'>,
+     *   limit: <Number; maximum number of messages to return. Default is 20 for standard/single-topic fetches. When using 'topics', no default limit is applied unless explicitly provided, and the limit applies to the total returned messages, not per topic>,
+     * }
      * @param onSuccess will be called on success
      * @param {Function} onError will be called on error
      */
@@ -873,6 +886,19 @@ class MobileMessaging {
         RNMMChat.setChatDomain(domain);
     }
 
+    /**
+     * Cleans up the SDK, removing all data and stopping all services.
+     * After cleanup, you should call init() again with a new configuration to restart the SDK.
+     * JWT supplier is also cleared during cleanup.
+     *
+     * @name cleanup
+     * @param {Function} onSuccess will be called on success
+     * @param {Function} onError will be called on error
+     */
+    cleanup(onSuccess = function() {}, onError = function() {}) {
+        ReactNativeMobileMessaging.cleanup(onSuccess, onError);
+    }
+
     /**
      * Set JSON Web Token for user data operations and personalization.
      * @param {String} jwt JWT token in predefined format

package/src/specs/NativeMobileMessaging.ts

@@ -52,6 +52,9 @@ export interface Spec extends TurboModule {
     submitEvent(eventData: Object, onError: (error: Object) => void): void;
     submitEventImmediately(eventData: Object, onSuccess: () => void, onError: (error: Object) => void): void;
 
+    // Cleanup
+    cleanup(onSuccess: () => void, onError: (error: Object) => void): void;
+
     // JWT
     setUserDataJwt(jwt: string, onSuccess: () => void, onError: (error: Object) => void): void;