@loyalytics/swan-react-native-sdk 2.3.0 → 2.3.1-beta.1

package/android/src/main/kotlin/com/loyalytics/swan/SwanNotificationModule.kt

@@ -1,20 +1,164 @@
 package com.loyalytics.swan
 
+import android.app.Activity
+import android.app.NotificationManager
+import android.content.Context
+import android.content.Intent
+import android.util.Log
 import com.facebook.react.bridge.*
+import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.loyalytics.swan.templates.SwanTemplateRegistry
 import com.loyalytics.swan.templates.carousel.CarouselTemplate
+import com.loyalytics.swan.templates.common.NotificationBitmapCache
+import com.loyalytics.swan.templates.common.NotificationStateManager
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
+import org.json.JSONObject
 
 class SwanNotificationModule(reactContext: ReactApplicationContext) :
-    ReactContextBaseJavaModule(reactContext) {
+    ReactContextBaseJavaModule(reactContext), ActivityEventListener {
 
     override fun getName(): String = "SwanNotificationModule"
 
+    companion object {
+        private const val TAG = "SwanNotificationModule"
+        private const val EVENT_CAROUSEL_CLICK = "swanCarouselClick"
+    }
+
     init {
         // Register built-in templates
         SwanTemplateRegistry.register(CarouselTemplate())
+
+        // Listen for new intents (e.g., when PendingIntent.getActivity() delivers
+        // carousel click data to an already-running Activity via onNewIntent)
+        reactContext.addActivityEventListener(this)
+
+        // Register click listener so carousel clicks emit a DeviceEventEmitter event
+        // to the JS layer. This covers the foreground-click case where AppState
+        // stays 'active' and the polling approach never triggers.
+        CarouselTemplate.clickListener = { clickData ->
+            try {
+                val map = Arguments.createMap().apply {
+                    putString("messageId", clickData.optString("messageId"))
+                    putString("route", clickData.optString("route"))
+                    putInt("itemIndex", clickData.optInt("itemIndex"))
+                    putString("title", clickData.optString("title"))
+                    putString("body", clickData.optString("body"))
+                }
+                reactContext
+                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                    .emit(EVENT_CAROUSEL_CLICK, map)
+            } catch (e: Exception) {
+                Log.d(TAG, "React bridge not available for click event, will use polling fallback")
+            }
+        }
+    }
+
+    /**
+     * Called when the Activity receives a new intent via onNewIntent().
+     * On Android 12+, carousel clicks use PendingIntent.getActivity() which delivers
+     * click data as intent extras. We extract the data here and save it to the static
+     * variable so getPendingCarouselClick() can find it.
+     */
+    override fun onNewIntent(intent: Intent?) {
+        if (intent == null) return
+        if (!intent.getBooleanExtra(CarouselTemplate.EXTRA_SWAN_CAROUSEL_CLICK, false)) return
+
+        val messageId = intent.getStringExtra(CarouselTemplate.EXTRA_SWAN_MESSAGE_ID) ?: ""
+        val route = intent.getStringExtra(CarouselTemplate.EXTRA_SWAN_ROUTE) ?: ""
+        val itemIndex = intent.getIntExtra(CarouselTemplate.EXTRA_SWAN_ITEM_INDEX, 0)
+        val notificationId = intent.getIntExtra(CarouselTemplate.EXTRA_SWAN_NOTIFICATION_ID, 0)
+
+        // Get title/body from notification state (saved during display)
+        val activity = currentActivity
+        val state = if (activity != null) NotificationStateManager.get(activity, notificationId) else null
+        val title = state?.optString("title", "") ?: ""
+        val body = state?.optString("body", "") ?: ""
+
+        // Save click data to static variable for JS SDK to consume
+        val clickData = JSONObject().apply {
+            put("messageId", messageId)
+            put("route", route)
+            put("itemIndex", itemIndex)
+            put("title", title)
+            put("body", body)
+        }
+        CarouselTemplate.savePendingClick(clickData)
+
+        // Clean up: cancel notification, clear bitmap cache, remove state
+        if (activity != null) {
+            NotificationBitmapCache.clear(notificationId)
+            NotificationStateManager.remove(activity, notificationId)
+            val nm = activity.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+            nm.cancel(notificationId)
+        }
+    }
+
+    override fun onActivityResult(activity: Activity?, requestCode: Int, resultCode: Int, data: Intent?) {
+        // Not used
+    }
+
+    /**
+     * Check for a pending carousel click.
+     * Called by the JS SDK on AppState 'active' to bridge native carousel
+     * clicks into the JS NOTIFICATION_OPENED event system.
+     *
+     * Checks two sources:
+     * 1. Static variable (set by BroadcastReceiver on pre-Android 12, or by onNewIntent on Android 12+)
+     * 2. Activity intent extras (covers fresh app launch from killed state on Android 12+)
+     */
+    @ReactMethod
+    fun getPendingCarouselClick(promise: Promise) {
+        // Source 1: Static variable (primary path for both pre-12 and 12+)
+        val click = CarouselTemplate.consumePendingClick()
+        if (click != null) {
+            val map = Arguments.createMap().apply {
+                putString("messageId", click.optString("messageId"))
+                putString("route", click.optString("route"))
+                putInt("itemIndex", click.optInt("itemIndex"))
+                putString("title", click.optString("title"))
+                putString("body", click.optString("body"))
+            }
+            promise.resolve(map)
+            return
+        }
+
+        // Source 2: Activity intent extras (covers fresh launch from killed state)
+        val activity = currentActivity
+        val intent = activity?.intent
+        if (intent != null && intent.getBooleanExtra(CarouselTemplate.EXTRA_SWAN_CAROUSEL_CLICK, false)) {
+            val messageId = intent.getStringExtra(CarouselTemplate.EXTRA_SWAN_MESSAGE_ID) ?: ""
+            val route = intent.getStringExtra(CarouselTemplate.EXTRA_SWAN_ROUTE) ?: ""
+            val itemIndex = intent.getIntExtra(CarouselTemplate.EXTRA_SWAN_ITEM_INDEX, 0)
+            val notificationId = intent.getIntExtra(CarouselTemplate.EXTRA_SWAN_NOTIFICATION_ID, 0)
+
+            // Get title/body from notification state (saved during display)
+            val state = NotificationStateManager.get(activity, notificationId)
+            val title = state?.optString("title", "") ?: ""
+            val body = state?.optString("body", "") ?: ""
+
+            // Clear the intent flag to prevent re-consumption
+            intent.removeExtra(CarouselTemplate.EXTRA_SWAN_CAROUSEL_CLICK)
+
+            // Clean up
+            NotificationBitmapCache.clear(notificationId)
+            NotificationStateManager.remove(activity, notificationId)
+            val nm = activity.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+            nm.cancel(notificationId)
+
+            val map = Arguments.createMap().apply {
+                putString("messageId", messageId)
+                putString("route", route)
+                putInt("itemIndex", itemIndex)
+                putString("title", title)
+                putString("body", body)
+            }
+            promise.resolve(map)
+            return
+        }
+
+        promise.resolve(null)
     }
 
     @ReactMethod

package/android/src/main/kotlin/com/loyalytics/swan/templates/carousel/CarouselAutoRemoteViews.kt

@@ -2,13 +2,9 @@ package com.loyalytics.swan.templates.carousel
 
 import android.app.PendingIntent
 import android.content.Context
-import android.content.Intent
 import android.graphics.Bitmap
-import android.os.Build
-import android.os.Bundle
 import android.widget.RemoteViews
 import com.loyalytics.swan.R
-import com.loyalytics.swan.templates.SwanNotificationActionReceiver
 
 /**
  * Builds RemoteViews for auto-carousel using ViewFlipper.
@@ -80,24 +76,9 @@ object CarouselAutoRemoteViews {
         messageId: String,
         route: String
     ): PendingIntent {
-        val intent = Intent(context, SwanNotificationActionReceiver::class.java).apply {
-            action = "com.loyalytics.swan.${CarouselTemplate.ACTION_CLICK}_$notificationId"
-            putExtra(SwanNotificationActionReceiver.EXTRA_TEMPLATE_TYPE, CarouselTemplate.TYPE)
-            putExtra(SwanNotificationActionReceiver.EXTRA_TEMPLATE_ACTION, CarouselTemplate.ACTION_CLICK)
-            putExtra(SwanNotificationActionReceiver.EXTRA_NOTIFICATION_ID, notificationId)
-            putExtra(CarouselTemplate.EXTRA_MESSAGE_ID, messageId)
-            putExtra(CarouselTemplate.EXTRA_ITEM_INDEX, 0)
-            putExtra(CarouselTemplate.EXTRA_ITEM_ROUTE, route)
-        }
-
-        val flags = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_MUTABLE
-        } else {
-            PendingIntent.FLAG_UPDATE_CURRENT
-        }
-
-        return PendingIntent.getBroadcast(
-            context, "${notificationId}AUTO_CLICK".hashCode(), intent, flags
+        // Use PendingIntent.getActivity() to avoid Android 12+ trampoline restriction
+        return CarouselTemplate.createClickActivityPendingIntent(
+            context, notificationId, messageId, 0, route
         )
     }
 }

package/android/src/main/kotlin/com/loyalytics/swan/templates/carousel/CarouselFilmstripRemoteViews.kt

@@ -109,6 +109,13 @@ object CarouselFilmstripRemoteViews {
         itemIndex: Int,
         itemRoute: String
     ): PendingIntent {
+        // For CLICK, use PendingIntent.getActivity() to avoid Android 12+ trampoline restriction
+        if (action == CarouselTemplate.ACTION_CLICK) {
+            return CarouselTemplate.createClickActivityPendingIntent(
+                context, notificationId, messageId, itemIndex, itemRoute
+            )
+        }
+
         val intent = Intent(context, SwanNotificationActionReceiver::class.java).apply {
             this.action = "com.loyalytics.swan.${action}_$notificationId"
             putExtra(SwanNotificationActionReceiver.EXTRA_TEMPLATE_TYPE, CarouselTemplate.TYPE)

package/android/src/main/kotlin/com/loyalytics/swan/templates/carousel/CarouselRemoteViews.kt

@@ -106,6 +106,13 @@ object CarouselRemoteViews {
         itemIndex: Int,
         itemRoute: String
     ): PendingIntent {
+        // For CLICK, use PendingIntent.getActivity() to avoid Android 12+ trampoline restriction
+        if (action == CarouselTemplate.ACTION_CLICK) {
+            return CarouselTemplate.createClickActivityPendingIntent(
+                context, notificationId, messageId, itemIndex, itemRoute
+            )
+        }
+
         val intent = Intent(context, SwanNotificationActionReceiver::class.java).apply {
             this.action = "com.loyalytics.swan.${action}_$notificationId"
             putExtra(SwanNotificationActionReceiver.EXTRA_TEMPLATE_TYPE, CarouselTemplate.TYPE)

package/android/src/main/kotlin/com/loyalytics/swan/templates/carousel/CarouselTemplate.kt

@@ -36,6 +36,81 @@ class CarouselTemplate : SwanNotificationTemplate {
         const val EXTRA_ITEM_INDEX = "itemIndex"
         const val EXTRA_ITEM_ROUTE = "itemRoute"
         const val EXTRA_MESSAGE_ID = "messageId"
+
+        // Activity intent extras (prefixed to avoid conflicts)
+        const val EXTRA_SWAN_CAROUSEL_CLICK = "swanCarouselClick"
+        const val EXTRA_SWAN_MESSAGE_ID = "swanMessageId"
+        const val EXTRA_SWAN_ROUTE = "swanRoute"
+        const val EXTRA_SWAN_ITEM_INDEX = "swanItemIndex"
+        const val EXTRA_SWAN_NOTIFICATION_ID = "swanNotificationId"
+        const val EXTRA_SWAN_TITLE = "swanTitle"
+        const val EXTRA_SWAN_BODY = "swanBody"
+
+        /**
+         * Pending click data for the JS bridge.
+         * When a carousel item is clicked, the click data is stored here
+         * so the JS SDK can read it via SwanNotificationModule.getPendingCarouselClick()
+         * and emit the appropriate NOTIFICATION_OPENED event.
+         */
+        @Volatile
+        private var pendingClick: JSONObject? = null
+
+        /**
+         * Optional listener invoked immediately when a carousel item is clicked.
+         * SwanNotificationModule registers this to emit a DeviceEventEmitter event
+         * to the JS layer, covering the foreground-click case where AppState
+         * doesn't change (so the polling approach never triggers).
+         */
+        var clickListener: ((JSONObject) -> Unit)? = null
+
+        fun savePendingClick(data: JSONObject) {
+            pendingClick = data
+            clickListener?.invoke(data)
+        }
+
+        fun consumePendingClick(): JSONObject? {
+            val click = pendingClick
+            pendingClick = null
+            return click
+        }
+
+        /**
+         * Create a PendingIntent that directly launches the app's main Activity.
+         * Android 12+ blocks BroadcastReceiver → startActivity() ("notification trampolines"),
+         * so CLICK actions must use PendingIntent.getActivity() instead of getBroadcast().
+         */
+        fun createClickActivityPendingIntent(
+            context: Context,
+            notificationId: Int,
+            messageId: String,
+            itemIndex: Int,
+            itemRoute: String
+        ): PendingIntent {
+            val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)
+                ?: Intent(Intent.ACTION_MAIN).apply {
+                    addCategory(Intent.CATEGORY_LAUNCHER)
+                    setPackage(context.packageName)
+                }
+
+            launchIntent.apply {
+                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
+                putExtra(EXTRA_SWAN_CAROUSEL_CLICK, true)
+                putExtra(EXTRA_SWAN_MESSAGE_ID, messageId)
+                putExtra(EXTRA_SWAN_ROUTE, itemRoute)
+                putExtra(EXTRA_SWAN_ITEM_INDEX, itemIndex)
+                putExtra(EXTRA_SWAN_NOTIFICATION_ID, notificationId)
+            }
+
+            val flags = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_MUTABLE
+            } else {
+                PendingIntent.FLAG_UPDATE_CURRENT
+            }
+
+            return PendingIntent.getActivity(
+                context, "$notificationId${ACTION_CLICK}$itemIndex".hashCode(), launchIntent, flags
+            )
+        }
     }
 
     override fun canHandle(notificationType: String): Boolean = notificationType == TYPE
@@ -142,6 +217,11 @@ class CarouselTemplate : SwanNotificationTemplate {
         )
     }
 
+    /**
+     * Handle carousel item click from BroadcastReceiver.
+     * On Android 12+ (API 31+), CLICK actions use PendingIntent.getActivity() directly,
+     * so this method is only called on older Android versions.
+     */
     private fun handleItemClick(context: Context, extras: Bundle, notificationId: Int) {
         NotificationBitmapCache.clear(notificationId)
 
@@ -149,16 +229,35 @@ class CarouselTemplate : SwanNotificationTemplate {
         val itemRoute = extras.getString(EXTRA_ITEM_ROUTE, "")
         val itemIndex = extras.getInt(EXTRA_ITEM_INDEX, 0)
 
+        // Get notification metadata from state for the JS event
+        val state = NotificationStateManager.get(context, notificationId)
+        val title = state?.optString("title", "") ?: ""
+        val body = state?.optString("body", "") ?: ""
+        val defaultRoute = state?.optString("defaultRoute", "") ?: ""
+
         Log.d(TAG, "Carousel item clicked: messageId=$messageId, index=$itemIndex, route=$itemRoute")
 
-        val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)
-        if (launchIntent != null) {
-            launchIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
-            launchIntent.putExtra("swanTemplateClick", true)
-            launchIntent.putExtra("messageId", messageId)
-            launchIntent.putExtra("route", itemRoute)
-            launchIntent.putExtra("itemIndex", itemIndex)
-            context.startActivity(launchIntent)
+        // Save click data for JS SDK to consume via getPendingCarouselClick()
+        val clickData = JSONObject().apply {
+            put("messageId", messageId)
+            put("route", itemRoute.ifEmpty { defaultRoute })
+            put("itemIndex", itemIndex)
+            put("title", title)
+            put("body", body)
+        }
+        savePendingClick(clickData)
+
+        // Launch the app — on Android 12+, this is handled by PendingIntent.getActivity() instead
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
+            val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)
+            if (launchIntent != null) {
+                launchIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
+                launchIntent.putExtra(EXTRA_SWAN_CAROUSEL_CLICK, true)
+                launchIntent.putExtra(EXTRA_SWAN_MESSAGE_ID, messageId)
+                launchIntent.putExtra(EXTRA_SWAN_ROUTE, itemRoute)
+                launchIntent.putExtra(EXTRA_SWAN_ITEM_INDEX, itemIndex)
+                context.startActivity(launchIntent)
+            }
         }
 
         val nm = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
@@ -249,6 +348,18 @@ class CarouselTemplate : SwanNotificationTemplate {
                 context, notificationId, ACTION_DISMISS, Bundle()
             ))
 
+        // Set contentIntent so tapping the notification (collapsed or expanded text area) opens the app
+        val defaultRoute = state?.optString("defaultRoute", "") ?: ""
+        val contentRoute = itemRoute.ifEmpty { defaultRoute }
+        val contentClickExtras = Bundle().apply {
+            putString(EXTRA_MESSAGE_ID, messageId)
+            putString(EXTRA_ITEM_ROUTE, contentRoute)
+            putInt(EXTRA_ITEM_INDEX, currentIndex)
+        }
+        builder.setContentIntent(createActionPendingIntent(
+            context, notificationId, ACTION_CLICK, contentClickExtras
+        ))
+
         // DecoratedCustomViewStyle on Android 12+ (same as CleverTap)
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
             builder.setStyle(NotificationCompat.DecoratedCustomViewStyle())
@@ -301,12 +412,22 @@ class CarouselTemplate : SwanNotificationTemplate {
             .setCustomBigContentView(views.expanded)
             .setCustomContentView(views.collapsed)
             .setOngoing(false)
-            .setAutoCancel(false)
+            .setAutoCancel(true)
             .setOnlyAlertOnce(true)
             .setDeleteIntent(createActionPendingIntent(
                 context, notificationId, ACTION_DISMISS, Bundle()
             ))
 
+        // Set contentIntent so tapping the notification opens the app with the default route
+        val contentClickExtras = Bundle().apply {
+            putString(EXTRA_MESSAGE_ID, messageId)
+            putString(EXTRA_ITEM_ROUTE, route)
+            putInt(EXTRA_ITEM_INDEX, 0)
+        }
+        builder.setContentIntent(createActionPendingIntent(
+            context, notificationId, ACTION_CLICK, contentClickExtras
+        ))
+
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
             builder.setStyle(NotificationCompat.DecoratedCustomViewStyle())
         }
@@ -321,6 +442,17 @@ class CarouselTemplate : SwanNotificationTemplate {
         action: String,
         extras: Bundle
     ): PendingIntent {
+        // For CLICK, use PendingIntent.getActivity() to avoid Android 12+ trampoline restriction
+        if (action == ACTION_CLICK) {
+            return createClickActivityPendingIntent(
+                context,
+                notificationId,
+                extras.getString(EXTRA_MESSAGE_ID, ""),
+                extras.getInt(EXTRA_ITEM_INDEX, 0),
+                extras.getString(EXTRA_ITEM_ROUTE, "")
+            )
+        }
+
         val intent = Intent(context, SwanNotificationActionReceiver::class.java).apply {
             this.action = "com.loyalytics.swan.${action}_$notificationId"
             putExtra(SwanNotificationActionReceiver.EXTRA_TEMPLATE_TYPE, TYPE)

package/android/src/main/res/layout/swan_carousel_auto_expanded.xml

@@ -41,7 +41,7 @@
     <ViewFlipper
         android:id="@+id/swan_carousel_flipper"
         android:layout_width="match_parent"
-        android:layout_height="196dp"
+        android:layout_height="144dp"
         android:layout_below="@id/swan_carousel_auto_header"
         android:inAnimation="@anim/swan_slide_in_right"
         android:outAnimation="@anim/swan_slide_out_left"

package/android/src/main/res/layout/swan_carousel_expanded.xml

@@ -43,7 +43,7 @@
         android:layout_width="match_parent"
         android:layout_height="0dp"
         android:layout_weight="1"
-        android:minHeight="196dp">
+        android:minHeight="144dp">
 
         <!-- Center ViewFlipper (all images pre-loaded) -->
         <ViewFlipper

package/android/src/main/res/layout/swan_carousel_filmstrip_expanded.xml

@@ -23,7 +23,7 @@
     <!-- 3-image filmstrip: left preview | center | right preview -->
     <LinearLayout
         android:layout_width="match_parent"
-        android:layout_height="196dp"
+        android:layout_height="144dp"
         android:orientation="horizontal"
         android:gravity="center_vertical">
 

package/ios/SwanAppGroup.m

@@ -0,0 +1,55 @@
+//
+//  SwanAppGroup.m
+//  swan-react-native-sdk
+//
+//  Native bridge for iOS App Group UserDefaults.
+//  Replaces react-native-shared-group-preferences to fix cross-process
+//  caching bug: the third-party library caches the NSUserDefaults instance
+//  and misses writes from the Notification Content Extension process.
+//
+//  This module creates a fresh NSUserDefaults instance on every call,
+//  ensuring reads always reflect the latest data from any process.
+//
+
+#import <React/RCTBridgeModule.h>
+
+@interface SwanAppGroup : NSObject <RCTBridgeModule>
+@end
+
+@implementation SwanAppGroup
+
+RCT_EXPORT_MODULE();
+
+RCT_EXPORT_METHOD(getItem:(NSString *)key
+                  suiteName:(NSString *)suiteName
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+  NSUserDefaults *defaults = [[NSUserDefaults alloc] initWithSuiteName:suiteName];
+  if (!defaults) {
+    reject(@"ERR_APP_GROUP", @"Failed to access App Group", nil);
+    return;
+  }
+
+  NSString *value = [defaults stringForKey:key];
+  resolve(value);
+}
+
+RCT_EXPORT_METHOD(setItem:(NSString *)key
+                  value:(NSString *)value
+                  suiteName:(NSString *)suiteName
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+  NSUserDefaults *defaults = [[NSUserDefaults alloc] initWithSuiteName:suiteName];
+  if (!defaults) {
+    reject(@"ERR_APP_GROUP", @"Failed to access App Group", nil);
+    return;
+  }
+
+  [defaults setObject:value forKey:key];
+  [defaults synchronize];
+  resolve(nil);
+}
+
+@end