infobip-mobile-messaging-react-native-plugin 14.8.0 → 14.9.0

package/README.md

@@ -12,7 +12,7 @@ The document describes library integration steps for your React Native project.
 ## Requirements
 - node (v20.16.0 or higher)
 - ruby (2.7.8 or higher; the Example app uses 3.3.5)
-- React Native (v0.79.0)
+- React Native (v0.84.0)
 
 For iOS project:
 - Xcode and Command Line Tools (16.x or newer, tested with 26.0.1)

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

@@ -951,7 +951,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 +1088,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()
     }
@@ -199,6 +200,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()
     }
@@ -230,6 +231,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

@@ -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/RNMMChat.swift

@@ -13,9 +13,15 @@ import MobileMessaging
 class RNMMChat: NSObject  {
     private var willUseJWT = false
     private var willUseChatExceptionHandler = false
-    private var jwtRequestQueue: [((String?) -> Void)] = []
+    private var jwtRequestQueue: [JWTRequest] = []
     private let jwtQueueLock = NSLock()
 
+    private final class JWTRequest {
+        var completed = false
+        let onResult: (String?) -> Void
+        init(_ onResult: @escaping (String?) -> Void) { self.onResult = onResult }
+    }
+
     @objc(showChat:)
     func showChat(presentingOptions: NSDictionary) {
         MobileMessaging.inAppChat?.delegate = self
@@ -161,22 +167,26 @@ class RNMMChat: NSObject  {
     @objc(setChatJwtProvider)
     func setChatJwtProvider() {
         willUseJWT = true
+        // We cannot rely on 'showChat' for setting the delegate as we have several presentation modes - any async provider/handler request sets the delegate to ensure proper completions are triggered
+        MobileMessaging.inAppChat?.delegate = self
     }
 
     @objc(setChatExceptionHandler:)
     func setChatExceptionHandler(isHandlerPresent: NSNumber) {
         // NSNumber due to how RN bridge wraps JavaScript booleans
         willUseChatExceptionHandler = isHandlerPresent.boolValue
+        MobileMessaging.inAppChat?.delegate = self
     }
     
     @objc(setChatJwt:)
     func setChatJwt(jwt: String?) {
         jwtQueueLock.lock()
-        if !jwtRequestQueue.isEmpty {
-            let completion = jwtRequestQueue.removeFirst()
-            completion(jwt)
-        }
-        jwtQueueLock.unlock()
+        defer { jwtQueueLock.unlock() }
+        guard let request = jwtRequestQueue.first(where: { !$0.completed }) else { return }
+        request.completed = true
+        jwtRequestQueue.removeAll(where: { $0 === request })
+        // Settled inside the lock so a concurrent getJWT cleanup observes completed == true and jwtResult is set before getJWT returns.
+        request.onResult(jwt)
     }
 
     @objc(restartConnection)
@@ -201,15 +211,27 @@ extension RNMMChat: MMInAppChatDelegate {
         guard willUseJWT else { return nil }
         var jwtResult: String?
         let semaphore = DispatchSemaphore(value: 0)
-
-        jwtQueueLock.lock()
-        jwtRequestQueue.append { jwt in
+        let request = JWTRequest { jwt in
             jwtResult = jwt
             semaphore.signal()
         }
+
+        jwtQueueLock.lock()
+        jwtRequestQueue.append(request)
         jwtQueueLock.unlock()
-        ReactNativeMobileMessaging.shared?.sendEvent(withName: EventName.inAppChat_jwtRequested, body: nil)
+
+        ReactNativeMobileMessaging.shared?.sendDirectEvent(withName: EventName.inAppChat_jwtRequested, body: nil)
         _ = semaphore.wait(timeout: .now() + 45)
+
+        // Remove this request by identity (not position) so a setChatJwt that fires between the wait timeout and the lock cannot cause us to evict a different in-flight request.
+        jwtQueueLock.lock()
+        if !request.completed {
+            request.completed = true
+            if let idx = jwtRequestQueue.firstIndex(where: { $0 === request }) {
+                jwtRequestQueue.remove(at: idx)
+            }
+        }
+        jwtQueueLock.unlock()
         return jwtResult
     }
     

package/ios/MobileMessagingPlugin/RNMMChatViewManager.swift

@@ -37,7 +37,9 @@ class RNMMChatViewManager: RCTViewManager {
     }
 
     override func didMoveToWindow() {
-        embedViewController()
+        if window != nil { // this could be triggered in an improper manner from RN side, so we confirm UI is in a proper state
+            embedViewController()
+        }
         super.didMoveToWindow()
     }
 

package/ios/MobileMessagingPlugin/RNMobileMessaging.swift

@@ -64,6 +64,20 @@ class ReactNativeMobileMessaging: RCTEventEmitter  {
         }
         super.sendEvent(withName: name, body: body)
     }
+    
+    func sendDirectEvent(withName name: String!, body: Any!) {
+        guard let _eventsManager = eventsManager, _eventsManager.hasEventListeners == true else {
+            // JS listener persists on the mobileMessaging singleton but RCTEventEmitter's _listenerCount may be zero during a React Navigation transition (reproducible with custom chat navigations and JWT async callback/authentication flow). Bypass that guard by invoking RCTDeviceEventEmitter directly via the public callableJSModules API (bridgeless-safe; the same path super.sendEvent uses internally).
+            MMLogDebug("[RNMobileMessaging] sendDirectEvent: invoking RCTDeviceEventEmitter directly")
+            self.callableJSModules?.invokeModule(
+                "RCTDeviceEventEmitter",
+                method: "emit",
+                withArgs: [name!, body ?? NSNull()]
+            )
+            return
+        }
+        super.sendEvent(withName: name, body: body)
+    }
         
     @objc
     override static func requiresMainQueueSetup() -> Bool {
@@ -84,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 {
@@ -145,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)
         })
     }
@@ -169,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*/
     

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,70 @@ 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)
+        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.0",
+  "version": "14.9.0",
   "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;
     }
 
@@ -149,6 +151,7 @@ declare namespace MobileMessagingReactNative {
 
     export interface Message {
         messageId: string;
+        topic?: string;
         title?: string;
         body?: string;
         sound?: string;

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
      */