@shortkitsdk/react-native 0.2.12 → 0.2.14

package/android/src/main/java/com/shortkit/reactnative/ReactCarouselOverlayHost.kt

@@ -56,6 +56,13 @@ class ReactCarouselOverlayHost(context: Context) : FrameLayout(context), Carouse
     private var pendingWriteJob: Job? = null
     private var configureGeneration: Int = 0
 
+    /** Unique identifier for this overlay instance, used for event routing. */
+    val surfaceId: String = java.util.UUID.randomUUID().toString()
+
+    private var cachedItemJSON: String? = null
+    private var isActive: Boolean = false
+    private var activeImageIndex: Int = 0
+
     // ------------------------------------------------------------------
     // Fabric layout workaround
     // ------------------------------------------------------------------
@@ -123,6 +130,9 @@ class ReactCarouselOverlayHost(context: Context) : FrameLayout(context), Carouse
     // ------------------------------------------------------------------
 
     override fun configure(item: ImageCarouselItem) {
+        isActive = false
+        activeImageIndex = 0
+
         // Increment generation — any in-flight coroutine from a previous
         // configure() call will see a stale generation and bail out.
         val gen = ++configureGeneration
@@ -155,8 +165,8 @@ class ReactCarouselOverlayHost(context: Context) : FrameLayout(context), Carouse
         } else item
 
         val json = Json.encodeToString(fastItem)
-        val bundle = Bundle().apply { putString("item", json) }
-        applySurfaceProps(bundle)
+        cachedItemJSON = json
+        pushProps()
 
         // Pre-size the surface view NOW — before the overlay is attached to a cell.
         val parentView = parent as? android.view.View
@@ -203,12 +213,45 @@ class ReactCarouselOverlayHost(context: Context) : FrameLayout(context), Carouse
             val hasLocalImages = modifiedItem.images.any { it.url.startsWith("file://") }
             if (hasLocalImages) {
                 val localJson = Json.encodeToString(modifiedItem)
-                val localBundle = Bundle().apply { putString("item", localJson) }
-                applySurfaceProps(localBundle)
+                cachedItemJSON = localJson
+                pushProps()
             }
         }
     }
 
+    override fun activatePlayback() {
+        isActive = true
+        val params = com.facebook.react.bridge.Arguments.createMap().apply {
+            putString("surfaceId", surfaceId)
+            putBoolean("isActive", true)
+            putString("playerState", "idle")
+            putBoolean("isMuted", true)
+            putDouble("playbackRate", 1.0)
+            putBoolean("captionsEnabled", false)
+            putNull("activeCue")
+            putNull("feedScrollPhase")
+        }
+        ShortKitBridge.shared?.emitEvent("onOverlayFullState", params)
+    }
+
+    override fun updateActiveImage(index: Int) {
+        activeImageIndex = index
+        val params = com.facebook.react.bridge.Arguments.createMap().apply {
+            putString("surfaceId", surfaceId)
+            putInt("activeImageIndex", index)
+        }
+        ShortKitBridge.shared?.emitEvent("onCarouselActiveImageChanged", params)
+    }
+
+    /** Build a props bundle with item data and surfaceId. */
+    private fun pushProps() {
+        val bundle = Bundle().apply {
+            putString("surfaceId", surfaceId)
+            cachedItemJSON?.let { putString("item", it) }
+        }
+        applySurfaceProps(bundle)
+    }
+
     /** Apply props to the surface, handling all lifecycle states. */
     private fun applySurfaceProps(bundle: Bundle) {
         val s = surface

package/android/src/main/java/com/shortkit/reactnative/ReactVideoCarouselOverlayHost.kt

@@ -0,0 +1,431 @@
+package com.shortkit.reactnative
+
+import android.content.Context
+import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
+import android.widget.FrameLayout
+import com.facebook.react.ReactApplication
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.interfaces.fabric.ReactSurface
+import com.facebook.react.runtime.ReactSurfaceImpl
+import com.shortkit.sdk.ShortKitPlayer
+import com.shortkit.sdk.model.ContentItem
+import com.shortkit.sdk.model.PlayerState
+import com.shortkit.sdk.model.VideoCarouselItem
+import com.shortkit.sdk.overlay.VideoCarouselOverlay
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+import java.util.UUID
+
+/**
+ * A [FrameLayout] that conforms to [VideoCarouselOverlay] and hosts a React Native
+ * Fabric [ReactSurface] for rendering the developer's React video carousel overlay
+ * component inside a feed cell.
+ *
+ * Pushes [VideoCarouselItem] and active video data as surface properties, and
+ * emits playback state (isActive, time, playerState, isMuted) via bridge events
+ * using the same event names as [ReactOverlayHost] (routed by [surfaceId]).
+ *
+ * Android equivalent of `react_native_sdk/ios/ReactVideoCarouselOverlayHost.swift`.
+ */
+class ReactVideoCarouselOverlayHost(context: Context) : FrameLayout(context), VideoCarouselOverlay {
+
+    private companion object {
+        const val TAG = "SK:VidCarouselHost"
+    }
+
+    // Touch handling: this view sits below the ViewPager2 in z-order.
+    // The cell's root FrameLayout dispatches taps to this overlay when the
+    // ViewPager2 doesn't consume them (i.e. non-scroll touches).
+
+    // ------------------------------------------------------------------
+    // Configuration
+    // ------------------------------------------------------------------
+
+    /** Suffix for the surface module name (e.g. "news" -> "ShortKitVideoCarouselOverlay_news"). */
+    var videoCarouselOverlayName: String = "Default"
+
+    // ------------------------------------------------------------------
+    // State
+    // ------------------------------------------------------------------
+
+    private var surface: ReactSurface? = null
+    private var pendingProps: Bundle? = null
+    private var isInLayoutPass: Boolean = false
+
+    /** Unique identifier for this overlay instance, used for event routing. */
+    val surfaceId: String = UUID.randomUUID().toString()
+
+    /** Cached carouselItem JSON — updateInitProps replaces all props, doesn't merge. */
+    private var carouselItemJSON: String? = null
+
+    // Player state
+    private var player: ShortKitPlayer? = null
+    private var isActive: Boolean = false
+    private var cachedPlayerState: String = "idle"
+    private var cachedIsMuted: Boolean = true
+    private var cachedCurrentTime: Double = 0.0
+    private var cachedDuration: Double = 0.0
+    private var cachedBuffered: Double = 0.0
+    private var timeDirty: Boolean = false
+    private val handler = Handler(Looper.getMainLooper())
+    private var timeCoalesceRunnable: Runnable? = null
+    private var flowScope: CoroutineScope? = null
+
+    // ------------------------------------------------------------------
+    // Fabric layout workaround
+    // ------------------------------------------------------------------
+
+    private val layoutHandler = Handler(Looper.getMainLooper())
+
+    private val layoutRunnable = Runnable {
+        measure(
+            MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
+            MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY)
+        )
+        layout(left, top, right, bottom)
+    }
+
+    override fun requestLayout() {
+        super.requestLayout()
+        if (!isInLayoutPass) {
+            @Suppress("UNNECESSARY_SAFE_CALL")
+            layoutHandler?.post(layoutRunnable)
+        }
+    }
+
+    // ------------------------------------------------------------------
+    // Init
+    // ------------------------------------------------------------------
+
+    init {
+        setBackgroundColor(android.graphics.Color.TRANSPARENT)
+    }
+
+    // ------------------------------------------------------------------
+    // Surface warmup
+    // ------------------------------------------------------------------
+
+    fun prepareSurface() {
+        createSurfaceIfNeeded()
+
+        val displayW = context.resources.displayMetrics.widthPixels
+        val displayH = context.resources.displayMetrics.heightPixels
+        val wSpec = MeasureSpec.makeMeasureSpec(displayW, MeasureSpec.EXACTLY)
+        val hSpec = MeasureSpec.makeMeasureSpec(displayH, MeasureSpec.EXACTLY)
+        measure(wSpec, hSpec)
+        layout(0, 0, displayW, displayH)
+        measureAndLayoutSurfaceView(displayW, displayH)
+    }
+
+    // ------------------------------------------------------------------
+    // VideoCarouselOverlay
+    // ------------------------------------------------------------------
+
+    override fun configure(item: VideoCarouselItem) {
+        isActive = false
+        timeDirty = false
+        stopTimeCoalescing()
+        cachedCurrentTime = 0.0
+        cachedDuration = 0.0
+        cachedBuffered = 0.0
+        cachedPlayerState = "idle"
+
+        val json = Json.encodeToString(item)
+        carouselItemJSON = json
+        val bundle = Bundle().apply {
+            putString("surfaceId", surfaceId)
+            putString("carouselItem", json)
+            putBoolean("isActive", false)
+            putString("playerState", "idle")
+            putBoolean("isMuted", cachedIsMuted)
+            if (item.videos.isNotEmpty()) {
+                putString("activeVideo", ShortKitBridge.serializeContentItemToJSON(item.videos.first()))
+                putInt("activeVideoIndex", 0)
+            }
+        }
+        applySurfaceProps(bundle)
+
+        // Pre-size the surface view
+        val parentView = parent as? android.view.View
+        val w = if (width > 0) width
+                else if (parentView != null && parentView.width > 0) parentView.width
+                else context.resources.displayMetrics.widthPixels
+        val h = if (height > 0) height
+                else if (parentView != null && parentView.height > 0) parentView.height
+                else context.resources.displayMetrics.heightPixels
+        measureAndLayoutSurfaceView(w, h)
+    }
+
+    override fun updateActiveVideo(index: Int, item: ContentItem) {
+        // Only emit when active — matches ReactOverlayHost pattern.
+        // During initial setup, configure() sets the first video via surface props.
+        if (!isActive) return
+
+        val params = Arguments.createMap().apply {
+            putString("surfaceId", surfaceId)
+            putString("activeVideo", ShortKitBridge.serializeContentItemToJSON(item))
+            putInt("activeVideoIndex", index)
+        }
+        ShortKitBridge.shared?.emitEvent("onVideoCarouselActiveVideoChanged", params)
+    }
+
+    override fun resetState() {
+        // Don't clear surface props — configure() will overwrite.
+    }
+
+    override fun attach(player: ShortKitPlayer) {
+        this.player = player
+        resubscribeToPlayer(player)
+    }
+
+    override fun activatePlayback() {
+        isActive = true
+        startTimeCoalescing()
+
+        handler.post {
+            if (isActive) {
+                emitFullState()
+            }
+        }
+    }
+
+    override fun deactivatePlayback() {
+        isActive = false
+        timeDirty = false
+        stopTimeCoalescing()
+    }
+
+    // ------------------------------------------------------------------
+    // Player Subscriptions
+    // ------------------------------------------------------------------
+
+    private fun resubscribeToPlayer(player: ShortKitPlayer) {
+        flowScope?.cancel()
+        val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
+        flowScope = scope
+
+        scope.launch {
+            player.playerState.collect { state ->
+                cachedPlayerState = ShortKitBridge.playerStateString(state)
+                if (isActive) {
+                    val params = Arguments.createMap().apply {
+                        putString("surfaceId", surfaceId)
+                        putString("playerState", cachedPlayerState)
+                    }
+                    ShortKitBridge.shared?.emitEvent("onOverlayPlayerStateChanged", params)
+                }
+            }
+        }
+
+        scope.launch {
+            player.isMuted.collect { muted ->
+                cachedIsMuted = muted
+                if (isActive) {
+                    val params = Arguments.createMap().apply {
+                        putString("surfaceId", surfaceId)
+                        putBoolean("isMuted", cachedIsMuted)
+                    }
+                    ShortKitBridge.shared?.emitEvent("onOverlayMutedChanged", params)
+                }
+            }
+        }
+
+        scope.launch {
+            player.time.collect { time ->
+                cachedCurrentTime = time.currentMs / 1000.0
+                cachedDuration = time.durationMs / 1000.0
+                cachedBuffered = time.bufferedMs / 1000.0
+                if (isActive) {
+                    timeDirty = true
+                }
+            }
+        }
+    }
+
+    // ------------------------------------------------------------------
+    // Time Coalescing (250ms)
+    // ------------------------------------------------------------------
+
+    private fun startTimeCoalescing() {
+        stopTimeCoalescing()
+        val runnable = object : Runnable {
+            override fun run() {
+                if (isActive && timeDirty && cachedPlayerState != "seeking") {
+                    emitTimeUpdate()
+                    timeDirty = false
+                }
+                if (isActive) {
+                    handler.postDelayed(this, 250)
+                }
+            }
+        }
+        timeCoalesceRunnable = runnable
+        handler.postDelayed(runnable, 250)
+    }
+
+    private fun stopTimeCoalescing() {
+        timeCoalesceRunnable?.let { handler.removeCallbacks(it) }
+        timeCoalesceRunnable = null
+    }
+
+    private fun emitTimeUpdate() {
+        val params = Arguments.createMap().apply {
+            putString("surfaceId", surfaceId)
+            putDouble("current", cachedCurrentTime)
+            putDouble("duration", cachedDuration)
+            putDouble("buffered", cachedBuffered)
+        }
+        ShortKitBridge.shared?.emitEvent("onOverlayTimeUpdate", params)
+    }
+
+    // ------------------------------------------------------------------
+    // Full State Emission
+    // ------------------------------------------------------------------
+
+    private fun emitFullState() {
+        val bridge = ShortKitBridge.shared ?: return
+
+        val params = Arguments.createMap().apply {
+            putString("surfaceId", surfaceId)
+            putBoolean("isActive", true)
+            putString("playerState", cachedPlayerState)
+            putBoolean("isMuted", cachedIsMuted)
+            putDouble("playbackRate", 1.0)
+            putBoolean("captionsEnabled", false)
+            putNull("activeCue")
+            putNull("feedScrollPhase")
+        }
+        bridge.emitEvent("onOverlayFullState", params)
+    }
+
+    // ------------------------------------------------------------------
+    // Surface Creation
+    // ------------------------------------------------------------------
+
+    /** Apply props to the surface, handling all lifecycle states. */
+    private fun applySurfaceProps(bundle: Bundle) {
+        val s = surface
+        if (s != null && s.isRunning) {
+            (s as? ReactSurfaceImpl)?.updateInitProps(bundle)
+        } else if (s != null && !s.isRunning) {
+            (s as? ReactSurfaceImpl)?.updateInitProps(bundle)
+            s.start()
+        } else {
+            pendingProps = bundle
+            createSurfaceIfNeeded()
+        }
+    }
+
+    override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
+        super.onSizeChanged(w, h, oldw, oldh)
+        if (w > 0 && h > 0) {
+            measureAndLayoutSurfaceView(w, h)
+        }
+    }
+
+    override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
+        isInLayoutPass = true
+        try {
+            super.onLayout(changed, left, top, right, bottom)
+            val w = right - left
+            val h = bottom - top
+            if (w > 0 && h > 0) {
+                measureAndLayoutSurfaceView(w, h)
+            } else {
+                val parentView = parent as? android.view.View
+                val pw = parentView?.width ?: 0
+                val ph = parentView?.height ?: 0
+                if (pw > 0 && ph > 0) {
+                    measureAndLayoutSurfaceView(pw, ph)
+                }
+            }
+        } finally {
+            isInLayoutPass = false
+        }
+    }
+
+    private fun measureAndLayoutSurfaceView(w: Int, h: Int) {
+        val sv = surface?.view ?: return
+        if (sv.width == w && sv.height == h) return
+        val wSpec = android.view.View.MeasureSpec.makeMeasureSpec(w, android.view.View.MeasureSpec.EXACTLY)
+        val hSpec = android.view.View.MeasureSpec.makeMeasureSpec(h, android.view.View.MeasureSpec.EXACTLY)
+        sv.measure(wSpec, hSpec)
+        sv.layout(0, 0, w, h)
+    }
+
+    override fun onAttachedToWindow() {
+        super.onAttachedToWindow()
+
+        // Re-subscribe to player flows if we were detached and reattached
+        if (flowScope == null) {
+            player?.let { resubscribeToPlayer(it) }
+        }
+
+        val parentView = parent as? android.view.View
+        if (parentView != null && parentView.width > 0 && parentView.height > 0 && (width == 0 || height == 0)) {
+            val wSpec = MeasureSpec.makeMeasureSpec(parentView.width, MeasureSpec.EXACTLY)
+            val hSpec = MeasureSpec.makeMeasureSpec(parentView.height, MeasureSpec.EXACTLY)
+            measure(wSpec, hSpec)
+            layout(0, 0, parentView.width, parentView.height)
+        }
+    }
+
+    private fun createSurfaceIfNeeded() {
+        if (surface != null) return
+
+        val reactHost = (context.applicationContext as? ReactApplication)?.reactHost
+        if (reactHost == null) {
+            android.util.Log.e(TAG, "createSurface FAILED: reactHost is null")
+            return
+        }
+        val moduleName = "ShortKitVideoCarouselOverlay_$videoCarouselOverlayName"
+
+        val initialProps = pendingProps
+        pendingProps = null
+
+        val newSurface = reactHost.createSurface(context, moduleName, initialProps)
+        surface = newSurface
+
+        newSurface.view?.let { surfaceView ->
+            surfaceView.layoutParams = LayoutParams(
+                LayoutParams.MATCH_PARENT,
+                LayoutParams.MATCH_PARENT
+            )
+            addView(surfaceView)
+        }
+
+        // Only start if we have item data
+        if (initialProps != null) {
+            newSurface.start()
+        }
+
+        val parentView = parent as? android.view.View
+        val w = if (width > 0) width else parentView?.width ?: 0
+        val h = if (height > 0) height else parentView?.height ?: 0
+        if (w > 0 && h > 0) {
+            measureAndLayoutSurfaceView(w, h)
+        }
+    }
+
+    // ------------------------------------------------------------------
+    // Cleanup
+    // ------------------------------------------------------------------
+
+    override fun onDetachedFromWindow() {
+        super.onDetachedFromWindow()
+        flowScope?.cancel()
+        flowScope = null
+        isActive = false
+        stopTimeCoalescing()
+        if (surface?.isRunning == true) {
+            surface?.stop()
+        }
+    }
+}

package/android/src/main/java/com/shortkit/reactnative/ShortKitBridge.kt

@@ -17,6 +17,7 @@ import com.shortkit.sdk.model.FeedInput
 import com.shortkit.sdk.model.FeedScrollPhase
 import com.shortkit.sdk.model.FeedTransitionPhase
 import com.shortkit.sdk.model.ImageCarouselItem
+import com.shortkit.sdk.model.VideoCarouselItem
 import com.shortkit.sdk.model.JsonValue
 import com.shortkit.sdk.model.PlayerState
 import com.shortkit.sdk.config.AdOverlayMode
@@ -26,6 +27,7 @@ import com.shortkit.sdk.config.FeedHeight
 import com.shortkit.sdk.config.FeedSource
 import com.shortkit.sdk.config.ScrollAxis
 import com.shortkit.sdk.config.SurveyOverlayMode
+import com.shortkit.sdk.config.VideoCarouselOverlayMode
 import com.shortkit.sdk.config.VideoOverlayMode
 import com.shortkit.sdk.feed.FeedPreload
 import com.shortkit.sdk.feed.ShortKitFeedFragment
@@ -152,6 +154,8 @@ class ShortKitBridge(
 
                 val carouselOverlayRaw = obj.optString("carouselOverlay", null)
                 val carouselOverlay = parseCarouselOverlay(carouselOverlayRaw, context)
+                val videoCarouselOverlayRaw = obj.optString("videoCarouselOverlay", null)
+                val videoCarouselOverlay = parseVideoCarouselOverlay(videoCarouselOverlayRaw, context)
                 val autoplay = obj.optBoolean("autoplay", true)
                 val filter = obj.optJSONObject("filter")?.let { parseFeedFilterToModel(it.toString()) }
 
@@ -162,6 +166,7 @@ class ShortKitBridge(
                     feedHeight = feedHeight,
                     videoOverlay = videoOverlay,
                     carouselOverlay = carouselOverlay,
+                    videoCarouselOverlay = videoCarouselOverlay,
                     surveyOverlay = SurveyOverlayMode.None,
                     adOverlay = AdOverlayMode.None,
                     muteOnStart = muteOnStart,
@@ -273,6 +278,43 @@ class ShortKitBridge(
             }
         }
 
+        /**
+         * Parse a double-stringified video carousel overlay JSON.
+         * - `"\"none\""` -> None
+         * - `"{\"type\":\"custom\"}"` -> Custom with ReactVideoCarouselOverlayHost factory
+         */
+        private fun parseVideoCarouselOverlay(json: String?, context: android.content.Context?): VideoCarouselOverlayMode {
+            if (json.isNullOrEmpty()) return VideoCarouselOverlayMode.None
+            return try {
+                val parsed = json.trim()
+
+                if (parsed == "\"none\"" || parsed == "none") {
+                    return VideoCarouselOverlayMode.None
+                }
+
+                val inner = if (parsed.startsWith("\"") && parsed.endsWith("\"")) {
+                    JSONObject(parsed.substring(1, parsed.length - 1).replace("\\\"", "\""))
+                } else {
+                    JSONObject(parsed)
+                }
+
+                if (inner.optString("type") == "custom" && context != null) {
+                    val name = inner.optString("name", "Default")
+                    val ctx = context.applicationContext
+                    VideoCarouselOverlayMode.Custom {
+                        ReactVideoCarouselOverlayHost(ctx).apply {
+                            videoCarouselOverlayName = name
+                            prepareSurface()
+                        }
+                    }
+                } else {
+                    VideoCarouselOverlayMode.None
+                }
+            } catch (_: Exception) {
+                VideoCarouselOverlayMode.None
+            }
+        }
+
         private fun parseFeedFilter(json: String?): String? {
             // On Android, the SDK accepts the raw JSON string for filtering.
             // Return as-is if non-null/non-empty.
@@ -316,6 +358,26 @@ class ShortKitBridge(
                             val carouselItem = parseImageCarouselItem(itemObj) ?: continue
                             result.add(FeedInput.ImageCarousel(carouselItem))
                         }
+                        "videoCarousel" -> {
+                            val itemObj = obj.optJSONObject("item") ?: continue
+                            val videosArr = itemObj.optJSONArray("videos") ?: continue
+                            val videos = mutableListOf<ContentItem>()
+                            for (i in 0 until videosArr.length()) {
+                                val videoObj = videosArr.getJSONObject(i)
+                                parseContentItem(videoObj)?.let { videos.add(it) }
+                            }
+                            if (videos.isEmpty()) continue
+                            val carouselItem = VideoCarouselItem(
+                                id = itemObj.getString("id"),
+                                videos = videos,
+                                title = itemObj.optString("title", null),
+                                description = itemObj.optString("description", null),
+                                author = itemObj.optString("author", null),
+                                section = itemObj.optString("section", null),
+                                articleUrl = itemObj.optString("articleUrl", null),
+                            )
+                            result.add(FeedInput.VideoCarousel(carouselItem))
+                        }
                     }
                 }
                 result.ifEmpty { null }
@@ -349,6 +411,27 @@ class ShortKitBridge(
             )
         }
 
+        private fun parseContentItem(obj: JSONObject): ContentItem? {
+            val id = obj.optString("id", null) ?: return null
+            val title = obj.optString("title", null) ?: return null
+            val duration = obj.optDouble("duration", -1.0).takeIf { it >= 0 } ?: return null
+            val streamingUrl = obj.optString("streamingUrl", null) ?: return null
+            val thumbnailUrl = obj.optString("thumbnailUrl", null) ?: return null
+            return ContentItem(
+                id = id,
+                playbackId = obj.optString("playbackId", null),
+                title = title,
+                description = obj.optString("description", null),
+                duration = duration,
+                streamingUrl = streamingUrl,
+                thumbnailUrl = thumbnailUrl,
+                captionTracks = emptyList(),
+                author = obj.optString("author", null),
+                articleUrl = obj.optString("articleUrl", null),
+                fallbackUrl = obj.optString("fallbackUrl", null),
+            )
+        }
+
         private fun buildCaptionTracksJSONArray(tracks: List<CaptionTrack>): JSONArray {
             val arr = JSONArray()
             for (track in tracks) {

package/android/src/main/java/com/shortkit/reactnative/ShortKitModule.kt

@@ -273,6 +273,8 @@ class ShortKitModule(reactContext: ReactApplicationContext) :
                 "onOverlayFeedScrollPhaseChanged" -> emitOnOverlayFeedScrollPhaseChanged(params)
                 "onOverlayTimeUpdate" -> emitOnOverlayTimeUpdate(params)
                 "onOverlayFullState" -> emitOnOverlayFullState(params)
+                "onCarouselActiveImageChanged" -> emitOnCarouselActiveImageChanged(params)
+                "onVideoCarouselActiveVideoChanged" -> emitOnVideoCarouselActiveVideoChanged(params)
                 else -> {
                     android.util.Log.w("SK:Module", "sendEvent: unknown event name '$name', using legacy emitter")
                     reactApplicationContext