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

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

@@ -0,0 +1,412 @@
+package com.loyalytics.swan.templates.carousel
+
+import android.app.NotificationManager
+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.util.Log
+import android.util.TypedValue
+import android.widget.RemoteViews
+import androidx.core.app.NotificationCompat
+import com.facebook.react.bridge.ReadableMap
+import com.loyalytics.swan.R
+import com.loyalytics.swan.templates.SwanNotificationActionReceiver
+import com.loyalytics.swan.templates.SwanNotificationTemplate
+import com.loyalytics.swan.templates.common.NotificationBitmapCache
+import com.loyalytics.swan.templates.common.NotificationImageLoader
+import com.loyalytics.swan.templates.common.NotificationStateManager
+import org.json.JSONArray
+import org.json.JSONObject
+
+class CarouselTemplate : SwanNotificationTemplate {
+    companion object {
+        private const val TAG = "SwanCarousel"
+        const val TYPE = "carousel"
+
+        // Actions
+        const val ACTION_PREV = "PREV"
+        const val ACTION_NEXT = "NEXT"
+        const val ACTION_CLICK = "CLICK"
+        const val ACTION_DISMISS = "DISMISS"
+
+        // Intent extras
+        const val EXTRA_ITEM_INDEX = "itemIndex"
+        const val EXTRA_ITEM_ROUTE = "itemRoute"
+        const val EXTRA_MESSAGE_ID = "messageId"
+    }
+
+    override fun canHandle(notificationType: String): Boolean = notificationType == TYPE
+
+    override suspend fun display(context: Context, config: ReadableMap) {
+        val messageId = config.getString("messageId") ?: "swan_${System.currentTimeMillis()}"
+        val title = config.getString("title") ?: ""
+        val body = config.getString("body") ?: ""
+        val channelId = config.getString("channelId") ?: "swan_notifications"
+        val mode = config.getString("carouselMode") ?: "manual"
+        val variant = config.getString("carouselVariant") ?: "standard"
+        val interval = if (config.hasKey("carouselInterval")) config.getInt("carouselInterval") else 3000
+        val itemsJson = config.getString("carouselItems") ?: "[]"
+        val defaultRoute = config.getString("defaultRoute") ?: ""
+
+        val items = parseItems(itemsJson)
+        if (items.isEmpty()) {
+            Log.w(TAG, "No carousel items to display")
+            return
+        }
+
+        // Download all images concurrently
+        val imageUrls = items.map { it.optString("imageUrl", "") }
+        val bitmaps = NotificationImageLoader.downloadAll(imageUrls)
+
+        val notificationId = messageId.hashCode()
+
+        // Cache bitmaps for navigation
+        NotificationBitmapCache.putAll(notificationId, imageUrls, bitmaps)
+
+        // Save state for BroadcastReceiver
+        val state = JSONObject().apply {
+            put("items", JSONArray(items.map { it.toString() }))
+            put("currentIndex", 0)
+            put("messageId", messageId)
+            put("title", title)
+            put("body", body)
+            put("channelId", channelId)
+            put("carouselMode", mode)
+            put("carouselVariant", variant)
+            put("carouselInterval", interval)
+            put("defaultRoute", defaultRoute)
+        }
+        NotificationStateManager.save(context, notificationId, state)
+
+        if (mode == "auto" && items.size > 1) {
+            showAutoCarouselNotification(
+                context, notificationId, title, body, channelId,
+                items, bitmaps, interval, messageId, defaultRoute
+            )
+        } else {
+            showManualCarouselNotification(
+                context, notificationId, title, body, channelId,
+                items, bitmaps, 0, variant
+            )
+        }
+    }
+
+    override fun handleAction(context: Context, action: String, extras: Bundle) {
+        val notificationId = extras.getInt(SwanNotificationActionReceiver.EXTRA_NOTIFICATION_ID, -1)
+        if (notificationId == -1) {
+            Log.w(TAG, "Missing notificationId in action extras")
+            return
+        }
+
+        when (action) {
+            ACTION_PREV -> navigateCarousel(context, notificationId, -1)
+            ACTION_NEXT -> navigateCarousel(context, notificationId, +1)
+            ACTION_CLICK -> handleItemClick(context, extras, notificationId)
+            ACTION_DISMISS -> {
+                NotificationBitmapCache.clear(notificationId)
+                NotificationStateManager.remove(context, notificationId)
+            }
+        }
+    }
+
+    private fun navigateCarousel(context: Context, notificationId: Int, direction: Int) {
+        val state = NotificationStateManager.get(context, notificationId) ?: return
+        val itemsJsonArray = state.optJSONArray("items") ?: return
+        val items = (0 until itemsJsonArray.length()).map { JSONObject(itemsJsonArray.getString(it)) }
+        if (items.isEmpty()) return
+
+        val currentIndex = state.optInt("currentIndex", 0)
+        val newIndex = wrapIndex(currentIndex + direction, items.size)
+
+        // Update state
+        state.put("currentIndex", newIndex)
+        NotificationStateManager.save(context, notificationId, state)
+
+        val channelId = state.optString("channelId", "swan_notifications")
+        val title = state.optString("title", "")
+        val body = state.optString("body", "")
+        val variant = state.optString("carouselVariant", "standard")
+
+        // Load all bitmaps from cache
+        val bitmaps = items.map { item ->
+            val url = item.optString("imageUrl", "")
+            NotificationBitmapCache.get(notificationId, url)
+        }
+
+        showManualCarouselNotification(
+            context, notificationId, title, body, channelId,
+            items, bitmaps, newIndex, variant
+        )
+    }
+
+    private fun handleItemClick(context: Context, extras: Bundle, notificationId: Int) {
+        NotificationBitmapCache.clear(notificationId)
+
+        val messageId = extras.getString(EXTRA_MESSAGE_ID, "")
+        val itemRoute = extras.getString(EXTRA_ITEM_ROUTE, "")
+        val itemIndex = extras.getInt(EXTRA_ITEM_INDEX, 0)
+
+        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)
+        }
+
+        val nm = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        nm.cancel(notificationId)
+        NotificationStateManager.remove(context, notificationId)
+    }
+
+    /**
+     * Show manual carousel notification using custom RemoteViews.
+     * - Standard: ViewFlipper with all images, arrow overlays, per-item info
+     * - Filmstrip: 3 ImageViews (left/center/right preview)
+     * DecoratedCustomViewStyle on Android 12+ (same as CleverTap).
+     */
+    private fun showManualCarouselNotification(
+        context: Context,
+        notificationId: Int,
+        title: String,
+        body: String,
+        channelId: String,
+        items: List<JSONObject>,
+        bitmaps: List<Bitmap?>,
+        currentIndex: Int,
+        variant: String
+    ) {
+        val currentItem = items[currentIndex]
+        val itemRoute = currentItem.optString("route", "")
+        val state = NotificationStateManager.get(context, notificationId)
+        val messageId = state?.optString("messageId", "") ?: ""
+
+        val expanded: RemoteViews
+        val collapsed: RemoteViews
+
+        if (variant == "filmstrip" && items.size > 1) {
+            val prevIndex = wrapIndex(currentIndex - 1, items.size)
+            val nextIndex = wrapIndex(currentIndex + 1, items.size)
+
+            // Filmstrip shows 3 bitmaps at once — scale down to fit RemoteViews ~1MB limit
+            // Center (60% width) gets 400px, side previews (20% each) get 200px
+            val filmstrip = CarouselFilmstripRemoteViews.build(
+                context = context,
+                notificationId = notificationId,
+                title = title,
+                itemTitle = currentItem.optString("title", body),
+                itemBody = currentItem.optString("body", ""),
+                leftBitmap = bitmaps[prevIndex]?.let { scaleBitmap(it, 200) },
+                centerBitmap = bitmaps[currentIndex]?.let { scaleBitmap(it, 400) },
+                rightBitmap = bitmaps[nextIndex]?.let { scaleBitmap(it, 200) },
+                currentIndex = currentIndex,
+                totalItems = items.size,
+                messageId = messageId,
+                itemRoute = itemRoute
+            )
+            expanded = filmstrip.expanded
+            collapsed = filmstrip.collapsed
+        } else {
+            // Standard shows 1 bitmap at a time via ViewFlipper — 720px is fine
+            val scaledBitmaps = bitmaps.map { bitmap ->
+                bitmap?.let { scaleBitmap(it, 720) }
+            }
+            val standard = CarouselRemoteViews.build(
+                context = context,
+                notificationId = notificationId,
+                title = title,
+                body = currentItem.optString("title", body),
+                bitmaps = scaledBitmaps,
+                currentIndex = currentIndex,
+                totalItems = items.size,
+                messageId = messageId,
+                itemRoute = itemRoute
+            )
+            expanded = standard.expanded
+            collapsed = standard.collapsed
+        }
+
+        applyPreApi31TextPadding(context, expanded, variant)
+
+        val appIcon = getAppIcon(context)
+
+        val builder = NotificationCompat.Builder(context, channelId)
+            .setSmallIcon(appIcon)
+            .setContentTitle(title)
+            .setCustomBigContentView(expanded)
+            .setCustomContentView(collapsed)
+            .setOngoing(false)
+            .setAutoCancel(true)
+            .setOnlyAlertOnce(true)
+            .setDeleteIntent(createActionPendingIntent(
+                context, notificationId, ACTION_DISMISS, Bundle()
+            ))
+
+        // DecoratedCustomViewStyle on Android 12+ (same as CleverTap)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            builder.setStyle(NotificationCompat.DecoratedCustomViewStyle())
+        }
+
+        val nm = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        nm.notify(notificationId, builder.build())
+    }
+
+    /**
+     * Show auto-carousel using ViewFlipper with autoStart.
+     */
+    private fun showAutoCarouselNotification(
+        context: Context,
+        notificationId: Int,
+        title: String,
+        body: String,
+        channelId: String,
+        items: List<JSONObject>,
+        bitmaps: List<Bitmap?>,
+        intervalMs: Int,
+        messageId: String,
+        defaultRoute: String
+    ) {
+        val route = defaultRoute.ifEmpty {
+            items.firstOrNull()?.optString("route", "") ?: ""
+        }
+
+        val scaledBitmaps = bitmaps.map { bitmap ->
+            bitmap?.let { scaleBitmap(it, 400) }
+        }
+
+        val views = CarouselAutoRemoteViews.build(
+            context = context,
+            notificationId = notificationId,
+            title = title,
+            body = body,
+            bitmaps = scaledBitmaps,
+            intervalMs = intervalMs,
+            messageId = messageId,
+            defaultRoute = route
+        )
+
+        applyPreApi31TextPadding(context, views.expanded, "auto")
+
+        val appIcon = getAppIcon(context)
+
+        val builder = NotificationCompat.Builder(context, channelId)
+            .setSmallIcon(appIcon)
+            .setCustomBigContentView(views.expanded)
+            .setCustomContentView(views.collapsed)
+            .setOngoing(false)
+            .setAutoCancel(false)
+            .setOnlyAlertOnce(true)
+            .setDeleteIntent(createActionPendingIntent(
+                context, notificationId, ACTION_DISMISS, Bundle()
+            ))
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            builder.setStyle(NotificationCompat.DecoratedCustomViewStyle())
+        }
+
+        val nm = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        nm.notify(notificationId, builder.build())
+    }
+
+    internal fun createActionPendingIntent(
+        context: Context,
+        notificationId: Int,
+        action: String,
+        extras: Bundle
+    ): PendingIntent {
+        val intent = Intent(context, SwanNotificationActionReceiver::class.java).apply {
+            this.action = "com.loyalytics.swan.${action}_$notificationId"
+            putExtra(SwanNotificationActionReceiver.EXTRA_TEMPLATE_TYPE, TYPE)
+            putExtra(SwanNotificationActionReceiver.EXTRA_TEMPLATE_ACTION, action)
+            putExtra(SwanNotificationActionReceiver.EXTRA_NOTIFICATION_ID, notificationId)
+            putExtras(extras)
+        }
+
+        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".hashCode(), intent, flags)
+    }
+
+    private fun scaleBitmap(bitmap: Bitmap, maxDimension: Int): Bitmap {
+        val width = bitmap.width
+        val height = bitmap.height
+        if (width <= maxDimension && height <= maxDimension) return bitmap
+        val ratio = minOf(maxDimension.toFloat() / width, maxDimension.toFloat() / height)
+        val newWidth = (width * ratio).toInt().coerceAtLeast(1)
+        val newHeight = (height * ratio).toInt().coerceAtLeast(1)
+        return Bitmap.createScaledBitmap(bitmap, newWidth, newHeight, true)
+    }
+
+    private fun getAppIcon(context: Context): Int {
+        return try {
+            val appInfo = context.applicationInfo
+            appInfo.icon.takeIf { it != 0 }
+                ?: android.R.drawable.ic_dialog_info
+        } catch (e: Exception) {
+            android.R.drawable.ic_dialog_info
+        }
+    }
+
+    /**
+     * On API < 31 (pre-Android 12) there's no DecoratedCustomViewStyle padding,
+     * so we add 16dp horizontal padding to text areas programmatically.
+     */
+    private fun applyPreApi31TextPadding(context: Context, expanded: RemoteViews, variant: String) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) return
+
+        val dm = context.resources.displayMetrics
+        val px16 = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 16f, dm).toInt()
+        val px8 = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 8f, dm).toInt()
+        val px4 = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 4f, dm).toInt()
+        val px2 = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 2f, dm).toInt()
+
+        when (variant) {
+            "filmstrip" -> {
+                expanded.setViewPadding(R.id.swan_filmstrip_title, px16, 0, px16, px8)
+                expanded.setViewPadding(R.id.swan_filmstrip_item_title, px16, 0, px16, 0)
+                expanded.setViewPadding(R.id.swan_filmstrip_item_body, px16, 0, px16, 0)
+                expanded.setViewPadding(R.id.swan_filmstrip_counter, px16, 0, px16, 0)
+            }
+            "auto" -> {
+                expanded.setViewPadding(R.id.swan_carousel_auto_title, px16, 0, px16, 0)
+                expanded.setViewPadding(R.id.swan_carousel_auto_body, px16, 0, px16, 0)
+            }
+            else -> {
+                expanded.setViewPadding(R.id.swan_carousel_header, px16, 0, px16, px8)
+                expanded.setViewPadding(R.id.swan_carousel_counter, 0, px2, px16, px4)
+            }
+        }
+    }
+
+    private fun parseItems(json: String): List<JSONObject> {
+        return try {
+            val array = JSONArray(json)
+            (0 until array.length())
+                .map { array.getJSONObject(it) }
+                .filter { it.optString("imageUrl", "").isNotEmpty() }
+                .take(10)
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to parse carousel items", e)
+            emptyList()
+        }
+    }
+}
+
+/**
+ * Calculate wrapped index for circular navigation.
+ */
+internal fun wrapIndex(index: Int, size: Int): Int {
+    if (size == 0) return 0
+    return ((index % size) + size) % size
+}

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

@@ -0,0 +1,70 @@
+package com.loyalytics.swan.templates.common
+
+import android.graphics.Bitmap
+import android.util.Log
+import java.util.concurrent.ConcurrentHashMap
+
+/**
+ * In-memory bitmap cache for notification images.
+ * Keyed by notificationId → (imageUrl → Bitmap).
+ *
+ * Pre-populated on first display, served on navigation clicks,
+ * cleared on notification dismiss or click-through.
+ */
+object NotificationBitmapCache {
+    private const val TAG = "SwanBitmapCache"
+
+    private val cache = ConcurrentHashMap<Int, ConcurrentHashMap<String, Bitmap>>()
+
+    /**
+     * Bulk-cache bitmaps after initial downloadAll.
+     * Only caches non-null bitmaps with non-empty URLs.
+     */
+    fun putAll(notificationId: Int, urls: List<String>, bitmaps: List<Bitmap?>) {
+        val map = cache.getOrPut(notificationId) { ConcurrentHashMap() }
+        var cached = 0
+        urls.forEachIndexed { index, url ->
+            val bitmap = bitmaps.getOrNull(index)
+            if (url.isNotEmpty() && bitmap != null) {
+                map[url] = bitmap
+                cached++
+            }
+        }
+        Log.d(TAG, "Cached $cached/${urls.size} bitmaps for notification $notificationId")
+    }
+
+    /**
+     * Get a single cached bitmap. Returns null on cache miss.
+     */
+    fun get(notificationId: Int, url: String): Bitmap? {
+        return cache[notificationId]?.get(url)
+    }
+
+    /**
+     * Cache a single bitmap (e.g., after a cache-miss download).
+     */
+    fun put(notificationId: Int, url: String, bitmap: Bitmap) {
+        val map = cache.getOrPut(notificationId) { ConcurrentHashMap() }
+        map[url] = bitmap
+    }
+
+    /**
+     * Get ordered list of bitmaps for the given URLs.
+     * Returns null for any cache miss.
+     */
+    fun getAll(notificationId: Int, urls: List<String>): List<Bitmap?> {
+        val map = cache[notificationId] ?: return urls.map { null }
+        return urls.map { url -> map[url] }
+    }
+
+    /**
+     * Clear all cached bitmaps for a notification (on dismiss/click).
+     */
+    fun clear(notificationId: Int) {
+        val removed = cache.remove(notificationId)
+        val count = removed?.size ?: 0
+        if (count > 0) {
+            Log.d(TAG, "Cleared $count cached bitmaps for notification $notificationId")
+        }
+    }
+}

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

@@ -0,0 +1,97 @@
+package com.loyalytics.swan.templates.common
+
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.util.Log
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.withContext
+import java.net.HttpURLConnection
+import java.net.URL
+
+/**
+ * Shared image downloader for notification templates.
+ * Downloads and decodes bitmap images from URLs with size limits.
+ */
+object NotificationImageLoader {
+    private const val TAG = "SwanImageLoader"
+    private const val CONNECT_TIMEOUT_MS = 5000
+    private const val READ_TIMEOUT_MS = 10000
+    private const val MAX_IMAGE_DIMENSION = 500 // px
+
+    /**
+     * Download a single image from a URL.
+     * Returns null if download fails.
+     */
+    suspend fun download(imageUrl: String): Bitmap? = withContext(Dispatchers.IO) {
+        try {
+            val url = URL(imageUrl)
+            val connection = url.openConnection() as HttpURLConnection
+            connection.connectTimeout = CONNECT_TIMEOUT_MS
+            connection.readTimeout = READ_TIMEOUT_MS
+            connection.doInput = true
+            connection.connect()
+
+            if (connection.responseCode != HttpURLConnection.HTTP_OK) {
+                Log.w(TAG, "HTTP ${connection.responseCode} for $imageUrl")
+                connection.disconnect()
+                return@withContext null
+            }
+
+            val inputStream = connection.inputStream
+
+            // First pass: get dimensions
+            val options = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+            BitmapFactory.decodeStream(inputStream, null, options)
+            inputStream.close()
+            connection.disconnect()
+
+            // Calculate sample size for downscaling
+            val sampleSize = calculateSampleSize(
+                options.outWidth, options.outHeight, MAX_IMAGE_DIMENSION, MAX_IMAGE_DIMENSION
+            )
+
+            // Second pass: decode with sample size
+            val connection2 = url.openConnection() as HttpURLConnection
+            connection2.connectTimeout = CONNECT_TIMEOUT_MS
+            connection2.readTimeout = READ_TIMEOUT_MS
+            connection2.doInput = true
+            connection2.connect()
+
+            val decodeOptions = BitmapFactory.Options().apply { inSampleSize = sampleSize }
+            val bitmap = BitmapFactory.decodeStream(connection2.inputStream, null, decodeOptions)
+            connection2.disconnect()
+
+            bitmap
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to download image: $imageUrl", e)
+            null
+        }
+    }
+
+    /**
+     * Download multiple images concurrently.
+     * Returns list of nullable bitmaps (null for failed downloads).
+     */
+    suspend fun downloadAll(imageUrls: List<String>): List<Bitmap?> = coroutineScope {
+        imageUrls.map { url ->
+            async { download(url) }
+        }.awaitAll()
+    }
+
+    private fun calculateSampleSize(
+        width: Int, height: Int, reqWidth: Int, reqHeight: Int
+    ): Int {
+        var sampleSize = 1
+        if (height > reqHeight || width > reqWidth) {
+            val halfHeight = height / 2
+            val halfWidth = width / 2
+            while ((halfHeight / sampleSize) >= reqHeight && (halfWidth / sampleSize) >= reqWidth) {
+                sampleSize *= 2
+            }
+        }
+        return sampleSize
+    }
+}

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

@@ -0,0 +1,85 @@
+package com.loyalytics.swan.templates.common
+
+import android.content.Context
+import android.content.SharedPreferences
+import android.util.Log
+import org.json.JSONArray
+import org.json.JSONObject
+import java.util.concurrent.ConcurrentHashMap
+
+/**
+ * Manages state persistence for interactive notifications (e.g., carousel current index).
+ *
+ * Uses in-memory cache for fast reads during notification updates,
+ * backed by SharedPreferences for process restart survival.
+ */
+object NotificationStateManager {
+    private const val TAG = "SwanStateManager"
+    private const val PREFS_NAME = "swan_notification_state"
+
+    // In-memory cache for fast reads
+    private val memoryCache = ConcurrentHashMap<Int, JSONObject>()
+
+    private fun getPrefs(context: Context): SharedPreferences {
+        return context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+    }
+
+    /**
+     * Save state for a notification.
+     * @param notificationId The Android notification ID
+     * @param state JSON object with template-specific state
+     */
+    fun save(context: Context, notificationId: Int, state: JSONObject) {
+        memoryCache[notificationId] = state
+        try {
+            getPrefs(context).edit()
+                .putString(notificationId.toString(), state.toString())
+                .apply()
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to persist state for notification $notificationId", e)
+        }
+    }
+
+    /**
+     * Get state for a notification. Checks memory first, then SharedPrefs.
+     */
+    fun get(context: Context, notificationId: Int): JSONObject? {
+        // Check memory first
+        memoryCache[notificationId]?.let { return it }
+
+        // Fall back to SharedPrefs
+        return try {
+            val json = getPrefs(context).getString(notificationId.toString(), null)
+            if (json != null) {
+                val state = JSONObject(json)
+                memoryCache[notificationId] = state
+                state
+            } else {
+                null
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to read state for notification $notificationId", e)
+            null
+        }
+    }
+
+    /**
+     * Remove state for a dismissed notification.
+     */
+    fun remove(context: Context, notificationId: Int) {
+        memoryCache.remove(notificationId)
+        try {
+            getPrefs(context).edit()
+                .remove(notificationId.toString())
+                .apply()
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to remove state for notification $notificationId", e)
+        }
+    }
+
+    /** Visible for testing */
+    internal fun clearAll(context: Context) {
+        memoryCache.clear()
+        getPrefs(context).edit().clear().apply()
+    }
+}

package/android/src/main/res/anim/swan_fade_in.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<alpha xmlns:android="http://schemas.android.com/apk/res/android"
+    android:fromAlpha="0.0"
+    android:toAlpha="1.0"
+    android:duration="300"
+    android:interpolator="@android:anim/decelerate_interpolator" />

package/android/src/main/res/anim/swan_fade_out.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<alpha xmlns:android="http://schemas.android.com/apk/res/android"
+    android:fromAlpha="1.0"
+    android:toAlpha="0.0"
+    android:duration="300"
+    android:interpolator="@android:anim/accelerate_interpolator" />

package/android/src/main/res/anim/swan_slide_in_right.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<set xmlns:android="http://schemas.android.com/apk/res/android">
+    <translate
+        android:fromXDelta="100%p"
+        android:toXDelta="0"
+        android:duration="300"
+        android:interpolator="@android:anim/decelerate_interpolator" />
+</set>