@attentive-mobile/attentive-react-native-sdk 2.0.0-beta.5 → 2.0.0-beta.7

package/android/src/test/kotlin/com/attentivereactnativesdk/AttentiveNotificationStoreTest.kt

@@ -0,0 +1,103 @@
+package com.attentivereactnativesdk
+
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+/**
+ * Unit tests for [AttentiveNotificationStore].
+ *
+ * Verifies the store's core contract:
+ * - Starts empty.
+ * - Accepts a payload via [AttentiveNotificationStore.setPendingInitialNotification].
+ * - Returns the payload exactly once via [AttentiveNotificationStore.getAndClear].
+ * - Clears the store after retrieval (subsequent calls return null).
+ * - Replaces any previously stored value when set is called again.
+ */
+class AttentiveNotificationStoreTest {
+
+    @After
+    fun tearDown() {
+        // Ensure no state leaks between tests.
+        AttentiveNotificationStore.getAndClear()
+    }
+
+    @Test
+    fun `getAndClear returns null when no notification has been set`() {
+        val result = AttentiveNotificationStore.getAndClear()
+
+        assertNull("Expected null when nothing was stored", result)
+    }
+
+    @Test
+    fun `getAndClear returns the payload that was previously set`() {
+        val payload = mapOf(
+            "google.message_id" to "fcm-123",
+            "title" to "Flash Sale",
+            "body" to "40% off today only",
+        )
+
+        AttentiveNotificationStore.setPendingInitialNotification(payload)
+
+        val result = AttentiveNotificationStore.getAndClear()
+
+        assertEquals(payload, result)
+    }
+
+    @Test
+    fun `getAndClear returns null on the second call after the first consumed the payload`() {
+        val payload = mapOf("messageId" to "msg-1")
+        AttentiveNotificationStore.setPendingInitialNotification(payload)
+
+        // First retrieval — should return the payload.
+        val firstResult = AttentiveNotificationStore.getAndClear()
+        assertEquals(payload, firstResult)
+
+        // Second retrieval — store should be cleared.
+        val secondResult = AttentiveNotificationStore.getAndClear()
+        assertNull("Store should be empty after first getAndClear", secondResult)
+    }
+
+    @Test
+    fun `setPendingInitialNotification replaces any previously stored payload`() {
+        val firstPayload = mapOf("title" to "First Notification")
+        val secondPayload = mapOf("title" to "Second Notification", "body" to "Replacement")
+
+        AttentiveNotificationStore.setPendingInitialNotification(firstPayload)
+        AttentiveNotificationStore.setPendingInitialNotification(secondPayload)
+
+        val result = AttentiveNotificationStore.getAndClear()
+
+        assertEquals("Expected the second (replacement) payload", secondPayload, result)
+    }
+
+    @Test
+    fun `store handles payloads with all standard FCM fields`() {
+        val payload = mapOf(
+            "google.message_id" to "0:1234%abc",
+            "google.sent_time" to "1700000000000",
+            "from" to "123456789",
+            "collapse_key" to "com.bonni",
+            "title" to "New Order",
+            "body" to "Your order has shipped",
+            "channelId" to "orders",
+            "campaignId" to "camp-999",
+        )
+
+        AttentiveNotificationStore.setPendingInitialNotification(payload)
+        val result = AttentiveNotificationStore.getAndClear()
+
+        assertEquals(payload, result)
+    }
+
+    @Test
+    fun `store handles empty payloads without throwing`() {
+        val emptyPayload = emptyMap<String, String>()
+
+        AttentiveNotificationStore.setPendingInitialNotification(emptyPayload)
+        val result = AttentiveNotificationStore.getAndClear()
+
+        assertEquals(emptyPayload, result)
+    }
+}

package/attentive-react-native-sdk.podspec

@@ -16,7 +16,7 @@ Pod::Spec.new do |s|
 
   s.source_files = "ios/**/*.{h,m,mm,swift}"
 
-  s.dependency 'attentive-ios-sdk', '2.0.8'
+  s.dependency 'attentive-ios-sdk', '2.0.13'
   s.swift_versions = ['5']
   s.dependency "React-Core"
 

package/ios/AttentiveReactNativeSdk.mm

@@ -22,7 +22,8 @@
 RCT_EXPORT_MODULE()
 
 #ifdef RCT_NEW_ARCH_ENABLED
-// New Architecture implementation with flattened parameters
+// New Architecture implementation with flattened parameters.
+// Initialize is invoked only from TypeScript (e.g. Bonni App); native must not auto-initialize.
 - (void)initialize:(NSString *)attentiveDomain
               mode:(NSString *)mode
 skipFatigueOnCreatives:(BOOL)skipFatigueOnCreatives
@@ -189,7 +190,8 @@ customIdentifiers:(NSDictionary *)customIdentifiers {
 }
 
 #else
-// Old Architecture implementation with dictionary parameters
+// Old Architecture implementation with dictionary parameters.
+// Initialize is invoked only from TypeScript (e.g. Bonni App); native must not auto-initialize.
 - (void)initialize:(NSDictionary*)configuration {
     _sdk = [[ATTNNativeSDK alloc] initWithDomain:configuration[@"attentiveDomain"]
                                             mode:configuration[@"mode"]
@@ -311,6 +313,19 @@ customIdentifiers:(NSDictionary *)customIdentifiers {
    authorizationStatus:(NSString *)authorizationStatus {
     [_sdk handlePushOpenFromRN:userInfo authorizationStatus:authorizationStatus];
 }
+
+/**
+ * iOS stub for getInitialPushNotification.
+ *
+ * On iOS, the killed-state push-open event is tracked natively in
+ * AppDelegate.userNotificationCenter(_:didReceive:withCompletionHandler:) via
+ * AttentiveSDKManager.shared, so there is no pending payload to return here.
+ * Resolves with nil so callers on both platforms can share the same code path.
+ */
+- (void)getInitialPushNotification:(RCTPromiseResolveBlock)resolve
+                             reject:(RCTPromiseRejectBlock)reject {
+    resolve(nil);
+}
 #endif
 
 

package/ios/Bridging/ATTNNativeSDK.swift

@@ -280,7 +280,7 @@ struct DebugEvent {
 
   /**
    * Handle when a push notification is opened by the user.
-   * Note: SDK 2.0.8 changed the API to require UNNotificationResponse instead of userInfo dictionary.
+   * Note: The SDK requires UNNotificationResponse instead of a plain userInfo dictionary.
    * This method is kept for backward compatibility but has limited functionality.
    * For full functionality, handle push notifications natively in AppDelegate.
    *
@@ -290,11 +290,11 @@ struct DebugEvent {
    */
   @objc(handlePushOpened:applicationState:authorizationStatus:)
   public func handlePushOpened(_ userInfo: [String: Any], applicationState: String, authorizationStatus: String) {
-    // Note: SDK 2.0.8 changed the API to require UNNotificationResponse
+    // Note: The native SDK requires UNNotificationResponse for push tracking.
     // Since React Native doesn't provide direct access to UNNotificationResponse,
-    // apps should handle push notifications natively in AppDelegate for full functionality
-    print("[AttentiveSDK] Warning: Push notification handling from React Native is limited in SDK 2.0.8")
-    print("[AttentiveSDK] The native SDK now requires UNNotificationResponse for push tracking")
+    // apps should handle push notifications natively in AppDelegate for full functionality.
+    print("[AttentiveSDK] Warning: Push notification handling from React Native is limited")
+    print("[AttentiveSDK] The native SDK requires UNNotificationResponse for push tracking")
     print("[AttentiveSDK] Please implement push handling in AppDelegate for full functionality")
 
     if debuggingEnabled {
@@ -302,7 +302,7 @@ struct DebugEvent {
         "applicationState": applicationState,
         "authorizationStatus": authorizationStatus,
         "userInfo": userInfo,
-        "warning": "SDK 2.0.8 requires native UNNotificationResponse handling in AppDelegate"
+        "warning": "Native SDK requires UNNotificationResponse handling in AppDelegate"
       ])
     }
   }
@@ -313,15 +313,15 @@ struct DebugEvent {
    */
   @objc(handleForegroundNotification:)
   public func handleForegroundNotification(_ userInfo: [String: Any]) {
-    // Note: SDK 2.0.8 changed the API to require UNNotificationResponse
-    // Since React Native doesn't provide this, we'll log a warning
-    print("[AttentiveSDK] Warning: Foreground notification handling from React Native is limited in SDK 2.0.8")
+    // Note: The native SDK requires UNNotificationResponse for push tracking.
+    // Since React Native doesn't provide this, we'll log a warning.
+    print("[AttentiveSDK] Warning: Foreground notification handling from React Native is limited")
     print("[AttentiveSDK] Please handle foreground notifications natively in AppDelegate for full functionality")
 
     if debuggingEnabled {
       showDebugInfo(event: "Foreground Notification", data: [
         "userInfo": userInfo,
-        "warning": "SDK 2.0.8 requires native UNNotificationResponse handling"
+        "warning": "Native SDK requires UNNotificationResponse handling"
       ])
     }
   }
@@ -381,58 +381,128 @@ struct DebugEvent {
   }
 
   /**
-   * Handle a push notification when the app is in the foreground (active state) - React Native version.
-   * This method accepts userInfo dictionary instead of UNNotificationResponse, making it callable from React Native.
+   * React Native bridge entry point for foreground push tracking.
    *
-   * Note: This is a limited version since we don't have access to the full UNNotificationResponse.
-   * For full functionality, use the native AppDelegate implementation.
+   * The Attentive iOS SDK requires a `UNNotificationResponse` which cannot be
+   * serialised across the React Native bridge. To work around this, the method
+   * checks `AttentiveSDKManager.shared` for a cached response (set by the
+   * recommended `handleNotificationResponse(_:)` call in AppDelegate).
    *
-   * @param userInfo The notification payload dictionary
-   * @param authorizationStatus Current push authorization status string
+   * - If a cached response exists **and was already tracked**, this is a no-op
+   *   (prevents double-tracking).
+   * - If a cached response exists **but was not yet tracked**, it is used to
+   *   call the real native SDK method.
+   * - If no cached response is available, a warning is logged instructing the
+   *   developer to add `AttentiveSDKManager.shared.handleNotificationResponse(response)`
+   *   to their AppDelegate.
+   *
+   * @param userInfo The notification payload dictionary.
+   * @param authorizationStatus Current push authorization status string.
    */
   @objc(handleForegroundPushFromRN:authorizationStatus:)
   public func handleForegroundPushFromRN(_ userInfo: [String: Any], authorizationStatus: String) {
-    _ = mapAuthorizationStatus(authorizationStatus)
-
-    // Note: SDK 2.0.8 requires UNNotificationResponse, but we only have userInfo from React Native
-    // This is a workaround that logs the limitation
-    print("[AttentiveSDK] handleForegroundPush called from React Native (limited functionality)")
-    print("[AttentiveSDK] For full functionality, implement in native AppDelegate")
+    if let pending = AttentiveSDKManager.shared.consumePendingResponse() {
+      if pending.alreadyTracked {
+        // Already tracked by handleNotificationResponse — nothing to do.
+        if debuggingEnabled {
+          showDebugInfo(event: "Foreground Push (already tracked natively)", data: [
+            "authorizationStatus": authorizationStatus,
+            "note": "Push was already tracked via AttentiveSDKManager.handleNotificationResponse."
+          ])
+        }
+        return
+      }
 
-    if debuggingEnabled {
-      showDebugInfo(event: "Foreground Push (React Native)", data: [
-        "authorizationStatus": authorizationStatus,
-        "userInfo": userInfo,
-        "note": "Limited functionality - UNNotificationResponse not available from React Native"
-      ])
+      // Cached response exists but wasn't tracked yet — track it now.
+      let authStatus = mapAuthorizationStatus(authorizationStatus)
+      sdk.handleForegroundPush(response: pending.response, authorizationStatus: authStatus)
+
+      if debuggingEnabled {
+        let cachedUserInfo = pending.response.notification.request.content.userInfo
+        showDebugInfo(event: "Foreground Push (tracked via cached response)", data: [
+          "authorizationStatus": authorizationStatus,
+          "userInfo": cachedUserInfo as? [String: Any] ?? [:],
+          "actionIdentifier": pending.response.actionIdentifier
+        ])
+      }
+    } else {
+      // No cached response. Either:
+      //   (a) The client's AppDelegate is missing handleNotificationResponse, or
+      //   (b) A prior bridge call (handlePushOpen / handleForegroundPush) already consumed it.
+      print("[AttentiveSDK] handleForegroundPushFromRN: No cached UNNotificationResponse available.")
+      print("[AttentiveSDK] If push tracking is not working, add this line to your AppDelegate's didReceive handler:")
+      print("[AttentiveSDK]   AttentiveSDKManager.shared.handleNotificationResponse(response)")
+
+      if debuggingEnabled {
+        showDebugInfo(event: "Foreground Push (no cached response)", data: [
+          "authorizationStatus": authorizationStatus,
+          "userInfo": userInfo,
+          "note": "No cached response — either already consumed by a prior call or AppDelegate setup missing."
+        ])
+      }
     }
   }
 
   /**
-   * Handle when a push notification is opened by the user (app in background/inactive state) - React Native version.
-   * This method accepts userInfo dictionary instead of UNNotificationResponse, making it callable from React Native.
+   * React Native bridge entry point for push-open tracking (background/inactive tap).
    *
-   * Note: This is a limited version since we don't have access to the full UNNotificationResponse.
-   * For full functionality, use the native AppDelegate implementation.
+   * The Attentive iOS SDK requires a `UNNotificationResponse` which cannot be
+   * serialised across the React Native bridge. To work around this, the method
+   * checks `AttentiveSDKManager.shared` for a cached response (set by the
+   * recommended `handleNotificationResponse(_:)` call in AppDelegate).
    *
-   * @param userInfo The notification payload dictionary
-   * @param authorizationStatus Current push authorization status string
+   * - If a cached response exists **and was already tracked**, this is a no-op
+   *   (prevents double-tracking).
+   * - If a cached response exists **but was not yet tracked**, it is used to
+   *   call the real native SDK method.
+   * - If no cached response is available, a warning is logged instructing the
+   *   developer to add `AttentiveSDKManager.shared.handleNotificationResponse(response)`
+   *   to their AppDelegate.
+   *
+   * @param userInfo The notification payload dictionary.
+   * @param authorizationStatus Current push authorization status string.
    */
   @objc(handlePushOpenFromRN:authorizationStatus:)
   public func handlePushOpenFromRN(_ userInfo: [String: Any], authorizationStatus: String) {
-    _ = mapAuthorizationStatus(authorizationStatus)
-
-    // Note: SDK 2.0.8 requires UNNotificationResponse, but we only have userInfo from React Native
-    // This is a workaround that logs the limitation
-    print("[AttentiveSDK] handlePushOpen called from React Native (limited functionality)")
-    print("[AttentiveSDK] For full functionality, implement in native AppDelegate")
+    if let pending = AttentiveSDKManager.shared.consumePendingResponse() {
+      if pending.alreadyTracked {
+        // Already tracked by handleNotificationResponse — nothing to do.
+        if debuggingEnabled {
+          showDebugInfo(event: "Push Open (already tracked natively)", data: [
+            "authorizationStatus": authorizationStatus,
+            "note": "Push was already tracked via AttentiveSDKManager.handleNotificationResponse."
+          ])
+        }
+        return
+      }
 
-    if debuggingEnabled {
-      showDebugInfo(event: "Push Open (React Native)", data: [
-        "authorizationStatus": authorizationStatus,
-        "userInfo": userInfo,
-        "note": "Limited functionality - UNNotificationResponse not available from React Native"
-      ])
+      // Cached response exists but wasn't tracked yet — track it now.
+      let authStatus = mapAuthorizationStatus(authorizationStatus)
+      sdk.handlePushOpen(response: pending.response, authorizationStatus: authStatus)
+
+      if debuggingEnabled {
+        let cachedUserInfo = pending.response.notification.request.content.userInfo
+        showDebugInfo(event: "Push Open (tracked via cached response)", data: [
+          "authorizationStatus": authorizationStatus,
+          "userInfo": cachedUserInfo as? [String: Any] ?? [:],
+          "actionIdentifier": pending.response.actionIdentifier
+        ])
+      }
+    } else {
+      // No cached response. Either:
+      //   (a) The client's AppDelegate is missing handleNotificationResponse, or
+      //   (b) A prior bridge call (handlePushOpen / handleForegroundPush) already consumed it.
+      print("[AttentiveSDK] handlePushOpenFromRN: No cached UNNotificationResponse available.")
+      print("[AttentiveSDK] If push tracking is not working, add this line to your AppDelegate's didReceive handler:")
+      print("[AttentiveSDK]   AttentiveSDKManager.shared.handleNotificationResponse(response)")
+
+      if debuggingEnabled {
+        showDebugInfo(event: "Push Open (no cached response)", data: [
+          "authorizationStatus": authorizationStatus,
+          "userInfo": userInfo,
+          "note": "No cached response — either already consumed by a prior call or AppDelegate setup missing."
+        ])
+      }
     }
   }
 

package/ios/Bridging/AttentiveSDKManager.swift

@@ -7,6 +7,7 @@
 //
 
 import Foundation
+import UIKit
 import UserNotifications
 
 /**
@@ -14,21 +15,21 @@ import UserNotifications
  * This allows AppDelegate and other native code to access the SDK instance
  * that was initialized from React Native.
  *
- * Usage in AppDelegate:
+ * ## Minimal Integration (recommended)
+ *
+ * In your AppDelegate's `userNotificationCenter(_:didReceive:withCompletionHandler:)`,
+ * add **one line** to enable push-open and foreground-push tracking:
+ *
  * ```swift
- * // In userNotificationCenter(_:didReceive:withCompletionHandler:)
- * UNUserNotificationCenter.current().getNotificationSettings { settings in
- *   let authStatus = settings.authorizationStatus
- *   DispatchQueue.main.async {
- *     switch UIApplication.shared.applicationState {
- *     case .active:
- *       AttentiveSDKManager.shared.handleForegroundPush(response: response, authorizationStatus: authStatus)
- *     case .background, .inactive:
- *       AttentiveSDKManager.shared.handlePushOpen(response: response, authorizationStatus: authStatus)
- *     @unknown default:
- *       AttentiveSDKManager.shared.handlePushOpen(response: response, authorizationStatus: authStatus)
- *     }
- *   }
+ * func userNotificationCenter(_ center: UNUserNotificationCenter,
+ *                             didReceive response: UNNotificationResponse,
+ *                             withCompletionHandler completionHandler: @escaping () -> Void) {
+ *     // Track push interaction with Attentive (handles app-state detection + auth status internally)
+ *     AttentiveSDKManager.shared.handleNotificationResponse(response)
+ *
+ *     // Forward to your push library (e.g. RNCPushNotificationIOS) for JS-side handling
+ *     RNCPushNotificationIOS.didReceive(response)
+ *     completionHandler()
  * }
  * ```
  */
@@ -36,10 +37,40 @@ import UserNotifications
     /// Shared singleton instance
     @objc public static let shared: AttentiveSDKManager = AttentiveSDKManager()
 
-    /// The Attentive SDK instance as AnyObject for Objective-C compatibility
-    /// This should be set when the SDK is initialized from React Native
-    /// Cast to ATTNNativeSDK in Swift code
-    @objc public var sdk: AnyObject?
+    /// The Attentive SDK instance as AnyObject for Objective-C compatibility.
+    /// When set, any pending (untracked) notification response is automatically flushed.
+    @objc public var sdk: AnyObject? {
+        didSet {
+            if sdk != nil {
+                flushPendingResponseIfNeeded()
+            }
+        }
+    }
+
+    // MARK: - Notification Response Cache
+
+    /// The most recent UNNotificationResponse, cached so the RN bridge can use it
+    /// when JS calls handlePushOpen / handleForegroundPush.
+    ///
+    /// **Known limitation:** This is a single-slot cache. If two notifications
+    /// arrive in rapid succession (e.g. a tap followed immediately by a
+    /// foreground delivery), the second call to `handleNotificationResponse`
+    /// overwrites the first before its async tracking completes. In practice
+    /// this is extremely rare because `didReceive` is serialized by the system.
+    private var pendingResponse: UNNotificationResponse?
+
+    /// Whether the pending response has already been tracked via `handleNotificationResponse`.
+    /// Prevents double-tracking when both the native convenience method and the JS bridge fire.
+    private var pendingResponseTracked: Bool = false
+
+    /// The app state captured at the moment `handleNotificationResponse` was called.
+    /// Stored so that cold-launch replays use the original state (typically `.inactive`
+    /// or `.background`) rather than `.active` which is what the app will be in by the
+    /// time the SDK finishes initializing.
+    private var pendingAppState: UIApplication.State = .inactive
+
+    /// Serialises access to the cache fields above.
+    private let responseLock = NSLock()
 
     private override init() {
         super.init()
@@ -55,29 +86,167 @@ import UserNotifications
         sdk = nativeSDK
     }
 
-    // MARK: - Push Notification Handlers (for AppDelegate)
+    // MARK: - Push Notification Convenience Method
+
+    /**
+     * Handle a push notification response in one call.
+     *
+     * This is the **recommended** way to track push interactions on iOS.
+     * It automatically determines the app state, fetches the current
+     * authorization status, and calls the appropriate native SDK method
+     * (`handlePushOpen` or `handleForegroundPush`).
+     *
+     * Call this from your AppDelegate's
+     * `userNotificationCenter(_:didReceive:withCompletionHandler:)`.
+     *
+     * The response is also cached so that if the JS layer later calls
+     * `handlePushOpen()` or `handleForegroundPush()` via the RN bridge,
+     * the bridge can fulfil the call using the real `UNNotificationResponse`
+     * without double-tracking.
+     *
+     * **Cold-launch safety:** If the SDK has not yet been initialized (e.g. the
+     * app was launched from a killed state via a push tap), the response is
+     * cached and will be automatically tracked once `sdk` is set during RN
+     * bridge initialization.
+     *
+     * @param response The `UNNotificationResponse` from the notification center delegate.
+     */
+    @objc public func handleNotificationResponse(_ response: UNNotificationResponse) {
+        // UIApplication.shared.applicationState is a UIKit property that must
+        // be read on the main thread. userNotificationCenter(_:didReceive:) is
+        // almost always delivered on main, but we guard defensively.
+        let cacheAndTrack = { [self] (appState: UIApplication.State) in
+            // Cache the response for the RN bridge (consumed by handlePushOpenFromRN /
+            // handleForegroundPushFromRN).
+            responseLock.lock()
+            pendingResponse = response
+            pendingResponseTracked = false
+            pendingAppState = appState
+            responseLock.unlock()
+
+            trackResponse(response, appState: appState)
+        }
+
+        if Thread.isMainThread {
+            cacheAndTrack(UIApplication.shared.applicationState)
+        } else {
+            DispatchQueue.main.async {
+                cacheAndTrack(UIApplication.shared.applicationState)
+            }
+        }
+    }
+
+    // MARK: - Push Notification Handlers (legacy — prefer handleNotificationResponse)
 
     /**
      * Handle a push notification when the app is in the foreground (active state).
-     * Call this from AppDelegate's userNotificationCenter(_:didReceive:withCompletionHandler:)
-     * when UIApplication.shared.applicationState == .active
      *
-     * @param response The UNNotificationResponse from the notification center delegate
-     * @param authorizationStatus Current push authorization status from notification settings
+     * - Important: Deprecated — use ``handleNotificationResponse(_:)`` instead,
+     *   which handles app-state detection and auth-status lookup automatically.
+     *   Do **not** call both methods for the same notification.
      */
+    @available(*, deprecated, message: "Use handleNotificationResponse(_:) instead")
     @objc public func handleForegroundPush(response: UNNotificationResponse, authorizationStatus: UNAuthorizationStatus) {
         nativeSDK?.handleForegroundPush(response: response, authorizationStatus: authorizationStatus)
     }
 
     /**
      * Handle when a push notification is opened by the user (app in background/inactive state).
-     * Call this from AppDelegate's userNotificationCenter(_:didReceive:withCompletionHandler:)
-     * when UIApplication.shared.applicationState == .background or .inactive
      *
-     * @param response The UNNotificationResponse from the notification center delegate
-     * @param authorizationStatus Current push authorization status from notification settings
+     * - Important: Deprecated — use ``handleNotificationResponse(_:)`` instead,
+     *   which handles app-state detection and auth-status lookup automatically.
+     *   Do **not** call both methods for the same notification.
      */
+    @available(*, deprecated, message: "Use handleNotificationResponse(_:) instead")
     @objc public func handlePushOpen(response: UNNotificationResponse, authorizationStatus: UNAuthorizationStatus) {
         nativeSDK?.handlePushOpen(response: response, authorizationStatus: authorizationStatus)
     }
+
+    // MARK: - Response Cache (internal, used by RN bridge)
+
+    /**
+     * Consume the cached notification response.
+     *
+     * Returns the cached `UNNotificationResponse` and whether it was already
+     * tracked by `handleNotificationResponse`. The bridge uses this to decide
+     * whether to call the native SDK again.
+     *
+     * After this call the cache is cleared.
+     */
+    func consumePendingResponse() -> (response: UNNotificationResponse, alreadyTracked: Bool)? {
+        responseLock.lock()
+        defer { responseLock.unlock() }
+
+        guard let response = pendingResponse else { return nil }
+        let tracked = pendingResponseTracked
+        pendingResponse = nil
+        pendingResponseTracked = false
+        return (response, tracked)
+    }
+
+    // MARK: - Private
+
+    /// Attempt to track a cached response via the native SDK.
+    /// If nativeSDK is nil (cold launch), returns without marking tracked;
+    /// the `sdk` didSet will call `flushPendingResponseIfNeeded` later.
+    ///
+    /// Uses the supplied `appState` (captured at `handleNotificationResponse` time)
+    /// rather than the current app state, so cold-launch replays classify the
+    /// event correctly.
+    private func trackResponse(_ response: UNNotificationResponse, appState: UIApplication.State) {
+        UNUserNotificationCenter.current().getNotificationSettings { [weak self] settings in
+            guard let self = self else { return }
+            let authStatus = settings.authorizationStatus
+            DispatchQueue.main.async {
+                // Check that this response is still pending and untracked, then
+                // mark tracked optimistically *before* releasing the lock. This
+                // closes the window where consumePendingResponse() could run on
+                // another thread, see alreadyTracked: false, and also call the
+                // native SDK — resulting in double-tracking.
+                self.responseLock.lock()
+                guard self.pendingResponse === response, !self.pendingResponseTracked else {
+                    self.responseLock.unlock()
+                    return
+                }
+
+                guard self.nativeSDK != nil else {
+                    // SDK not yet initialized (cold launch). Leave
+                    // pendingResponseTracked = false so the didSet observer
+                    // on `sdk` can flush later.
+                    self.responseLock.unlock()
+                    return
+                }
+
+                // Mark tracked while still holding the lock, before the SDK call.
+                self.pendingResponseTracked = true
+                self.responseLock.unlock()
+
+                // Safe to call outside the lock — we've already claimed ownership.
+                switch appState {
+                case .active:
+                    self.nativeSDK?.handleForegroundPush(response: response, authorizationStatus: authStatus)
+                case .background, .inactive:
+                    self.nativeSDK?.handlePushOpen(response: response, authorizationStatus: authStatus)
+                @unknown default:
+                    self.nativeSDK?.handlePushOpen(response: response, authorizationStatus: authStatus)
+                }
+            }
+        }
+    }
+
+    /// Called from `sdk` didSet when the SDK becomes available.
+    /// If there is a pending untracked response (cold-launch scenario),
+    /// track it now using the app state captured at the original
+    /// `handleNotificationResponse` call.
+    private func flushPendingResponseIfNeeded() {
+        responseLock.lock()
+        guard let response = pendingResponse, !pendingResponseTracked else {
+            responseLock.unlock()
+            return
+        }
+        let appState = pendingAppState
+        responseLock.unlock()
+
+        trackResponse(response, appState: appState)
+    }
 }

package/ios/Podfile

@@ -20,7 +20,7 @@ target 'AttentiveReactNativeSdk' do
   flags = get_default_flags()
 
   # Ensure Swift support
-  pod 'attentive-ios-sdk', '2.0.8'
+  pod 'attentive-ios-sdk', '2.0.13'
 
   use_react_native!(
     :path => config[:reactNativePath],