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

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
@@ -50,22 +56,45 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
         return NAME
     }
 
+    /**
+     * 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,
         mode: String,
         skipFatigueOnCreatives: Boolean,
         enableDebugger: Boolean
     ) {
-        // 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)
+        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?) {
@@ -77,7 +106,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,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(itemsList).deeplink(deeplink).build()
+        val productViewEvent = ProductViewEvent.Builder().items(itemsList).deeplink(deeplink).build()
 
-        AttentiveEventTracker.getInstance().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)
         }
     }
@@ -173,19 +216,37 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
         cartCoupon: String?
     ) {
         Log.i(TAG, "Sending purchase event")
-        val order = Order.Builder(orderId).build()
 
+        val itemsDebugData = if (debugHelper.isDebuggingEnabled()) extractItemsDebugData(items) else emptyList()
+
+        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)
+        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)
         }
     }
@@ -193,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(itemsList).deeplink(deeplink).build()
+        val addToCartEvent = AddToCartEvent.Builder().items(itemsList).deeplink(deeplink).build()
 
-        AttentiveEventTracker.getInstance().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)
         }
     }
@@ -212,9 +288,19 @@ 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)
+        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>()
@@ -243,37 +329,67 @@ 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.
      *
-     * On Android 13+ (API 33+), requests [android.permission.POST_NOTIFICATIONS] via the
-     * system dialog. On older versions, no-op (notifications allowed by default).
-     * Uses [AttentivePushHelper] for the actual request.
+     * 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)")
 
-        UiThreadUtil.runOnUiThread {
-            val activity = reactApplicationContext.currentActivity
-            val requested = AttentivePushHelper.requestPermissionIfNeeded(activity, PUSH_PERMISSION_REQUEST_CODE)
-            if (!requested && activity == null) {
-                Log.w(TAG, "   Current activity is null; permission request deferred. Call again when app is in foreground.")
+        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)
+                    }
+                }
             }
-            if (debugHelper.isDebuggingEnabled()) {
-                val debugData = mutableMapOf<String, Any>()
-                debugData["platform"] = "Android"
-                debugData["request_started"] = requested
-                debugHelper.showDebugInfo("Push Registration Requested", 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.
@@ -283,7 +399,10 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
      */
     override fun getPushAuthorizationStatus(promise: Promise) {
         try {
-            val status = AttentivePushHelper.getAuthorizationStatus(reactApplicationContext)
+            val status = AttentivePushHelper.getAuthorizationStatus(
+                reactApplicationContext,
+                reactApplicationContext.currentActivity
+            )
             Log.d(TAG, "getPushAuthorizationStatus: $status")
             promise.resolve(status)
         } catch (e: Exception) {
@@ -295,10 +414,13 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
     /**
      * 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) {
@@ -308,22 +430,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) {
@@ -339,15 +461,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,
@@ -359,19 +483,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)
@@ -379,7 +502,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>()
@@ -416,62 +539,63 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
      *
      * @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
-
-            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 = com.attentive.androidsdk.events.CustomEvent.Builder(
-                    "app_open",
-                    properties
-                ).build()
-
-                Log.i(TAG, "   Custom event built successfully, recording event...")
-
-                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)
-            }
-        }
+        // 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)
+        //     }
+        // }
     }
 
     /**
@@ -505,12 +629,12 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
             }
 
             try {
-                val customEvent = com.attentive.androidsdk.events.CustomEvent.Builder(
-                    "push_open",
-                    properties
-                ).build()
+                val customEvent = CustomEvent.Builder()
+                    .type("push_open")
+                    .properties(properties)
+                    .build()
 
-                AttentiveEventTracker.getInstance().recordEvent(customEvent)
+                AttentiveSdk.recordEvent(customEvent)
 
                 Log.i(TAG, "✅ [AttentiveSDK] handlePushOpen completed (tracked as custom event)")
                 Log.i(TAG, "   Push open event sent to Attentive backend")
@@ -525,7 +649,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) {
@@ -571,12 +695,12 @@ class AttentiveReactNativeSdkModule(reactContext: ReactApplicationContext) :
             }
 
             try {
-                val customEvent = com.attentive.androidsdk.events.CustomEvent.Builder(
-                    "foreground_push",
-                    properties
-                ).build()
+                val customEvent = CustomEvent.Builder()
+                    .type("foreground_push")
+                    .properties(properties)
+                    .build()
 
-                AttentiveEventTracker.getInstance().recordEvent(customEvent)
+                AttentiveSdk.recordEvent(customEvent)
 
                 Log.i(TAG, "✅ [AttentiveSDK] handleForegroundPush completed (tracked as custom event)")
                 Log.i(TAG, "   Foreground push event sent to Attentive backend")
@@ -591,7 +715,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) {
@@ -659,6 +783,89 @@ 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!")
+
+//        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)
+//        }
+    }
+
+    // ==========================================================================
+    // 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.
+    }
+
+    /**
+     * 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) {
@@ -675,15 +882,38 @@ 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
-            val priceValue = rawItem.getString("price")
-            val currencyCode = rawItem.getString("currency")
-            val price = Price.Builder(BigDecimal(priceValue), Currency.getInstance(currencyCode)).build()
+            // 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(priceDecimal)
+                .currency(currency)
+                .build()
 
-            val builder = Item.Builder(rawItem.getString("productId"), rawItem.getString("productVariantId"), price)
+            val builder = Item.Builder(productId, productVariantId, price)
 
             if (rawItem.hasKey("productImage")) {
                 builder.productImage(rawItem.getString("productImage"))
@@ -693,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