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

package/README.md

@@ -68,12 +68,59 @@ See [DEBUGGING.md](./DEBUGGING.md) for detailed information about debugging feat
 
 ### Initialize the SDK
 
+> **Platform difference:** iOS and Android have different initialization requirements.
+
+#### iOS — Initialize from TypeScript
+
+On iOS, call `initialize` from TypeScript as early as possible (e.g. the root `App` component's `useEffect`):
+
 ```typescript
-// 'initialize' should be called as soon as possible after the app starts (see the example app for an example of initializing the SDK in the App element)
-// Note: 'initialize' should only be called once per app session - if you call it multiple times it will throw an exception
+// Called once per app session, before any other SDK operations.
 Attentive.initialize(config);
 ```
 
+#### Android — Initialize from Native Code
+
+On Android, `AttentiveSdk.initialize()` **must** be called from your `Application.onCreate()` in native Kotlin/Java code. This is required so that lifecycle observers (e.g. `AppLaunchTracker`) are registered before the React Native bridge is ready. Calling `initialize()` from TypeScript on Android is a **no-op** — the SDK will not be started and all subsequent event calls will fail.
+
+Add the following to your `MainApplication.kt` (or `MainApplication.java`):
+
+```kotlin
+import android.app.Application
+import com.attentive.androidsdk.AttentiveConfig
+import com.attentive.androidsdk.AttentiveSdk
+import com.attentive.androidsdk.AttentiveLogLevel
+import com.facebook.react.bridge.UiThreadUtil
+
+class MainApplication : Application(), ReactApplication {
+
+    override fun onCreate() {
+        super.onCreate()
+        // ... your existing setup ...
+        initAttentiveSDK()
+    }
+
+    private fun initAttentiveSDK() {
+        val config = AttentiveConfig.Builder()
+            .applicationContext(this)
+            .domain("YOUR_ATTENTIVE_DOMAIN")
+            .mode(AttentiveConfig.Mode.PRODUCTION) // or Mode.DEBUG for testing
+            .skipFatigueOnCreatives(false)
+            .logLevel(AttentiveLogLevel.VERBOSE)
+            .build()
+
+        // AttentiveSdk.initialize registers lifecycle observers and must run on the main thread.
+        UiThreadUtil.runOnUiThread {
+            AttentiveSdk.initialize(config)
+        }
+    }
+}
+```
+
+After the native initialization, all other SDK operations (`identify`, `recordAddToCartEvent`, `recordPurchaseEvent`, etc.) are called from TypeScript as normal on both platforms. The TypeScript `initialize()` call is still required on iOS but is safely ignored on Android.
+
+> **Tip:** If you see `[AttentiveSDK] recordAddToCartEvent failed — SDK may not be initialized` in your Android logcat, it means `AttentiveSdk.initialize()` was not called from native code before the event was recorded. Check your `Application.onCreate()` setup.
+
 ### Destroy the creative
 
 ```typescript
@@ -173,6 +220,25 @@ Attentive.identify({phone: '+15556667777'};)
 
 The SDK supports push notification integration on both iOS (APNs) and Android (runtime permission + optional FCM). The following sections cover iOS-specific flows and a full **App events on Android** implementation that mirrors the behavior of the [Bonni](https://github.com/attentive-mobile/attentive-react-native-sdk/tree/main/Bonni) example app.
 
+> **iOS — required setup:** Your AppDelegate **must** forward notification
+> responses to the SDK for push tracking to work. Add this single line to your
+> `userNotificationCenter(_:didReceive:withCompletionHandler:)`:
+>
+> ```swift
+> AttentiveSDKManager.shared.handleNotificationResponse(response)
+> ```
+>
+> Without this, push open and foreground push events **will not be tracked** on
+> iOS. See [iOS AppDelegate Integration](#ios-appdelegate-integration) for full
+> details.
+>
+> **Migrating from an earlier version?** If you previously called
+> `AttentiveSDKManager.shared.handleForegroundPush(response:authorizationStatus:)`
+> or `AttentiveSDKManager.shared.handlePushOpen(response:authorizationStatus:)`
+> directly from your AppDelegate, **replace** that code with the single
+> `handleNotificationResponse` call above. Using both will result in
+> double-tracked events. The old methods are now deprecated.
+
 ---
 
 ### App Events on Android
@@ -205,7 +271,7 @@ This section describes how to implement Attentive app events on Android so they
 </manifest>
 ```
 
-2. **Initialize and identify first** – In your app entry (e.g. root component `useEffect`), call `initialize(config)` and `identify(identifiers)` before any push or app-event logic.
+2. **Initialize and identify first** – The SDK must be initialized natively from `Application.onCreate()` on Android (see [Android Native Initialization](#android--initialize-from-native-code) above). Then, in your app entry (e.g. root component `useEffect`), call `identify(identifiers)` before any push or app-event logic.
 
 #### 1. On app launch (Android)
 
@@ -228,7 +294,13 @@ import {
 } from 'attentive-react-native-sdk';
 
 // Inside your root component (e.g. App.tsx useEffect):
-initialize(config);
+
+// iOS only: initialize from TypeScript.
+// Android: initialization must be done natively from Application.onCreate() — see README.
+if (Platform.OS === 'ios') {
+  initialize(config);
+}
+
 identify({ email: 'user@example.com', clientUserId: 'id-123' });
 
 if (Platform.OS === 'android') {
@@ -304,7 +376,7 @@ Get `authorizationStatus` via `getPushAuthorizationStatus()` when handling the e
 
 The [Bonni](https://github.com/attentive-mobile/attentive-react-native-sdk/tree/main/Bonni) example app ([App.tsx](https://github.com/attentive-mobile/attentive-react-native-sdk/blob/main/Bonni/App.tsx)) implements the full flow:
 
-1. **Launch:** `initialize` → `identify` → (Android) `getPushAuthorizationStatus()` → `handleRegularOpen(authStatus)` → `registerForPushNotifications()`.
+1. **Launch:** Native `AttentiveSdk.initialize(config)` (from `Application.onCreate()`) → TypeScript `identify` → `getPushAuthorizationStatus()` → `handleRegularOpen(authStatus)` → `registerForPushNotifications()`.
 2. **Foreground:** `AppState.addEventListener('change', …)` → when `active` and Android → `getPushAuthorizationStatus()` → `handleRegularOpen(authStatus)`.
 3. **Optional:** When FCM token is available → `registerDeviceTokenWithCallback(token, authStatus, callback)` → in callback call `handleRegularOpen(authStatus)`.
 4. **Optional:** When user opens a notification or receives one in foreground → `handlePushOpen` / `handleForegroundPush` with payload and status from `getPushAuthorizationStatus()`.
@@ -373,7 +445,40 @@ For proper push notification integration, your iOS AppDelegate needs to:
 
 1. Request notification permissions via the SDK
 2. Implement `application:didRegisterForRemoteNotificationsWithDeviceToken:` to register the token
-3. Implement `UNUserNotificationCenterDelegate` methods to handle notification events
+3. **Forward notification responses to the SDK for push-open tracking**
+
+##### Push Open Tracking (Required)
+
+Add **one line** to your AppDelegate's `didReceive` handler so the SDK can track
+push opens and foreground push events. Without this, `handlePushOpen()` and
+`handleForegroundPush()` called from JavaScript will not be able to track events
+on iOS (the native SDK requires a `UNNotificationResponse` which cannot cross the
+React Native bridge).
+
+```swift
+// In AppDelegate.swift — UNUserNotificationCenterDelegate
+func userNotificationCenter(
+    _ center: UNUserNotificationCenter,
+    didReceive response: UNNotificationResponse,
+    withCompletionHandler completionHandler: @escaping () -> Void
+) {
+    // Attentive push tracking (handles app-state + auth status automatically)
+    AttentiveSDKManager.shared.handleNotificationResponse(response)
+
+    // Forward to your push library (e.g. RNCPushNotificationIOS) for JS events
+    RNCPushNotificationIOS.didReceive(response)
+    completionHandler()
+}
+```
+
+`handleNotificationResponse` automatically:
+- Detects whether the app is in the foreground or background
+- Fetches the current authorization status
+- Calls the correct native SDK method (`handlePushOpen` or `handleForegroundPush`)
+- Caches the response so the JS-side `handlePushOpen()` / `handleForegroundPush()` calls
+  are fulfilled without double-tracking
+- **Cold-launch safe:** If the user taps a push while the app is killed, the
+  response is cached and automatically tracked once the SDK initializes
 
 ##### Callback-Based Registration (Recommended)
 
@@ -390,13 +495,13 @@ func application(
 ) {
     UNUserNotificationCenter.current().getNotificationSettings { settings in
         let authStatus = settings.authorizationStatus
-        
+
         // Get SDK instance with proper type
         guard let attentiveSdk = AttentiveSDKManager.shared.sdk as? ATTNNativeSDK else {
             print("[Attentive] SDK not initialized")
             return
         }
-        
+
         // Register device token with callback
         attentiveSdk.registerDeviceToken(
             deviceToken,
@@ -407,7 +512,7 @@ func application(
                     if let error = error {
                         print("[Attentive] Registration failed: \(error.localizedDescription)")
                     }
-                    
+
                     // Trigger regular open event after registration
                     attentiveSdk.handleRegularOpen(authorizationStatus: authStatus)
                 }

package/android/build.gradle

@@ -85,7 +85,7 @@ dependencies {
   // Use `api` so that the Attentive Android SDK types (AttentiveSdk, CustomEvent, etc.)
   // are visible to app-level code (e.g. Bonni's AttentiveFirebaseMessagingService) that
   // depends on this library and needs to call the SDK directly from native components.
-  api 'com.attentive:attentive-android-sdk:2.1.3-beta.1'
+  api 'com.attentive:attentive-android-sdk:2.1.3'
   implementation "org.jetbrains.kotlin:kotlin-stdlib:1.9.10"
   implementation(platform("org.jetbrains.kotlin:kotlin-bom:1.9.10"))
   

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

@@ -57,10 +57,28 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
     }
 
     /**
-     * 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.
+     * TypeScript-facing initialize() — intentionally a no-op on Android.
+     *
+     * On Android, AttentiveSdk.initialize() MUST be called from your Application.onCreate()
+     * (native code) so that lifecycle observers (AppLaunchTracker, etc.) are registered
+     * before the React Native bridge is ready. Calling this from TypeScript on Android has
+     * no effect and will not initialize the SDK.
+     *
+     * Required native setup in your Application class:
+     * ```kotlin
+     * override fun onCreate() {
+     *     super.onCreate()
+     *     val config = AttentiveConfig.Builder()
+     *         .applicationContext(this)
+     *         .domain("YOUR_ATTENTIVE_DOMAIN")
+     *         .mode(AttentiveConfig.Mode.PRODUCTION)
+     *         .build()
+     *     AttentiveSdk.initialize(config)
+     * }
+     * ```
+     *
+     * See the README.md "Android Native Initialization" section for the full guide.
+     * All other SDK operations (identify, recordEvent, push) are handled from TypeScript as normal.
      */
     override fun initialize(
         attentiveDomain: String,
@@ -68,8 +86,15 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
         skipFatigueOnCreatives: Boolean,
         enableDebugger: Boolean
     ) {
-        // Initialize debug helper
         debugHelper.initialize(enableDebugger)
+
+        Log.w(
+            TAG,
+            "[AttentiveSDK] initialize() called from TypeScript is a NO-OP on Android. " +
+            "You must call AttentiveSdk.initialize(config) from your Application.onCreate() " +
+            "so that lifecycle observers are registered before the React Native bridge is ready. " +
+            "See README.md § 'Android Native Initialization' for the required setup."
+        )
     }
 
     override fun triggerCreative(creativeId: String?) {
@@ -157,15 +182,29 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
     override fun recordProductViewEvent(items: ReadableArray, deeplink: String?) {
         Log.i(TAG, "Sending product viewed event")
 
+        val itemsDebugData = if (debugHelper.isDebuggingEnabled()) extractItemsDebugData(items) else emptyList()
+
         val itemsList = buildItems(items)
         val productViewEvent = ProductViewEvent.Builder().items(itemsList).deeplink(deeplink).build()
 
-        AttentiveSdk.recordEvent(productViewEvent)
+        try {
+            AttentiveSdk.recordEvent(productViewEvent)
+        } catch (e: Exception) {
+            Log.e(
+                TAG,
+                "[AttentiveSDK] recordProductViewEvent failed — SDK may not be initialized. " +
+                "On Android, call AttentiveSdk.initialize(config) from Application.onCreate() " +
+                "before recording events. Error: ${e.message}"
+            )
+            return
+        }
 
         if (debugHelper.isDebuggingEnabled()) {
             val debugData = mutableMapOf<String, Any>()
             debugData["items_count"] = itemsList.size.toString()
             debugData["deeplink"] = deeplink ?: ""
+            debugData["all_items"] = itemsDebugData
+            itemsDebugData.firstOrNull()?.let { debugData["first_item"] = it }
             debugHelper.showDebugInfo("Product View Event", debugData)
         }
     }
@@ -177,6 +216,9 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
         cartCoupon: String?
     ) {
         Log.i(TAG, "Sending purchase event")
+
+        val itemsDebugData = if (debugHelper.isDebuggingEnabled()) extractItemsDebugData(items) else emptyList()
+
         val order = Order.Builder().orderId(orderId).build()
         val itemsList = buildItems(items)
         val purchaseBuilder = PurchaseEvent.Builder(itemsList, order)
@@ -185,14 +227,26 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
         }
         val purchaseEvent = purchaseBuilder.build()
 
-        AttentiveSdk.recordEvent(purchaseEvent)
+        try {
+            AttentiveSdk.recordEvent(purchaseEvent)
+        } catch (e: Exception) {
+            Log.e(
+                TAG,
+                "[AttentiveSDK] recordPurchaseEvent failed — SDK may not be initialized. " +
+                "On Android, call AttentiveSdk.initialize(config) from Application.onCreate() " +
+                "before recording events. Error: ${e.message}"
+            )
+            return
+        }
 
         if (debugHelper.isDebuggingEnabled()) {
             val debugData = mutableMapOf<String, Any>()
             debugData["items_count"] = itemsList.size.toString()
             debugData["order_id"] = orderId
-            if (cartId != null) debugData["cart_id"] = cartId
-            if (cartCoupon != null) debugData["cart_coupon"] = cartCoupon
+            if (!cartId.isNullOrEmpty()) debugData["cart_id"] = cartId!!
+            if (!cartCoupon.isNullOrEmpty()) debugData["cart_coupon"] = cartCoupon!!
+            debugData["all_items"] = itemsDebugData
+            itemsDebugData.firstOrNull()?.let { debugData["first_item"] = it }
             debugHelper.showDebugInfo("Purchase Event", debugData)
         }
     }
@@ -200,15 +254,30 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
     override fun recordAddToCartEvent(items: ReadableArray, deeplink: String?) {
         Log.i(TAG, "Sending add to cart event")
 
+        // Extract raw debug data before building items so all bridge fields are preserved
+        val itemsDebugData = if (debugHelper.isDebuggingEnabled()) extractItemsDebugData(items) else emptyList()
+
         val itemsList = buildItems(items)
         val addToCartEvent = AddToCartEvent.Builder().items(itemsList).deeplink(deeplink).build()
 
-        AttentiveSdk.recordEvent(addToCartEvent)
+        try {
+            AttentiveSdk.recordEvent(addToCartEvent)
+        } catch (e: Exception) {
+            Log.e(
+                TAG,
+                "[AttentiveSDK] recordAddToCartEvent failed — SDK may not be initialized. " +
+                "On Android, call AttentiveSdk.initialize(config) from Application.onCreate() " +
+                "before recording events. Error: ${e.message}"
+            )
+            return
+        }
 
         if (debugHelper.isDebuggingEnabled()) {
             val debugData = mutableMapOf<String, Any>()
             debugData["items_count"] = itemsList.size.toString()
             debugData["deeplink"] = deeplink ?: ""
+            debugData["all_items"] = itemsDebugData
+            itemsDebugData.firstOrNull()?.let { debugData["first_item"] = it }
             debugHelper.showDebugInfo("Add To Cart Event", debugData)
         }
     }
@@ -221,7 +290,17 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
         val propertiesMap = convertToStringMap(properties.toHashMap())
         val customEvent = CustomEvent.Builder().type(type).properties(propertiesMap).build()
 
-        AttentiveSdk.recordEvent(customEvent)
+        try {
+            AttentiveSdk.recordEvent(customEvent)
+        } catch (e: Exception) {
+            Log.e(
+                TAG,
+                "[AttentiveSDK] recordCustomEvent failed — SDK may not be initialized. " +
+                "On Android, call AttentiveSdk.initialize(config) from Application.onCreate() " +
+                "before recording events. Error: ${e.message}"
+            )
+            return
+        }
 
         if (debugHelper.isDebuggingEnabled()) {
             val debugData = mutableMapOf<String, Any>()
@@ -457,14 +536,66 @@ 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) {  // 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
+        //     // Track app open as custom event
+
+        //     // Option 1: Track as custom event
+
+        //     Log.i(TAG, "   Tracking regular open as custom event 'app_open' with properties")
+
+        //     val properties = mapOf(
+        //         "event_type" to "app_open",
+        //         "authorization_status" to authorizationStatus,
+        //         "platform" to "Android"
+        //     )
+
+        //     try {
+        //         Log.i(TAG, "   Attempting to track custom event for regular app open")
+
+
+        //         val customEvent = CustomEvent.Builder()
+        //             .type("app_open")
+        //             .properties(properties)
+        //             .build()
+
+        //         Log.i(TAG, "   Custom event built successfully, recording event...")
+
+        //         AttentiveSdk.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"] = "2.1.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)
+        //     }
+        // }
     }
 
     /**
@@ -668,6 +799,23 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
      */
     override fun getInitialPushNotification(promise: Promise) {
       Log.d(TAG, "getInitialPushNotification called!")
+
+//        try {
+//            val payload = AttentiveNotificationStore.getAndClear()
+//            if (payload == null) {
+//                Log.d(TAG, "getInitialPushNotification: no pending initial notification")
+//                promise.resolve(null)
+//                return
+//            }
+//
+//            Log.i(TAG, "getInitialPushNotification: returning stored notification with keys=${payload.keys}")
+//            val result = Arguments.createMap()
+//            payload.forEach { (key, value) -> result.putString(key, value) }
+//            promise.resolve(result)
+//        } catch (e: Exception) {
+//            Log.e(TAG, "getInitialPushNotification: error — ${e.message}", e)
+//            promise.reject("INITIAL_PUSH_ERROR", "Failed to retrieve initial push notification: ${e.message}", e)
+//        }
     }
 
     // ==========================================================================
@@ -686,6 +834,38 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
         // No-op: listener bookkeeping is handled by the JS NativeEventEmitter.
     }
 
+    /**
+     * Extracts a human-readable list of item maps from the raw bridge array for debug display.
+     *
+     * This intentionally reads all fields from the original [ReadableArray] rather than from
+     * the built [Item] objects so that every field sent from TypeScript (including optional ones)
+     * is visible in the debugger — even fields that may be skipped during SDK item construction.
+     *
+     * @param rawItems The raw item array as received from the React Native bridge.
+     * @return A list of maps, one per item, containing all present fields.
+     */
+    private fun extractItemsDebugData(rawItems: ReadableArray): List<Map<String, Any>> {
+        val result = mutableListOf<Map<String, Any>>()
+        for (i in 0 until rawItems.size()) {
+            val rawItem = rawItems.getMap(i) ?: continue
+            val itemData = mutableMapOf<String, Any>()
+
+            rawItem.getString("productId")?.let { itemData["productId"] = it }
+            rawItem.getString("productVariantId")?.let { itemData["productVariantId"] = it }
+            rawItem.getString("price")?.let { itemData["price"] = it }
+            rawItem.getString("currency")?.let { itemData["currency"] = it }
+            rawItem.getString("name")?.let { itemData["name"] = it }
+            rawItem.getString("productImage")?.let { itemData["productImage"] = it }
+            rawItem.getString("category")?.let { itemData["category"] = it }
+            if (rawItem.hasKey("quantity")) {
+                itemData["quantity"] = rawItem.getDouble("quantity").toInt()
+            }
+
+            result.add(itemData)
+        }
+        return result
+    }
+
     private fun convertToStringMap(inputMap: Map<String, Any?>): Map<String, String> {
         val outputMap = mutableMapOf<String, String>()
         for ((key, value) in inputMap) {
@@ -702,19 +882,37 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
     private fun buildItems(rawItems: ReadableArray): List<Item> {
         Log.i(TAG, "buildItems method called with rawItems: $rawItems")
         val items = mutableListOf<Item>()
+
         for (i in 0 until rawItems.size()) {
             val rawItem = rawItems.getMap(i) ?: continue
 
-            // Price and currency are now flattened, not nested
+            // Required scalar fields
             val priceValue = rawItem.getString("price") ?: continue
             val currencyCode = rawItem.getString("currency") ?: continue
+            val productId = rawItem.getString("productId") ?: continue
+            val productVariantId = rawItem.getString("productVariantId") ?: continue
+
+            // Parse price amount — skip item on malformed value rather than crash
+            val priceDecimal = try {
+                BigDecimal(priceValue)
+            } catch (e: NumberFormatException) {
+                Log.w(TAG, "buildItems: invalid price value '$priceValue' at index $i — skipping item")
+                continue
+            }
+
+            // Parse currency — skip item on unrecognised ISO 4217 code rather than crash
+            val currency = try {
+                Currency.getInstance(currencyCode)
+            } catch (e: IllegalArgumentException) {
+                Log.w(TAG, "buildItems: invalid currency code '$currencyCode' at index $i — skipping item")
+                continue
+            }
+
             val price = Price.Builder()
-                .price(BigDecimal(priceValue))
-                .currency(Currency.getInstance(currencyCode))
+                .price(priceDecimal)
+                .currency(currency)
                 .build()
 
-            val productId = rawItem.getString("productId") ?: continue
-            val productVariantId = rawItem.getString("productVariantId") ?: continue
             val builder = Item.Builder(productId, productVariantId, price)
 
             if (rawItem.hasKey("productImage")) {
@@ -725,16 +923,16 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
                 builder.name(rawItem.getString("name"))
             }
 
+            // JS numbers are doubles on the bridge; use getDouble().toInt() to avoid ClassCastException
             if (rawItem.hasKey("quantity")) {
-                builder.quantity(rawItem.getInt("quantity"))
+                builder.quantity(rawItem.getDouble("quantity").toInt())
             }
 
             if (rawItem.hasKey("category")) {
                 builder.category(rawItem.getString("category"))
             }
 
-            val item = builder.build()
-            items.add(item)
+            items.add(builder.build())
         }
 
         return items

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"