@attentive-mobile/attentive-react-native-sdk 2.0.0-beta.4 → 2.0.0-beta.6

package/android/src/main/kotlin/com/attentivereactnativesdk/AttentiveReactNativeSdkModule.kt

@@ -1,21 +1,25 @@
 package com.attentivereactnativesdk
 
 import android.app.Activity
+import android.app.Application
 import android.util.Log
 import android.view.ViewGroup
 import androidx.annotation.NonNull
 import androidx.annotation.Nullable
 import com.attentive.androidsdk.AttentiveConfig
-import com.attentive.androidsdk.AttentiveEventTracker
+import com.attentive.androidsdk.AttentiveSdk
 import com.attentive.androidsdk.UserIdentifiers
 import com.attentive.androidsdk.creatives.Creative
 import com.attentive.androidsdk.events.AddToCartEvent
+import com.attentive.androidsdk.events.Cart
 import com.attentive.androidsdk.events.CustomEvent
 import com.attentive.androidsdk.events.Item
 import com.attentive.androidsdk.events.Order
 import com.attentive.androidsdk.events.Price
 import com.attentive.androidsdk.events.ProductViewEvent
 import com.attentive.androidsdk.events.PurchaseEvent
+import com.attentive.androidsdk.push.TokenFetchResult
+import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.ReadableArray
@@ -23,7 +27,9 @@ import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.UiThreadUtil
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.Callback
+import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.attentivereactnativesdk.debug.AttentiveDebugHelper
+import com.attentive.androidsdk.AttentiveLogLevel
 import java.math.BigDecimal
 import java.security.InvalidParameterException
 import java.util.Currency
@@ -35,6 +41,7 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
     companion object {
         const val NAME = "AttentiveReactNativeSdk"
         private const val TAG = NAME
+        private const val PUSH_PERMISSION_REQUEST_CODE = 3901
     }
 
     private var attentiveConfig: AttentiveConfig? = null
@@ -49,6 +56,12 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
         return NAME
     }
 
+    /**
+     * Initialize the Attentive SDK. Called only from the TypeScript layer (e.g. Bonni App.tsx);
+     * this module must not auto-initialize in Application.onCreate or elsewhere.
+     * This is operation is a no-op on Android. Initialization should happen directly through
+     * native Kotlin for Android builds to enable subscriptions.
+     */
     override fun initialize(
         attentiveDomain: String,
         mode: String,
@@ -57,14 +70,6 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
     ) {
         // Initialize debug helper
         debugHelper.initialize(enableDebugger)
-
-        attentiveConfig = AttentiveConfig.Builder()
-            .context(reactApplicationContext)
-            .domain(attentiveDomain)
-            .mode(AttentiveConfig.Mode.valueOf(mode.uppercase(Locale.ROOT)))
-            .skipFatigueOnCreatives(skipFatigueOnCreatives)
-            .build()
-        AttentiveEventTracker.getInstance().initialize(attentiveConfig)
     }
 
     override fun triggerCreative(creativeId: String?) {
@@ -76,7 +81,7 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
                     currentActivity.window.decorView.rootView as ViewGroup
                 // The following calls edit the view hierarchy so they must run on the UI thread
                 UiThreadUtil.runOnUiThread {
-                    creative = Creative(attentiveConfig, rootView)
+                    creative = Creative(attentiveConfig!!, rootView, currentActivity)
                     creative?.trigger(null, creativeId)
                     if (debugHelper.isDebuggingEnabled()) {
                         val debugData = mutableMapOf<String, Any>()
@@ -153,9 +158,9 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
         Log.i(TAG, "Sending product viewed event")
 
         val itemsList = buildItems(items)
-        val productViewEvent = ProductViewEvent.Builder(itemsList).deeplink(deeplink).build()
+        val productViewEvent = ProductViewEvent.Builder().items(itemsList).deeplink(deeplink).build()
 
-        AttentiveEventTracker.getInstance().recordEvent(productViewEvent)
+        AttentiveSdk.recordEvent(productViewEvent)
 
         if (debugHelper.isDebuggingEnabled()) {
             val debugData = mutableMapOf<String, Any>()
@@ -172,12 +177,15 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
         cartCoupon: String?
     ) {
         Log.i(TAG, "Sending purchase event")
-        val order = Order.Builder(orderId).build()
-
+        val order = Order.Builder().orderId(orderId).build()
         val itemsList = buildItems(items)
-        val purchaseEvent = PurchaseEvent.Builder(itemsList, order).build()
+        val purchaseBuilder = PurchaseEvent.Builder(itemsList, order)
+        if (!cartId.isNullOrEmpty()) {
+            purchaseBuilder.cart(Cart.Builder().cartId(cartId).cartCoupon(cartCoupon).build())
+        }
+        val purchaseEvent = purchaseBuilder.build()
 
-        AttentiveEventTracker.getInstance().recordEvent(purchaseEvent)
+        AttentiveSdk.recordEvent(purchaseEvent)
 
         if (debugHelper.isDebuggingEnabled()) {
             val debugData = mutableMapOf<String, Any>()
@@ -193,9 +201,9 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
         Log.i(TAG, "Sending add to cart event")
 
         val itemsList = buildItems(items)
-        val addToCartEvent = AddToCartEvent.Builder(itemsList).deeplink(deeplink).build()
+        val addToCartEvent = AddToCartEvent.Builder().items(itemsList).deeplink(deeplink).build()
 
-        AttentiveEventTracker.getInstance().recordEvent(addToCartEvent)
+        AttentiveSdk.recordEvent(addToCartEvent)
 
         if (debugHelper.isDebuggingEnabled()) {
             val debugData = mutableMapOf<String, Any>()
@@ -211,9 +219,9 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
             throw IllegalArgumentException("The CustomEvent 'properties' field cannot be null.")
         }
         val propertiesMap = convertToStringMap(properties.toHashMap())
-        val customEvent = CustomEvent.Builder(type, propertiesMap).build()
+        val customEvent = CustomEvent.Builder().type(type).properties(propertiesMap).build()
 
-        AttentiveEventTracker.getInstance().recordEvent(customEvent)
+        AttentiveSdk.recordEvent(customEvent)
 
         if (debugHelper.isDebuggingEnabled()) {
             val debugData = mutableMapOf<String, Any>()
@@ -241,45 +249,99 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
     // ==========================================================================
     //
     // These methods provide Android push notification support.
-    // 
-    // IMPORTANT NOTE: The Attentive Android SDK version 1.0.1 has limited push notification
-    // support compared to version 2.x. These methods provide logging and debugging infrastructure
-    // but may require SDK upgrade or custom implementation for full functionality.
     //
-    // The iOS implementation uses APNs; Android uses Firebase Cloud Messaging (FCM).
+    // Push: Uses AttentiveSdk.getPushTokenWithCallback (SDK 2.1.x) to fetch FCM token and register with Attentive.
+    // See: https://github.com/attentive-mobile/attentive-android-sdk/blob/main/README.md
     // ==========================================================================
 
     /**
-     * Request push notification permission from the user.
+     * Request push notification permission and fetch the FCM token via the Attentive SDK.
      *
-     * Note: For Android 13+ (API 33+), you need to request POST_NOTIFICATIONS permission
-     * in your app's AndroidManifest.xml and request it at runtime.
-     * For older versions, permissions are granted at install time.
-     *
-     * This method is currently a logging placeholder for parity with iOS.
-     * Actual permission handling should be done in the host app.
+     * Uses [AttentiveSdk.getPushTokenWithCallback] so the SDK requests permission (when
+     * requestPermission = true) and registers the token with Attentive.
      */
     override fun registerForPushNotifications() {
         Log.i(TAG, "📱 [AttentiveSDK] registerForPushNotifications called (Android)")
-        Log.i(TAG, "   Note: Push notification permissions should be requested in your host app")
-        Log.i(TAG, "   For Android 13+, request POST_NOTIFICATIONS permission at runtime")
 
-        if (debugHelper.isDebuggingEnabled()) {
-            val debugData = mutableMapOf<String, Any>()
-            debugData["platform"] = "Android"
-            debugData["sdk_version"] = "1.0.1"
-            debugData["note"] = "Permission handling should be done in host app"
-            debugHelper.showDebugInfo("Push Registration Requested", debugData)
+        val application = reactApplicationContext.applicationContext as? Application
+        if (application == null) {
+            Log.w(TAG, "   Application context is null; cannot fetch push token.")
+            return
+        }
+
+        AttentiveSdk.getPushTokenWithCallback(application, true, createPushTokenCallback())
+    }
+
+    private fun createPushTokenCallback(): AttentiveSdk.PushTokenCallback =
+        object : AttentiveSdk.PushTokenCallback {
+            override fun onSuccess(result: TokenFetchResult) {
+                UiThreadUtil.runOnUiThread {
+                    val token = result.token
+                    Log.i(TAG, "🎫 [AttentiveSDK] Push token fetched successfully (preview): ${token.take(16)}...")
+
+                    // Emit the token to JS so the app can store it (e.g. for display in Settings)
+                    // and mirror the iOS behavior where APNs delivers the token via a "register" event.
+                    try {
+                        reactApplicationContext
+                            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                            .emit("AttentiveDeviceToken", token)
+                        Log.i(TAG, "📡 [AttentiveSDK] AttentiveDeviceToken event emitted to JS")
+                    } catch (e: Exception) {
+                        Log.w(TAG, "⚠️  [AttentiveSDK] Could not emit AttentiveDeviceToken event: ${e.message}")
+                    }
+
+                    if (debugHelper.isDebuggingEnabled()) {
+                        val debugData = mutableMapOf<String, Any>()
+                        debugData["platform"] = "Android"
+                        debugData["token_preview"] = "${token.take(16)}..."
+                        debugData["has_token"] = token.isNotEmpty()
+                        debugData["permission_granted"] = result.permissionGranted
+                        debugHelper.showDebugInfo("Push Token (AttentiveSdk)", debugData)
+                    }
+                }
+            }
+            override fun onFailure(exception: Exception) {
+                UiThreadUtil.runOnUiThread {
+                    Log.e(TAG, "❌ [AttentiveSDK] getPushTokenWithCallback failed: ${exception.message}", exception)
+                    if (debugHelper.isDebuggingEnabled()) {
+                        val debugData = mutableMapOf<String, Any>()
+                        debugData["error"] = exception.message ?: "Unknown error"
+                        debugHelper.showDebugInfo("Push Token Error", debugData)
+                    }
+                }
+            }
+        }
+
+    /**
+     * Returns the current push notification authorization status for Android.
+     *
+     * On API 33+: returns "authorized" if POST_NOTIFICATIONS is granted, else "notDetermined".
+     * On API < 33: returns "authorized" (no runtime permission required).
+     */
+    override fun getPushAuthorizationStatus(promise: Promise) {
+        try {
+            val status = AttentivePushHelper.getAuthorizationStatus(
+                reactApplicationContext,
+                reactApplicationContext.currentActivity
+            )
+            Log.d(TAG, "getPushAuthorizationStatus: $status")
+            promise.resolve(status)
+        } catch (e: Exception) {
+            Log.e(TAG, "getPushAuthorizationStatus error: ${e.message}", e)
+            promise.reject("GET_STATUS_ERROR", e.message ?: "Unknown error", e)
         }
     }
 
     /**
      * Register the device token (FCM token) with the Attentive backend.
      *
-     * This method attempts to register the FCM push token with the Attentive SDK.
-     * Note: The exact API for push token registration may vary by SDK version.
+     * The Attentive Android SDK does not expose an API that accepts a token string; it registers
+     * by fetching the FCM token from Firebase and sending it to Attentive. When the app passes
+     * its own FCM token (e.g. from Firebase Messaging in JS), that token matches the one the SDK
+     * will fetch. This method therefore triggers [AttentiveSdk.updatePushPermissionStatus], which
+     * fetches the current FCM token and registers it with Attentive, so push targeting works.
      *
-     * @param token The FCM registration token from Firebase
+     * @param token The FCM registration token from Firebase (used for logging; registration uses SDK fetch)
      * @param authorizationStatus Push authorization status (used for consistency with iOS)
      */
     override fun registerDeviceToken(token: String, authorizationStatus: String) {
@@ -289,22 +351,22 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
         Log.i(TAG, "   Authorization status: $authorizationStatus")
 
         try {
-            // Note: Attentive Android SDK 1.0.1 may not have direct push token registration
-            // For SDK version 2.x, use: AttentiveConfig.setDeviceToken() or similar
-            // For now, we log the token and make it available for custom implementation
-            
-            Log.i(TAG, "⚠️  [AttentiveSDK] Push token registration requires manual implementation")
-            Log.i(TAG, "   FCM token available: ${token.take(16)}...")
-            Log.i(TAG, "   Store this token and register it with Attentive backend manually")
-            Log.i(TAG, "   Or upgrade to Attentive Android SDK 2.x for built-in support")
+            val application = reactApplicationContext.applicationContext
+            if (application == null) {
+                Log.w(TAG, "   Application context is null; cannot register push token with Attentive.")
+                return
+            }
+            // Forward registration to the Attentive SDK. It will fetch the FCM token (same as app-provided
+            // token when the app gets it from Firebase) and register it with the Attentive backend.
+            AttentiveSdk.updatePushPermissionStatus(application)
+            Log.i(TAG, "   Attentive SDK updatePushPermissionStatus invoked (token will be fetched and registered)")
 
             if (debugHelper.isDebuggingEnabled()) {
                 val debugData = mutableMapOf<String, Any>()
                 debugData["token_preview"] = "${token.take(16)}..."
                 debugData["token_length"] = token.length.toString()
                 debugData["authorization_status"] = authorizationStatus
-                debugData["sdk_version"] = "1.0.1"
-                debugData["implementation_status"] = "manual_required"
+                debugData["registration_triggered"] = true
                 debugHelper.showDebugInfo("Device Token (Android)", debugData)
             }
         } catch (e: Exception) {
@@ -320,15 +382,17 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
     }
 
     /**
-     * Register the device token with callback for network response tracking.
+     * Register the device token with callback for flow consistency with iOS.
      *
-     * Note: The Android SDK version 1.0.1 doesn't provide a callback mechanism for
-     * push token registration. This method logs the token and invokes the callback
-     * immediately for consistency with the iOS API.
+     * Triggers the same registration as [registerDeviceToken] via [AttentiveSdk.updatePushPermissionStatus].
+     * The Attentive Android SDK does not expose a registration API with a completion callback, so this
+     * callback is invoked after registration has been triggered (token is fetched by the SDK and sent
+     * to Attentive). Success here means the registration request was triggered, not that the backend
+     * responded successfully.
      *
      * @param token The FCM registration token
      * @param authorizationStatus Push authorization status
-     * @param callback Callback invoked after registration attempt
+     * @param callback Callback invoked after registration has been triggered
      */
     override fun registerDeviceTokenWithCallback(
         token: String,
@@ -340,19 +404,18 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
         Log.i(TAG, "   Authorization status: $authorizationStatus")
 
         try {
-            // Register using the standard method (which logs the token)
+            // Trigger real registration (SDK fetches FCM token and registers with Attentive)
             registerDeviceToken(token, authorizationStatus)
 
-            // Invoke callback immediately with success response
+            // Callback is invoked after triggering registration; Android SDK does not provide backend result
             val responseData = mapOf(
                 "success" to true,
                 "token" to "${token.take(16)}...",
                 "platform" to "Android",
-                "sdk_version" to "1.0.1",
-                "note" to "Manual push token registration required"
+                "sdk_version" to "2.1.1",
+                "registration_triggered" to true
             )
 
-            // Invoke callback with: data, url, response, error
             callback.invoke(
                 responseData, // data
                 null, // url (not available in Android SDK)
@@ -360,7 +423,7 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
                 null // error
             )
 
-            Log.i(TAG, "📥 [AttentiveSDK] Callback invoked with success response")
+            Log.i(TAG, "📥 [AttentiveSDK] Callback invoked after registration triggered")
 
             if (debugHelper.isDebuggingEnabled()) {
                 val debugData = mutableMapOf<String, Any>()
@@ -394,58 +457,14 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
      * Handle regular/direct app open (not from a push notification).
      *
      * This tracks app open events using the Attentive SDK's event tracking system.
+     * This operation is iOS only. Android version is handled directly by native SDK upon
+     * TypeScript initialization.
      *
      * @param authorizationStatus Current push authorization status
      */
-    override fun handleRegularOpen(authorizationStatus: String) {
+    override fun handleRegularOpen(authorizationStatus: String) {  // Meant to be NOOP
         Log.i(TAG, "🌉 [AttentiveSDK] handleRegularOpen called (Android)")
         Log.i(TAG, "   Authorization status: $authorizationStatus")
-        Log.i(TAG, "   Tracking regular app open event...")
-
-        try {
-            // Attentive Android SDK 1.0.1 doesn't have a built-in handleRegularOpen method
-            // We can track this as a custom event or use AttentiveEventTracker
-            
-            // Option 1: Track as custom event
-            val properties = mapOf(
-                "event_type" to "app_open",
-                "authorization_status" to authorizationStatus,
-                "platform" to "Android"
-            )
-            
-            try {
-                val customEvent = com.attentive.androidsdk.events.CustomEvent.Builder(
-                    "app_open",
-                    properties
-                ).build()
-                
-                AttentiveEventTracker.getInstance().recordEvent(customEvent)
-                
-                Log.i(TAG, "✅ [AttentiveSDK] handleRegularOpen completed (tracked as custom event)")
-                Log.i(TAG, "   Event sent to Attentive backend")
-            } catch (e: Exception) {
-                Log.w(TAG, "⚠️  [AttentiveSDK] Could not track app open as custom event: ${e.message}")
-                Log.i(TAG, "   App open tracking requires manual implementation or SDK upgrade")
-            }
-
-            if (debugHelper.isDebuggingEnabled()) {
-                val debugData = mutableMapOf<String, Any>()
-                debugData["authorization_status"] = authorizationStatus
-                debugData["event_type"] = "regular_open"
-                debugData["platform"] = "Android"
-                debugData["sdk_version"] = "1.0.1"
-                debugHelper.showDebugInfo("Regular Open Event", debugData)
-            }
-        } catch (e: Exception) {
-            Log.e(TAG, "❌ [AttentiveSDK] Error in handleRegularOpen: ${e.message}", e)
-
-            if (debugHelper.isDebuggingEnabled()) {
-                val debugData = mutableMapOf<String, Any>()
-                debugData["error"] = e.message ?: "Unknown error"
-                debugData["error_type"] = e.javaClass.simpleName
-                debugHelper.showDebugInfo("Regular Open Error", debugData)
-            }
-        }
     }
 
     /**
@@ -472,20 +491,20 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
             properties["event_type"] = "push_open"
             properties["authorization_status"] = authorizationStatus
             properties["platform"] = "Android"
-            
+
             // Add notification payload to properties (converting to strings)
             payload.forEach { (key, value) ->
                 properties["notification_$key"] = value?.toString() ?: "null"
             }
 
             try {
-                val customEvent = com.attentive.androidsdk.events.CustomEvent.Builder(
-                    "push_open",
-                    properties
-                ).build()
-                
-                AttentiveEventTracker.getInstance().recordEvent(customEvent)
-                
+                val customEvent = CustomEvent.Builder()
+                    .type("push_open")
+                    .properties(properties)
+                    .build()
+
+                AttentiveSdk.recordEvent(customEvent)
+
                 Log.i(TAG, "✅ [AttentiveSDK] handlePushOpen completed (tracked as custom event)")
                 Log.i(TAG, "   Push open event sent to Attentive backend")
             } catch (e: Exception) {
@@ -499,7 +518,7 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
                 debugData["event_type"] = "push_open"
                 debugData["platform"] = "Android"
                 debugData["payload_keys"] = payload.keys.joinToString(", ")
-                debugData["sdk_version"] = "1.0.1"
+                debugData["sdk_version"] = "2.1.1"
                 debugHelper.showDebugInfo("Push Open Event", debugData)
             }
         } catch (e: Exception) {
@@ -538,20 +557,20 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
             properties["event_type"] = "foreground_push"
             properties["authorization_status"] = authorizationStatus
             properties["platform"] = "Android"
-            
+
             // Add notification payload to properties (converting to strings)
             payload.forEach { (key, value) ->
                 properties["notification_$key"] = value?.toString() ?: "null"
             }
 
             try {
-                val customEvent = com.attentive.androidsdk.events.CustomEvent.Builder(
-                    "foreground_push",
-                    properties
-                ).build()
-                
-                AttentiveEventTracker.getInstance().recordEvent(customEvent)
-                
+                val customEvent = CustomEvent.Builder()
+                    .type("foreground_push")
+                    .properties(properties)
+                    .build()
+
+                AttentiveSdk.recordEvent(customEvent)
+
                 Log.i(TAG, "✅ [AttentiveSDK] handleForegroundPush completed (tracked as custom event)")
                 Log.i(TAG, "   Foreground push event sent to Attentive backend")
             } catch (e: Exception) {
@@ -565,7 +584,7 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
                 debugData["event_type"] = "foreground_push"
                 debugData["platform"] = "Android"
                 debugData["payload_keys"] = payload.keys.joinToString(", ")
-                debugData["sdk_version"] = "1.0.1"
+                debugData["sdk_version"] = "2.1.1"
                 debugHelper.showDebugInfo("Foreground Push Event", debugData)
             }
         } catch (e: Exception) {
@@ -633,6 +652,40 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
         handleForegroundPush(userInfo, "authorized")
     }
 
+    /**
+     * Returns the push notification payload that launched the app from a killed state
+     * (i.e. the user tapped a notification while the app was not running) and clears it
+     * so it is only delivered once.
+     *
+     * The host app's `MainActivity.onCreate` is responsible for storing the payload in
+     * [AttentiveNotificationStore] when a push-tap Intent is detected before the React
+     * Native bridge is ready.
+     *
+     * Returns a [Promise] that resolves to a `ReadableMap` containing the notification data,
+     * or `null` if the app was not launched from a push notification tap.
+     *
+     * @param promise Promise to resolve with the notification payload map or null.
+     */
+    override fun getInitialPushNotification(promise: Promise) {
+      Log.d(TAG, "getInitialPushNotification called!")
+    }
+
+    // ==========================================================================
+    // MARK: - NativeEventEmitter support
+    // ==========================================================================
+    // These stubs are required by React Native's NativeEventEmitter on the old
+    // architecture. Without them the bridge logs a warning about missing methods.
+
+    @ReactMethod
+    fun addListener(eventName: String) {
+        // No-op: listener bookkeeping is handled by the JS NativeEventEmitter.
+    }
+
+    @ReactMethod
+    fun removeListeners(count: Double) {
+        // No-op: listener bookkeeping is handled by the JS NativeEventEmitter.
+    }
+
     private fun convertToStringMap(inputMap: Map<String, Any?>): Map<String, String> {
         val outputMap = mutableMapOf<String, String>()
         for ((key, value) in inputMap) {
@@ -653,11 +706,16 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
             val rawItem = rawItems.getMap(i) ?: continue
 
             // Price and currency are now flattened, not nested
-            val priceValue = rawItem.getString("price")
-            val currencyCode = rawItem.getString("currency")
-            val price = Price.Builder(BigDecimal(priceValue), Currency.getInstance(currencyCode)).build()
-
-            val builder = Item.Builder(rawItem.getString("productId"), rawItem.getString("productVariantId"), price)
+            val priceValue = rawItem.getString("price") ?: continue
+            val currencyCode = rawItem.getString("currency") ?: continue
+            val price = Price.Builder()
+                .price(BigDecimal(priceValue))
+                .currency(Currency.getInstance(currencyCode))
+                .build()
+
+            val productId = rawItem.getString("productId") ?: continue
+            val productVariantId = rawItem.getString("productVariantId") ?: continue
+            val builder = Item.Builder(productId, productVariantId, price)
 
             if (rawItem.hasKey("productImage")) {
                 builder.productImage(rawItem.getString("productImage"))

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)
+    }
+}