@shortkitsdk/react-native 0.2.34 → 0.2.36

package/android/build.gradle.kts

@@ -27,6 +27,10 @@ android {
             java.srcDirs("src/main/java")
         }
     }
+
+    testOptions {
+        unitTests.isIncludeAndroidResources = true
+    }
 }
 
 dependencies {
@@ -47,4 +51,8 @@ dependencies {
     implementation("com.squareup.okhttp3:okhttp:4.12.0")
     implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.9.0")
     implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.7.3")
+
+    testImplementation("junit:junit:4.13.2")
+    testImplementation("org.robolectric:robolectric:4.14.1")
+    testImplementation("androidx.test:core:1.6.1")
 }

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

@@ -59,6 +59,52 @@ class ReactCarouselOverlayHost(context: Context) : FrameLayout(context), Carouse
     /** Unique identifier for this overlay instance, used for event routing. */
     val surfaceId: String = java.util.UUID.randomUUID().toString()
 
+    /**
+     * Currently configured item id — used to detect item transitions so we
+     * can emit an event instead of triggering a full Fabric remount.
+     * Marked `internal` to allow unit-test verification.
+     */
+    internal var currentItemId: String? = null
+        private set
+
+    /**
+     * Whether initial props have been pushed at least once. First configure
+     * must go through pushProps()/setProperties; subsequent same-item
+     * rebinds are no-op; subsequent different-item rebinds emit
+     * onCarouselItemChanged for a React diff (no Fabric remount).
+     */
+    internal var hasPushedInitialProps: Boolean = false
+        private set
+
+    /**
+     * Test seam for emit-event interception. Production uses the default
+     * (forward to ShortKitBridge.shared); tests can overwrite to capture.
+     * Mirrors how iOS tests wrap bridge.emit().
+     */
+    internal var emitEvent: (String, com.facebook.react.bridge.WritableMap) -> Unit =
+        { name, params -> ShortKitBridge.shared?.emitEvent(name, params) }
+
+    /**
+     * Test seam for WritableMap creation. Defaults to Arguments.createMap()
+     * (WritableNativeMap — requires JNI). Tests override with JavaOnlyMap()
+     * to avoid the native-library initialization requirement in Robolectric.
+     */
+    internal var createMap: () -> com.facebook.react.bridge.WritableMap =
+        { com.facebook.react.bridge.Arguments.createMap() }
+
+    /**
+     * Test seam for ReactSurface creation. Production implementation resolves
+     * the surface from the ReactHost obtained from the application context.
+     * Tests override with a stub/mock so the surface is non-null after
+     * pushProps(), allowing hasPushedInitialProps to flip as expected.
+     * Returns null when surface creation fails (e.g. reactHost unavailable).
+     */
+    internal var createSurface: (moduleName: String, initialProps: Bundle?) -> ReactSurface? =
+        { moduleName, initialProps ->
+            (context.applicationContext as? ReactApplication)?.reactHost
+                ?.createSurface(context, moduleName, initialProps)
+        }
+
     private var cachedItemJSON: String? = null
     private var isActive: Boolean = false
     private var activeImageIndex: Int = 0
@@ -133,16 +179,12 @@ class ReactCarouselOverlayHost(context: Context) : FrameLayout(context), Carouse
         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
+        val isSameItem = item.id == currentItemId
+        currentItemId = item.id
 
-        // Cancel any in-flight write job from a previous configure() call.
+        val gen = ++configureGeneration
         pendingWriteJob?.cancel()
 
-        // Fast path: check for pre-existing temp files synchronously (just
-        // file.exists(), no I/O). This avoids the flicker of remote→local
-        // URL swap for images that were cached in a previous session.
         val lookup = cachedImage
         val fastItem = if (lookup != null) {
             val fastImages = item.images.map { image ->
@@ -166,9 +208,23 @@ class ReactCarouselOverlayHost(context: Context) : FrameLayout(context), Carouse
 
         val json = Json.encodeToString(fastItem)
         cachedItemJSON = json
-        pushProps()
 
-        // Pre-size the surface view NOW — before the overlay is attached to a cell.
+        if (!hasPushedInitialProps) {
+            pushProps()
+            // Only flip the flag if the surface was actually created. If reactHost
+            // was null (createSurfaceIfNeeded silently returned), surface remains
+            // null and pendingProps is parked — stay in "first mount" mode so the
+            // next configure() retries pushProps() with the new item. Mirrors iOS
+            // ReactCarouselOverlayHost.swift:131-141.
+            if (surface != null) {
+                hasPushedInitialProps = true
+            }
+        } else if (!isSameItem) {
+            emitItemChanged(json)
+        }
+        // else: same item rebind — no emit, no Fabric prop push.
+
+        // Pre-size the surface view (existing logic, unchanged).
         val parentView = parent as? android.view.View
         val w = if (width > 0) width
                 else if (parentView != null && parentView.width > 0) parentView.width
@@ -178,54 +234,35 @@ class ReactCarouselOverlayHost(context: Context) : FrameLayout(context), Carouse
                 else context.resources.displayMetrics.heightPixels
         measureAndLayoutSurfaceView(w, h)
 
-        // Background: write any newly-cached images to temp files.
-        // Only runs if there are remote URLs remaining (not all were fast-pathed).
+        // Background: write any newly-cached images to temp files for next-time
+        // fast-path availability. iOS-aligned: write-only, no second pushProps()
+        // (next configure() picks up the local URL via the synchronous fast-path).
         if (lookup == null) return
         val hasRemoteUrls = fastItem.images.any { !it.url.startsWith("file://") }
         if (!hasRemoteUrls) return
 
         pendingWriteJob = ioScope.launch {
-            val modifiedItem = withContext(Dispatchers.IO) {
-                val localImages = item.images.map { image ->
-                    val bitmap = lookup(image.url)
-                    if (bitmap != null) {
-                        val localUrl = writeTempImage(bitmap, image.url)
-                        if (localUrl != null) CarouselImage(url = localUrl, alt = image.alt)
-                        else image
-                    } else {
-                        image
-                    }
+            withContext(Dispatchers.IO) {
+                item.images.forEach { image ->
+                    if (gen != configureGeneration) return@forEach
+                    lookup(image.url)?.let { writeTempImage(it, image.url) }
                 }
-                ImageCarouselItem(
-                    id = item.id,
-                    images = localImages,
-                    caption = item.caption,
-                    title = item.title,
-                    description = item.description,
-                    author = item.author,
-                    section = item.section,
-                    articleUrl = item.articleUrl,
-                )
-            }
-
-            // Back on Main — only update if this configure() is still current
-            if (gen != configureGeneration) return@launch
-            val hasLocalImages = modifiedItem.images.any { it.url.startsWith("file://") }
-            if (hasLocalImages) {
-                val localJson = Json.encodeToString(modifiedItem)
-                cachedItemJSON = localJson
-                pushProps()
             }
         }
     }
 
     override fun activatePlayback() {
         isActive = true
+        // Source mute state from the SDK rather than hardcoding true so
+        // overlay icons reflect actual mute state even on image carousels
+        // (which have no audio of their own but should still match host
+        // expectations).
+        val isMutedNow = ShortKitBridge.shared?.sdk?.player?.isMuted?.value ?: true
         val params = com.facebook.react.bridge.Arguments.createMap().apply {
             putString("surfaceId", surfaceId)
             putBoolean("isActive", true)
             putString("playerState", "idle")
-            putBoolean("isMuted", true)
+            putBoolean("isMuted", isMutedNow)
             putDouble("playbackRate", 1.0)
             putBoolean("captionsEnabled", false)
             putNull("activeCue")
@@ -252,6 +289,21 @@ class ReactCarouselOverlayHost(context: Context) : FrameLayout(context), Carouse
         applySurfaceProps(bundle)
     }
 
+    /**
+     * Emit onCarouselItemChanged for a React diff update on cell reuse.
+     * Replaces pushProps() on subsequent item changes to avoid Fabric remount.
+     * Payload shape mirrors iOS ReactCarouselOverlayHost.swift:151-158.
+     */
+    private fun emitItemChanged(json: String) {
+        val params = createMap().apply {
+            putString("surfaceId", surfaceId)
+            putString("item", json)
+            putBoolean("isActive", false)
+            putInt("activeImageIndex", 0)
+        }
+        emitEvent("onCarouselItemChanged", params)
+    }
+
     /** Apply props to the surface, handling all lifecycle states. */
     private fun applySurfaceProps(bundle: Bundle) {
         val s = surface
@@ -369,11 +421,6 @@ class ReactCarouselOverlayHost(context: Context) : FrameLayout(context), Carouse
     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 = "ShortKitCarouselOverlay_$carouselOverlayName"
 
         // Pass pending props as initial props so the JS component has data on first render.
@@ -382,7 +429,13 @@ class ReactCarouselOverlayHost(context: Context) : FrameLayout(context), Carouse
         val initialProps = pendingProps
         pendingProps = null
 
-        val newSurface = reactHost.createSurface(context, moduleName, initialProps)
+        val newSurface = createSurface(moduleName, initialProps)
+        if (newSurface == null) {
+            android.util.Log.e(TAG, "createSurface FAILED: reactHost is null")
+            // Restore pending props so a future createSurfaceIfNeeded() can retry.
+            if (initialProps != null) pendingProps = initialProps
+            return
+        }
         surface = newSurface
 
         newSurface.view?.let { surfaceView ->

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

@@ -99,6 +99,21 @@ class ReactOverlayHost(context: Context) : FrameLayout(context), FeedOverlay {
     private var cachedActiveCue: JSONObject? = null
     private var cachedFeedScrollPhase: String? = null
 
+    /**
+     * Tracks active drag phase. While true, per-frame player-state emissions
+     * (playerState, isMuted, playbackRate, captionsEnabled, activeCue, time)
+     * are suppressed; emitFullState() re-syncs cached values on settle.
+     *
+     * Mirrors iOS ReactOverlayHost.swift:51 isDragging field.
+     */
+    internal var isDragging: Boolean = false
+        private set
+
+    /** Test-only setter for [isDragging]. */
+    internal var isDraggingForTest: Boolean
+        get() = isDragging
+        set(value) { isDragging = value }
+
     // Time coalescing (250ms)
     private var cachedCurrentTime: Double = 0.0
     private var cachedDuration: Double = 0.0
@@ -172,15 +187,29 @@ class ReactOverlayHost(context: Context) : FrameLayout(context), FeedOverlay {
         cachedDuration = 0.0
         cachedBuffered = 0.0
         cachedPlayerState = "idle"
-        cachedIsMuted = true
+        // Read the SDK's actual current mute state instead of hardcoding
+        // `true`. The flow subscription below will keep this in sync going
+        // forward, but during the brief window between configure() and the
+        // first emission the overlay's initialProps would otherwise carry a
+        // stale `true`, causing the next-cell mute toggle to compute the
+        // wrong target value (the user's tap on the new cell would resolve
+        // to setMuted(false) regardless of actual state).
+        player?.isMuted?.value?.let { cachedIsMuted = it }
         cachedPlaybackRate = 1.0
         cachedCaptionsEnabled = false
         cachedActiveCue = null
         cachedFeedScrollPhase = null
+        isDragging = false
 
         if (surface == null) {
             createSurfaceIfNeeded()
-            surfaceHasStarted = true
+            // Only flip the flag if surface was actually created. If reactHost was
+            // null (createSurfaceIfNeeded silently returned), surface remains null
+            // and the next configure() will retry. Mirrors iOS pattern and matches
+            // the carousel host fix from 6e5e1dce.
+            if (surface != null) {
+                surfaceHasStarted = true
+            }
         } else if (!surfaceHasStarted) {
             (surface as? ReactSurfaceImpl)?.updateInitProps(buildInitialPropsBundle())
             surfaceHasStarted = true
@@ -403,7 +432,7 @@ class ReactOverlayHost(context: Context) : FrameLayout(context), FeedOverlay {
         scope.launch {
             player.playerState.collect { state ->
                 cachedPlayerState = ShortKitBridge.playerStateString(state)
-                if (isActive) {
+                if (isActive && !isDragging) {
                     val params = Arguments.createMap().apply {
                         putString("surfaceId", surfaceId)
                         putString("playerState", cachedPlayerState)
@@ -417,7 +446,7 @@ class ReactOverlayHost(context: Context) : FrameLayout(context), FeedOverlay {
         scope.launch {
             player.isMuted.collect { muted ->
                 cachedIsMuted = muted
-                if (isActive) {
+                if (isActive && !isDragging) {
                     val params = Arguments.createMap().apply {
                         putString("surfaceId", surfaceId)
                         putBoolean("isMuted", cachedIsMuted)
@@ -431,7 +460,7 @@ class ReactOverlayHost(context: Context) : FrameLayout(context), FeedOverlay {
         scope.launch {
             player.playbackRate.collect { rate ->
                 cachedPlaybackRate = rate.toDouble()
-                if (isActive) {
+                if (isActive && !isDragging) {
                     val params = Arguments.createMap().apply {
                         putString("surfaceId", surfaceId)
                         putDouble("playbackRate", cachedPlaybackRate)
@@ -445,7 +474,7 @@ class ReactOverlayHost(context: Context) : FrameLayout(context), FeedOverlay {
         scope.launch {
             player.captionsEnabled.collect { enabled ->
                 cachedCaptionsEnabled = enabled
-                if (isActive) {
+                if (isActive && !isDragging) {
                     val params = Arguments.createMap().apply {
                         putString("surfaceId", surfaceId)
                         putBoolean("captionsEnabled", cachedCaptionsEnabled)
@@ -467,7 +496,7 @@ class ReactOverlayHost(context: Context) : FrameLayout(context), FeedOverlay {
                 } else {
                     null
                 }
-                if (isActive) {
+                if (isActive && !isDragging) {
                     val params = Arguments.createMap().apply {
                         putString("surfaceId", surfaceId)
                         val cueJson = cachedActiveCue?.toString()
@@ -488,7 +517,7 @@ class ReactOverlayHost(context: Context) : FrameLayout(context), FeedOverlay {
                 cachedCurrentTime = time.currentMs / 1000.0
                 cachedDuration = time.durationMs / 1000.0
                 cachedBuffered = time.bufferedMs / 1000.0
-                if (isActive) {
+                if (isActive && !isDragging) {
                     timeDirty = true
                 }
             }
@@ -504,6 +533,23 @@ class ReactOverlayHost(context: Context) : FrameLayout(context), FeedOverlay {
                     }.toString()
                     is FeedScrollPhase.Settled -> """{"phase":"settled"}"""
                 }
+                when (phase) {
+                    is FeedScrollPhase.Dragging -> {
+                        isDragging = true
+                        stopTimeCoalescing()
+                    }
+                    is FeedScrollPhase.Settled -> {
+                        val wasDragging = isDragging
+                        isDragging = false
+                        if (isActive) {
+                            startTimeCoalescing()
+                            if (wasDragging) {
+                                emitFullState()
+                                return@collect  // emitFullState includes feedScrollPhase
+                            }
+                        }
+                    }
+                }
                 if (isActive) {
                     val params = Arguments.createMap().apply {
                         putString("surfaceId", surfaceId)