@loyalytics/swan-react-native-sdk 2.1.3-beta.0 → 2.1.3-beta.2

package/android/build.gradle

@@ -0,0 +1,66 @@
+buildscript {
+    ext.safeExtGet = {prop, fallback ->
+        rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+    }
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${safeExtGet('kotlinVersion', '1.9.22')}")
+    }
+}
+
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+android {
+    namespace 'com.loyalytics.swan'
+    compileSdkVersion safeExtGet('compileSdkVersion', 34)
+
+    defaultConfig {
+        minSdkVersion safeExtGet('minSdkVersion', 21)
+        targetSdkVersion safeExtGet('targetSdkVersion', 34)
+    }
+
+    buildTypes {
+        release {
+            minifyEnabled false
+        }
+    }
+
+    def javaVersion = safeExtGet('jvmTargetVersion', '17')
+
+    compileOptions {
+        sourceCompatibility JavaVersion.toVersion(javaVersion)
+        targetCompatibility JavaVersion.toVersion(javaVersion)
+    }
+
+    kotlinOptions {
+        jvmTarget = javaVersion
+    }
+
+    sourceSets {
+        main {
+            java.srcDirs += 'src/main/kotlin'
+        }
+        test {
+            java.srcDirs += 'src/test/kotlin'
+        }
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+dependencies {
+    implementation "com.facebook.react:react-native:+"
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:${safeExtGet('kotlinVersion', '1.9.22')}"
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3"
+    implementation "androidx.core:core-ktx:1.12.0"
+
+    testImplementation "junit:junit:4.13.2"
+    testImplementation "org.jetbrains.kotlinx:kotlinx-coroutines-test:1.7.3"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,10 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.loyalytics.swan">
+
+    <application>
+        <receiver
+            android:name=".templates.SwanNotificationActionReceiver"
+            android:exported="false" />
+    </application>
+
+</manifest>

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

@@ -0,0 +1,43 @@
+package com.loyalytics.swan
+
+import com.facebook.react.bridge.*
+import com.loyalytics.swan.templates.SwanTemplateRegistry
+import com.loyalytics.swan.templates.carousel.CarouselTemplate
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+
+class SwanNotificationModule(reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    override fun getName(): String = "SwanNotificationModule"
+
+    init {
+        // Register built-in templates
+        SwanTemplateRegistry.register(CarouselTemplate())
+    }
+
+    @ReactMethod
+    fun displayTemplateNotification(config: ReadableMap, promise: Promise) {
+        val type = config.getString("notificationType")
+        if (type == null) {
+            promise.reject("MISSING_TYPE", "notificationType is required")
+            return
+        }
+
+        val template = SwanTemplateRegistry.findTemplate(type)
+        if (template == null) {
+            promise.reject("UNSUPPORTED_TYPE", "No template registered for: $type")
+            return
+        }
+
+        CoroutineScope(Dispatchers.IO).launch {
+            try {
+                template.display(reactApplicationContext, config)
+                promise.resolve(true)
+            } catch (e: Exception) {
+                promise.reject("DISPLAY_ERROR", "Template display failed: ${e.message}", e)
+            }
+        }
+    }
+}

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

@@ -0,0 +1,16 @@
+package com.loyalytics.swan
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class SwanNotificationPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(SwanNotificationModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}

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

@@ -0,0 +1,49 @@
+package com.loyalytics.swan.templates
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.os.Bundle
+import android.util.Log
+
+/**
+ * Single BroadcastReceiver for all template notification actions.
+ * Routes actions to the correct template based on templateType extra.
+ *
+ * Intent extras:
+ *   - templateType: String — which template to route to (e.g., "carousel")
+ *   - templateAction: String — the action to perform (e.g., "NEXT", "PREV", "CLICK")
+ *   - notificationId: Int — the notification ID for updating in-place
+ *   - Additional extras specific to each template
+ */
+class SwanNotificationActionReceiver : BroadcastReceiver() {
+    companion object {
+        private const val TAG = "SwanActionReceiver"
+        const val EXTRA_TEMPLATE_TYPE = "templateType"
+        const val EXTRA_TEMPLATE_ACTION = "templateAction"
+        const val EXTRA_NOTIFICATION_ID = "notificationId"
+    }
+
+    override fun onReceive(context: Context, intent: Intent) {
+        val templateType = intent.getStringExtra(EXTRA_TEMPLATE_TYPE)
+        val action = intent.getStringExtra(EXTRA_TEMPLATE_ACTION)
+
+        if (templateType == null || action == null) {
+            Log.w(TAG, "Missing templateType or templateAction in intent")
+            return
+        }
+
+        Log.d(TAG, "Received action: $action for template: $templateType")
+
+        // Ensure templates are registered (covers process restart scenario)
+        SwanTemplateRegistry.ensureDefaults()
+
+        val template = SwanTemplateRegistry.findTemplate(templateType)
+        if (template == null) {
+            Log.w(TAG, "No template registered for type: $templateType")
+            return
+        }
+
+        template.handleAction(context, action, intent.extras ?: Bundle.EMPTY)
+    }
+}

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

@@ -0,0 +1,20 @@
+package com.loyalytics.swan.templates
+
+import android.content.Context
+import android.os.Bundle
+import com.facebook.react.bridge.ReadableMap
+
+/**
+ * Interface for notification template handlers.
+ * Each notification type (carousel, timer, CTA) implements this.
+ */
+interface SwanNotificationTemplate {
+    /** Whether this template handles the given notificationType */
+    fun canHandle(notificationType: String): Boolean
+
+    /** Display the notification using custom RemoteViews */
+    suspend fun display(context: Context, config: ReadableMap)
+
+    /** Handle a user action (button press, swipe, etc.) routed from BroadcastReceiver */
+    fun handleAction(context: Context, action: String, extras: Bundle)
+}

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

@@ -0,0 +1,47 @@
+package com.loyalytics.swan.templates
+
+import com.loyalytics.swan.templates.carousel.CarouselTemplate
+
+/**
+ * Registry of notification template handlers.
+ * Templates register once at module init time.
+ * The BroadcastReceiver and bridge module look up templates here.
+ *
+ * ensureDefaults() is called by the BroadcastReceiver to guarantee
+ * templates are available even after a process restart (when the
+ * React Native module init may not have run yet).
+ */
+object SwanTemplateRegistry {
+    private val templates = mutableListOf<SwanNotificationTemplate>()
+    @Volatile
+    private var defaultsRegistered = false
+
+    fun register(template: SwanNotificationTemplate) {
+        // Remove existing handler for the same type to allow override
+        templates.removeAll { it::class == template::class }
+        templates.add(template)
+    }
+
+    /**
+     * Ensure built-in templates are registered.
+     * Safe to call multiple times — only registers once.
+     */
+    fun ensureDefaults() {
+        if (!defaultsRegistered) {
+            if (templates.none { it.canHandle("carousel") }) {
+                templates.add(CarouselTemplate())
+            }
+            defaultsRegistered = true
+        }
+    }
+
+    fun findTemplate(notificationType: String): SwanNotificationTemplate? {
+        return templates.find { it.canHandle(notificationType) }
+    }
+
+    /** Visible for testing — clears all registered templates */
+    internal fun clear() {
+        templates.clear()
+        defaultsRegistered = false
+    }
+}

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

@@ -0,0 +1,103 @@
+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.
+ *
+ * All images are added as children to the ViewFlipper which handles
+ * cycling natively with slide animations. No AlarmManager needed.
+ *
+ * The entire flipper area gets a single click action (auto-carousel
+ * uses one deep link for the whole notification, same as CleverTap).
+ *
+ * Capped at MAX_FLIPPER_IMAGES to stay within RemoteViews ~1MB limit.
+ */
+object CarouselAutoRemoteViews {
+
+    private const val MAX_FLIPPER_IMAGES = 5
+
+    data class AutoCarouselViews(
+        val expanded: RemoteViews,
+        val collapsed: RemoteViews
+    )
+
+    fun build(
+        context: Context,
+        notificationId: Int,
+        title: String,
+        body: String,
+        bitmaps: List<Bitmap?>,
+        intervalMs: Int,
+        messageId: String,
+        defaultRoute: String
+    ): AutoCarouselViews {
+        val packageName = context.packageName
+
+        val expanded = RemoteViews(packageName, R.layout.swan_carousel_auto_expanded).apply {
+            setTextViewText(R.id.swan_carousel_auto_title, title)
+            setTextViewText(R.id.swan_carousel_auto_body, body)
+
+            // autoStart and flipInterval are set in XML (RemoteViews doesn't allow setAutoStart)
+
+            // Add each bitmap as a child of the ViewFlipper
+            removeAllViews(R.id.swan_carousel_flipper)
+            val validBitmaps = bitmaps.filterNotNull().take(MAX_FLIPPER_IMAGES)
+            for (bitmap in validBitmaps) {
+                val childView = RemoteViews(packageName, R.layout.swan_carousel_flipper_item)
+                childView.setImageViewBitmap(R.id.swan_carousel_flipper_image, bitmap)
+                addView(R.id.swan_carousel_flipper, childView)
+            }
+
+            // Single click action for the whole flipper
+            setOnClickPendingIntent(
+                R.id.swan_carousel_flipper,
+                createClickPendingIntent(
+                    context, notificationId, messageId, defaultRoute
+                )
+            )
+        }
+
+        val collapsed = RemoteViews(packageName, R.layout.swan_carousel_collapsed).apply {
+            setTextViewText(R.id.swan_carousel_collapsed_title, title)
+            setTextViewText(R.id.swan_carousel_collapsed_body, body)
+        }
+
+        return AutoCarouselViews(expanded, collapsed)
+    }
+
+    private fun createClickPendingIntent(
+        context: Context,
+        notificationId: Int,
+        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
+        )
+    }
+}

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

@@ -0,0 +1,132 @@
+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.view.View
+import android.widget.RemoteViews
+import com.loyalytics.swan.R
+import com.loyalytics.swan.templates.SwanNotificationActionReceiver
+
+/**
+ * Builds RemoteViews for filmstrip carousel variant.
+ *
+ * Shows 3 images horizontally: left preview (dimmed) | center (full) | right preview (dimmed).
+ * Clicking side images navigates prev/next. Center click opens deep link.
+ */
+object CarouselFilmstripRemoteViews {
+
+    data class FilmstripViews(
+        val expanded: RemoteViews,
+        val collapsed: RemoteViews
+    )
+
+    fun build(
+        context: Context,
+        notificationId: Int,
+        title: String,
+        itemTitle: String,
+        itemBody: String,
+        leftBitmap: Bitmap?,
+        centerBitmap: Bitmap?,
+        rightBitmap: Bitmap?,
+        currentIndex: Int,
+        totalItems: Int,
+        messageId: String,
+        itemRoute: String
+    ): FilmstripViews {
+        val packageName = context.packageName
+
+        val expanded = RemoteViews(packageName, R.layout.swan_carousel_filmstrip_expanded).apply {
+            setTextViewText(R.id.swan_filmstrip_title, title)
+            setTextViewText(R.id.swan_filmstrip_item_title, itemTitle)
+            setTextViewText(R.id.swan_filmstrip_item_body, itemBody)
+            setTextViewText(R.id.swan_filmstrip_counter, "${currentIndex + 1} / $totalItems")
+
+            // Left preview image
+            if (leftBitmap != null) {
+                setImageViewBitmap(R.id.swan_filmstrip_left, leftBitmap)
+                setViewVisibility(R.id.swan_filmstrip_left, View.VISIBLE)
+                setOnClickPendingIntent(
+                    R.id.swan_filmstrip_left,
+                    createCarouselActionIntent(
+                        context, notificationId, CarouselTemplate.ACTION_PREV,
+                        messageId, currentIndex, itemRoute
+                    )
+                )
+            } else {
+                setViewVisibility(R.id.swan_filmstrip_left, View.INVISIBLE)
+            }
+
+            // Center image
+            if (centerBitmap != null) {
+                setImageViewBitmap(R.id.swan_filmstrip_center, centerBitmap)
+                setViewVisibility(R.id.swan_filmstrip_center, View.VISIBLE)
+            } else {
+                setViewVisibility(R.id.swan_filmstrip_center, View.GONE)
+            }
+
+            // Center click → open deep link
+            setOnClickPendingIntent(
+                R.id.swan_filmstrip_center,
+                createCarouselActionIntent(
+                    context, notificationId, CarouselTemplate.ACTION_CLICK,
+                    messageId, currentIndex, itemRoute
+                )
+            )
+
+            // Right preview image
+            if (rightBitmap != null) {
+                setImageViewBitmap(R.id.swan_filmstrip_right, rightBitmap)
+                setViewVisibility(R.id.swan_filmstrip_right, View.VISIBLE)
+                setOnClickPendingIntent(
+                    R.id.swan_filmstrip_right,
+                    createCarouselActionIntent(
+                        context, notificationId, CarouselTemplate.ACTION_NEXT,
+                        messageId, currentIndex, itemRoute
+                    )
+                )
+            } else {
+                setViewVisibility(R.id.swan_filmstrip_right, View.INVISIBLE)
+            }
+        }
+
+        val collapsed = RemoteViews(packageName, R.layout.swan_carousel_collapsed).apply {
+            setTextViewText(R.id.swan_carousel_collapsed_title, title)
+            setTextViewText(R.id.swan_carousel_collapsed_body, itemTitle)
+        }
+
+        return FilmstripViews(expanded, collapsed)
+    }
+
+    private fun createCarouselActionIntent(
+        context: Context,
+        notificationId: Int,
+        action: String,
+        messageId: String,
+        itemIndex: Int,
+        itemRoute: String
+    ): PendingIntent {
+        val intent = Intent(context, SwanNotificationActionReceiver::class.java).apply {
+            this.action = "com.loyalytics.swan.${action}_$notificationId"
+            putExtra(SwanNotificationActionReceiver.EXTRA_TEMPLATE_TYPE, CarouselTemplate.TYPE)
+            putExtra(SwanNotificationActionReceiver.EXTRA_TEMPLATE_ACTION, action)
+            putExtra(SwanNotificationActionReceiver.EXTRA_NOTIFICATION_ID, notificationId)
+            putExtra(CarouselTemplate.EXTRA_MESSAGE_ID, messageId)
+            putExtra(CarouselTemplate.EXTRA_ITEM_INDEX, itemIndex)
+            putExtra(CarouselTemplate.EXTRA_ITEM_ROUTE, itemRoute)
+        }
+
+        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$action$itemIndex".hashCode(), intent, flags
+        )
+    }
+}

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

@@ -0,0 +1,129 @@
+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.view.View
+import android.widget.RemoteViews
+import com.loyalytics.swan.R
+import com.loyalytics.swan.templates.SwanNotificationActionReceiver
+
+/**
+ * Builds RemoteViews for the standard manual carousel.
+ *
+ * Uses a single ViewFlipper with all images pre-loaded.
+ * Navigation uses showNext()/showPrevious() with fade animation.
+ */
+object CarouselRemoteViews {
+
+    data class CarouselViews(
+        val expanded: RemoteViews,
+        val collapsed: RemoteViews
+    )
+
+    fun build(
+        context: Context,
+        notificationId: Int,
+        title: String,
+        body: String,
+        bitmaps: List<Bitmap?>,
+        currentIndex: Int,
+        totalItems: Int,
+        messageId: String,
+        itemRoute: String
+    ): CarouselViews {
+        val packageName = context.packageName
+
+        val expanded = RemoteViews(packageName, R.layout.swan_carousel_expanded).apply {
+            setTextViewText(R.id.swan_carousel_title, title)
+            setTextViewText(R.id.swan_carousel_body, body)
+            setTextViewText(R.id.swan_carousel_counter, "${currentIndex + 1} / $totalItems")
+
+            // Populate ViewFlipper with all images
+            removeAllViews(R.id.swan_carousel_center)
+            for (bitmap in bitmaps) {
+                val child = RemoteViews(packageName, R.layout.swan_carousel_flipper_item)
+                if (bitmap != null) {
+                    child.setImageViewBitmap(R.id.swan_carousel_flipper_image, bitmap)
+                }
+                addView(R.id.swan_carousel_center, child)
+            }
+
+            // Advance ViewFlipper to currentIndex
+            for (i in 0 until currentIndex) {
+                showNext(R.id.swan_carousel_center)
+            }
+
+            // Show/hide arrows
+            if (totalItems > 1) {
+                setViewVisibility(R.id.swan_carousel_btn_prev, View.VISIBLE)
+                setViewVisibility(R.id.swan_carousel_btn_next, View.VISIBLE)
+
+                setOnClickPendingIntent(
+                    R.id.swan_carousel_btn_prev,
+                    createActionIntent(
+                        context, notificationId, CarouselTemplate.ACTION_PREV,
+                        messageId, currentIndex, itemRoute
+                    )
+                )
+                setOnClickPendingIntent(
+                    R.id.swan_carousel_btn_next,
+                    createActionIntent(
+                        context, notificationId, CarouselTemplate.ACTION_NEXT,
+                        messageId, currentIndex, itemRoute
+                    )
+                )
+            } else {
+                setViewVisibility(R.id.swan_carousel_btn_prev, View.GONE)
+                setViewVisibility(R.id.swan_carousel_btn_next, View.GONE)
+            }
+
+            // Image click → open deep link
+            setOnClickPendingIntent(
+                R.id.swan_carousel_center,
+                createActionIntent(
+                    context, notificationId, CarouselTemplate.ACTION_CLICK,
+                    messageId, currentIndex, itemRoute
+                )
+            )
+        }
+
+        val collapsed = RemoteViews(packageName, R.layout.swan_carousel_collapsed).apply {
+            setTextViewText(R.id.swan_carousel_collapsed_title, title)
+            setTextViewText(R.id.swan_carousel_collapsed_body, body)
+        }
+
+        return CarouselViews(expanded, collapsed)
+    }
+
+    private fun createActionIntent(
+        context: Context,
+        notificationId: Int,
+        action: String,
+        messageId: String,
+        itemIndex: Int,
+        itemRoute: String
+    ): PendingIntent {
+        val intent = Intent(context, SwanNotificationActionReceiver::class.java).apply {
+            this.action = "com.loyalytics.swan.${action}_$notificationId"
+            putExtra(SwanNotificationActionReceiver.EXTRA_TEMPLATE_TYPE, CarouselTemplate.TYPE)
+            putExtra(SwanNotificationActionReceiver.EXTRA_TEMPLATE_ACTION, action)
+            putExtra(SwanNotificationActionReceiver.EXTRA_NOTIFICATION_ID, notificationId)
+            putExtra(CarouselTemplate.EXTRA_MESSAGE_ID, messageId)
+            putExtra(CarouselTemplate.EXTRA_ITEM_INDEX, itemIndex)
+            putExtra(CarouselTemplate.EXTRA_ITEM_ROUTE, itemRoute)
+        }
+
+        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$action$itemIndex".hashCode(), intent, flags
+        )
+    }
+}