@shortkitsdk/react-native 0.2.11 → 0.2.14

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
@@ -24,8 +25,11 @@ import com.shortkit.sdk.config.CarouselOverlayMode
 import com.shortkit.sdk.config.FeedConfig
 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
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -74,6 +78,7 @@ class ShortKitBridge(
             return try {
                 val obj = JSONObject().apply {
                     put("id", item.id)
+                    item.playbackId?.let { put("playbackId", it) }
                     put("title", item.title)
                     item.description?.let { put("description", it) }
                     put("duration", item.duration)
@@ -138,29 +143,40 @@ class ShortKitBridge(
             return try {
                 val obj = JSONObject(json)
 
+                val overlayRaw = obj.optString("overlay", null)
+
                 val feedHeight = parseFeedHeight(obj.optString("feedHeight", null))
                 val muteOnStart = obj.optBoolean("muteOnStart", true)
-                val videoOverlay = parseVideoOverlay(obj.optString("overlay", null), context)
+                val videoOverlay = parseVideoOverlay(overlayRaw, context)
 
                 val feedSourceStr = obj.optString("feedSource", "algorithmic")
                 val feedSource = if (feedSourceStr == "custom") FeedSource.CUSTOM else FeedSource.ALGORITHMIC
 
-                val carouselOverlay = parseCarouselOverlay(obj.optString("carouselOverlay", null), context)
+                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()) }
 
+                val scrollAxisStr = obj.optString("scrollAxis", "vertical")
+                val scrollAxis = if (scrollAxisStr == "horizontal") ScrollAxis.Horizontal else ScrollAxis.Vertical
+
                 FeedConfig(
                     feedHeight = feedHeight,
                     videoOverlay = videoOverlay,
                     carouselOverlay = carouselOverlay,
+                    videoCarouselOverlay = videoCarouselOverlay,
                     surveyOverlay = SurveyOverlayMode.None,
                     adOverlay = AdOverlayMode.None,
                     muteOnStart = muteOnStart,
                     autoplay = autoplay,
                     feedSource = feedSource,
                     filter = filter,
+                    scrollAxis = scrollAxis,
                 )
-            } catch (_: Exception) {
+            } catch (e: Exception) {
+                android.util.Log.e("SK:Bridge", "parseFeedConfig: EXCEPTION parsing config, returning default. json=${json.take(300)}", e)
                 FeedConfig()
             }
         }
@@ -191,7 +207,9 @@ class ShortKitBridge(
          * - `"{\"type\":\"custom\"}"` -> Custom with ReactOverlayHost factory
          */
         private fun parseVideoOverlay(json: String?, context: android.content.Context?): VideoOverlayMode {
-            if (json.isNullOrEmpty()) return VideoOverlayMode.None
+            if (json.isNullOrEmpty()) {
+                return VideoOverlayMode.None
+            }
             return try {
                 val parsed = json.trim()
 
@@ -205,14 +223,18 @@ class ShortKitBridge(
                     JSONObject(parsed)
                 }
 
-                if (inner.optString("type") == "custom" && context != null) {
-                    val name = inner.optString("name", "Default")
+                val type = inner.optString("type")
+                val name = inner.optString("name", "Default")
+
+                if (type == "custom" && context != null) {
                     val ctx = context.applicationContext
                     VideoOverlayMode.Custom { ReactOverlayHost(ctx).apply { overlayName = name } }
                 } else {
+                    android.util.Log.w("SK:Bridge", "parseVideoOverlay: → None (type='$type' context=${if (context != null) "OK" else "NULL"})")
                     VideoOverlayMode.None
                 }
-            } catch (_: Exception) {
+            } catch (e: Exception) {
+                android.util.Log.e("SK:Bridge", "parseVideoOverlay: EXCEPTION → None. json=${json.take(200)}", e)
                 VideoOverlayMode.None
             }
         }
@@ -256,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.
@@ -299,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 }
@@ -332,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) {
@@ -378,7 +478,7 @@ class ShortKitBridge(
     private var scope: CoroutineScope? = null
 
     /** Preload handles keyed by UUID, consumed by feed views via preloadId prop. */
-    var preloadHandles = mutableMapOf<String, Any>()
+    var preloadHandles = mutableMapOf<String, FeedPreload>()
         private set
 
     // ------------------------------------------------------------------
@@ -450,8 +550,11 @@ class ShortKitBridge(
             pending = staticPendingFeedViews.toList()
             staticPendingFeedViews.clear()
         }
+        val mainHandler = Handler(Looper.getMainLooper())
         for (view in pending) {
-            view.embedFeedFragmentIfNeeded()
+            mainHandler.post {
+                if (view.isAttachedToWindow) view.embedFeedFragmentIfNeeded()
+            }
         }
     }
 
@@ -490,19 +593,29 @@ class ShortKitBridge(
             }
             emitEventOnMain("onRemainingContentCountChanged", params)
         }
+        fragment.onFeedReady = {
+            val params = Arguments.createMap().apply {
+                putString("feedId", id)
+            }
+            emitEventOnMain("onFeedReady", params)
+        }
 
-        // Replay buffered operations on the next main-thread tick
+        // Replay buffered operations after the fragment's view is created.
+        // commitNowAllowingStateLoss triggers onCreate but onViewCreated
+        // (which sets up customFeedController) runs on a later main-thread
+        // tick. A single post isn't enough — use postDelayed to ensure the
+        // fragment's view lifecycle has completed.
         val ops: List<(ShortKitFeedFragment) -> Unit>?
         synchronized(pendingOpsLock) {
             ops = pendingOps.remove(id)?.toList()
         }
         if (ops != null) {
-            Handler(Looper.getMainLooper()).post {
-                val frag = feedRegistry[id]?.get() ?: return@post
+            Handler(Looper.getMainLooper()).postDelayed({
+                val frag = feedRegistry[id]?.get() ?: return@postDelayed
                 for (op in ops) {
                     op(frag)
                 }
-            }
+            }, 100)
         }
     }
 
@@ -544,7 +657,7 @@ class ShortKitBridge(
     // Preload handle management
     // ------------------------------------------------------------------
 
-    fun consumePreload(id: String): Any? {
+    fun consumePreload(id: String): FeedPreload? {
         return preloadHandles.remove(id)
     }
 
@@ -714,13 +827,37 @@ class ShortKitBridge(
     // Preload feed
     // ------------------------------------------------------------------
 
-    fun preloadFeed(configJSON: String, callback: (String) -> Unit) {
+    fun preloadFeed(configJSON: String, itemsJSON: String?, callback: (String) -> Unit) {
         val sdk = shortKit
         if (sdk == null) {
             callback("")
             return
         }
-        val preload = sdk.preloadFeed(filter = configJSON)
+        val config = parseFeedConfig(configJSON)
+        if (config.feedSource == FeedSource.CUSTOM) {
+            if (itemsJSON == null) {
+                android.util.Log.w("ShortKit", "preloadFeed called with feedSource=CUSTOM but no items")
+                callback("")
+                return
+            }
+            val items = parseFeedInputs(itemsJSON)
+            if (items == null) {
+                callback("")
+                return
+            }
+            val preload = sdk.preloadFeed(items = items)
+            val uuid = java.util.UUID.randomUUID().toString()
+            preloadHandles[uuid] = preload
+            callback(uuid)
+            return
+        }
+        val filterJSON = config.filter?.let { org.json.JSONObject().apply {
+            it.tags?.let { tags -> put("tags", org.json.JSONArray(tags)) }
+            it.section?.let { s -> put("section", s) }
+            it.author?.let { a -> put("author", a) }
+            it.contentType?.let { ct -> put("contentType", ct) }
+        }.toString() }
+        val preload = sdk.preloadFeed(filter = filterJSON)
         val uuid = java.util.UUID.randomUUID().toString()
         preloadHandles[uuid] = preload
         callback(uuid)
@@ -952,16 +1089,7 @@ class ShortKitBridge(
             }
         }
 
-        // Remaining content count
-        newScope.launch {
-            player.remainingContentCount.collect { count ->
-                val params = Arguments.createMap().apply {
-                    putString("feedId", "") // Global fallback — per-feed routing via fragment callback
-                    putInt("count", count)
-                }
-                emitEvent.invoke("onRemainingContentCountChanged", params)
-            }
-        }
+        // Remaining content count — handled per-feed via fragment.onRemainingContentCountChange callback
 
         // Feed scroll phase
         newScope.launch {

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

@@ -9,7 +9,6 @@ import android.view.View
 import android.view.ViewGroup
 import android.widget.FrameLayout
 import androidx.fragment.app.FragmentActivity
-import androidx.viewpager2.widget.ViewPager2
 import com.shortkit.sdk.feed.ShortKitFeedFragment
 
 /**
@@ -41,6 +40,11 @@ class ShortKitFeedView(context: Context) : FrameLayout(context) {
     private var fragmentContainerId: Int = View.generateViewId()
     private val handler = Handler(Looper.getMainLooper())
 
+    // The React Native-assigned size. Stored so we can re-apply it after the
+    // SDK's forceLayoutIfNeeded potentially re-measures to full-screen size.
+    private var rnWidth: Int = 0
+    private var rnHeight: Int = 0
+
     init {
         // Use a child FrameLayout as the fragment container. Fabric overrides
         // this view's own id, so we can't use it as the fragment container.
@@ -73,6 +77,42 @@ class ShortKitFeedView(context: Context) : FrameLayout(context) {
         layout(left, top, right, bottom)
     }
 
+    /**
+     * Re-apply the React Native-assigned size to the fragment container and
+     * all descendants (fragment root, VP, RV). The SDK's forceLayoutIfNeeded
+     * may have sized them to the full activity height instead.
+     */
+    private val constrainRunnable = Runnable {
+        val w = rnWidth
+        val h = rnHeight
+        if (w == 0 || h == 0) return@Runnable
+
+        val fragView = feedFragment?.view ?: return@Runnable
+        val wSpec = MeasureSpec.makeMeasureSpec(w, MeasureSpec.EXACTLY)
+        val hSpec = MeasureSpec.makeMeasureSpec(h, MeasureSpec.EXACTLY)
+
+        // Re-pin container
+        fragmentContainer.measure(wSpec, hSpec)
+        fragmentContainer.layout(0, 0, w, h)
+
+        // Re-pin fragment root, VP, and RV if they got the wrong size
+        if (fragView.height != h) {
+            fragView.measure(wSpec, hSpec)
+            fragView.layout(0, 0, w, h)
+        }
+
+        val vp = findViewPager2(fragView)
+        if (vp != null && vp.height != h) {
+            vp.measure(wSpec, hSpec)
+            vp.layout(0, 0, w, h)
+            val rv = vp.getChildAt(0) as? ViewGroup
+            if (rv != null) {
+                rv.measure(wSpec, hSpec)
+                rv.layout(0, 0, w, h)
+            }
+        }
+    }
+
 
     // -----------------------------------------------------------------------
     // Lifecycle
@@ -80,14 +120,21 @@ class ShortKitFeedView(context: Context) : FrameLayout(context) {
 
     override fun onAttachedToWindow() {
         super.onAttachedToWindow()
-        embedFeedFragmentIfNeeded()
+        // Defer to the next message-loop tick. onAttachedToWindow can fire
+        // during a parent fragment transaction (e.g. react-native-screens
+        // ScreenStack.onUpdate), and FragmentManager forbids nested
+        // commitNow calls. Posting ensures we run after the outer
+        // transaction completes — still before the first draw pass.
+        handler.post {
+            if (isAttachedToWindow) embedFeedFragmentIfNeeded()
+        }
     }
 
     override fun onDetachedFromWindow() {
         synchronized(ShortKitBridge.staticPendingFeedViews) {
             ShortKitBridge.staticPendingFeedViews.remove(this)
         }
-        removeFeedFragment()
+        suspendFeedFragment()
         super.onDetachedFromWindow()
     }
 
@@ -96,7 +143,35 @@ class ShortKitFeedView(context: Context) : FrameLayout(context) {
     // -----------------------------------------------------------------------
 
     internal fun embedFeedFragmentIfNeeded() {
-        if (feedFragment != null) return
+        val activity = getReactActivity()
+        if (activity == null) {
+            Log.e(TAG, "embedFeedFragment: FragmentActivity not found in context chain")
+            return
+        }
+
+        // Show a hidden fragment (e.g. returning to this tab).
+        // Using hide()/show() instead of detach()/attach() preserves the
+        // entire view hierarchy (ViewPager, RecyclerView, player surface)
+        // so there is zero flicker — matching iOS behavior exactly.
+        val existingFragment = feedFragment
+        if (existingFragment != null) {
+            if (existingFragment.isHidden) {
+                try {
+                    activity.supportFragmentManager
+                        .beginTransaction()
+                        .show(existingFragment)
+                        .commitNowAllowingStateLoss()
+                    existingFragment.activate()
+                } catch (e: Exception) {
+                    Log.e(TAG, "Failed to show feed fragment", e)
+                }
+            }
+            feedId?.let { id ->
+                ShortKitBridge.shared?.registerFeed(id)
+                ShortKitBridge.shared?.registerFeedFragment(id, existingFragment)
+            }
+            return
+        }
 
         val sdk = ShortKitBridge.shared?.sdk ?: run {
             synchronized(ShortKitBridge.staticPendingFeedViews) {
@@ -105,15 +180,16 @@ class ShortKitFeedView(context: Context) : FrameLayout(context) {
             return
         }
 
-        val activity = getReactActivity() ?: return
-
-        val feedConfig = ShortKitBridge.parseFeedConfig(config ?: "{}", context)
+        var feedConfig = ShortKitBridge.parseFeedConfig(config ?: "{}", context)
 
         preloadId?.let { id ->
-            ShortKitBridge.shared?.consumePreload(id)
+            val preload = ShortKitBridge.shared?.consumePreload(id)
+            if (preload != null) {
+                feedConfig = feedConfig.copy(preload = preload)
+            }
         }
 
-        val fragment = ShortKitFeedFragment.newInstance(sdk, feedConfig)
+        val fragment = ShortKitFeedFragment.newInstance(sdk, feedConfig, startAtItemId)
 
         try {
             activity.supportFragmentManager
@@ -122,34 +198,39 @@ class ShortKitFeedView(context: Context) : FrameLayout(context) {
                 .commitNowAllowingStateLoss()
             this.feedFragment = fragment
 
-            // Force an immediate layout pass on the container so the fragment's
-            // ViewPager2/RecyclerView gets measured and can create cells.
+            // View.generateViewId() can return IDs that collide with Fabric-
+            // managed views (e.g. ReactSurfaceView also gets id=1).  When that
+            // happens, FragmentManager.replace() places the fragment view in
+            // the wrong parent.  Detect and correct this by reparenting.
+            val fragView = fragment.view
+            val fragParent = fragView?.parent
+            if (fragParent != null && fragParent !== fragmentContainer) {
+                Log.w(TAG, "embedFeedFragment: reparenting — fragment placed in ${fragParent.javaClass.simpleName} due to ID collision")
+                (fragParent as? ViewGroup)?.removeView(fragView)
+                fragmentContainer.addView(fragView, LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT))
+            }
+
+            // Pin the fragment container to the React Native-assigned size.
+            // Without this, MATCH_PARENT causes Android to re-measure the
+            // container to the full activity size, and the SDK's deferred
+            // layout forcing picks up the wrong (full-screen) dimensions.
+            rnWidth = measuredWidth
+            rnHeight = measuredHeight
+            fragmentContainer.layoutParams = LayoutParams(measuredWidth, measuredHeight)
             fragmentContainer.measure(
                 MeasureSpec.makeMeasureSpec(measuredWidth, MeasureSpec.EXACTLY),
                 MeasureSpec.makeMeasureSpec(measuredHeight, MeasureSpec.EXACTLY)
             )
             fragmentContainer.layout(0, 0, measuredWidth, measuredHeight)
+            // Schedule a delayed re-pin: the SDK's forceLayoutIfNeeded will
+            // run when deferCellSetup exhausts retries (~3 post ticks later)
+            // and may size the VP/RV to the wrong dimensions. Re-apply our
+            // correct RN size after it runs.
+            handler.postDelayed(constrainRunnable, 500)
 
-            // The SDK's deferCellSetup retries only run during the current message
-            // loop iteration. Since Fabric suppresses layout, ViewPager2 won't
-            // have cells until our Choreographer callback forces layout on the
-            // next frame. Schedule a delayed nudge that runs after layout settles.
-            handler.postDelayed({
-                val fragView = feedFragment?.view
-                val vp = if (fragView != null) findViewPager2(fragView) else findViewPager2(fragmentContainer)
-                if (vp != null) {
-                    if (vp.width == 0 || vp.height == 0) {
-                        fragView?.measure(
-                            MeasureSpec.makeMeasureSpec(measuredWidth, MeasureSpec.EXACTLY),
-                            MeasureSpec.makeMeasureSpec(measuredHeight, MeasureSpec.EXACTLY)
-                        )
-                        fragView?.layout(0, 0, measuredWidth, measuredHeight)
-                    }
-                    if (vp.adapter != null && vp.adapter!!.itemCount > 0) {
-                        vp.setCurrentItem(vp.currentItem, false)
-                    }
-                }
-            }, 200)
+            if (measuredWidth == 0 || measuredHeight == 0) {
+                Log.w(TAG, "embedFeedFragment: WARNING — container is 0x0, overlays will be invisible. Check if parent has display:none or flex:0")
+            }
 
             feedId?.let { id ->
                 ShortKitBridge.shared?.registerFeed(id)
@@ -160,12 +241,56 @@ class ShortKitFeedView(context: Context) : FrameLayout(context) {
         }
     }
 
-    private fun removeFeedFragment() {
+    /**
+     * Hide the fragment without destroying its view hierarchy (mirrors iOS
+     * `suspendFeedViewController`). Using hide() instead of detach() keeps
+     * the ViewPager, RecyclerView, player surface, and all overlay views
+     * alive in memory — so returning to the tab is instant with no flicker.
+     */
+    private fun suspendFeedFragment() {
+        feedId?.let { id ->
+            ShortKitBridge.shared?.unregisterFeed(id)
+            ShortKitBridge.shared?.unregisterFeedFragment(id)
+        }
+        val fragment = feedFragment ?: return
+
+        try {
+            fragment.deactivate()
+            val activity = getReactActivity() ?: return
+            activity.supportFragmentManager
+                .beginTransaction()
+                .hide(fragment)
+                .commitNowAllowingStateLoss()
+        } catch (e: IllegalStateException) {
+            // Expected during Activity teardown — fall back to full destroy
+            feedFragment = null
+        } catch (e: Exception) {
+            Log.e(TAG, "Unexpected error suspending feed fragment", e)
+            feedFragment = null
+        }
+    }
+
+    /**
+     * Called by [ShortKitFeedViewManager.onDropViewInstance] when React
+     * unmounts the native view. Performs a full fragment teardown.
+     */
+    fun destroy() {
+        handler.removeCallbacks(constrainRunnable)
+        handler.removeCallbacks(layoutRunnable)
+        destroyFeedFragment()
+    }
+
+    /**
+     * Full teardown — removes the fragment from FragmentManager entirely.
+     * Called when the Fabric view is being destroyed (not just hidden).
+     */
+    private fun destroyFeedFragment() {
         feedId?.let { id ->
             ShortKitBridge.shared?.unregisterFeed(id)
             ShortKitBridge.shared?.unregisterFeedFragment(id)
         }
         val fragment = feedFragment ?: return
+        fragment.deactivate()
         feedFragment = null
 
         try {
@@ -185,9 +310,9 @@ class ShortKitFeedView(context: Context) : FrameLayout(context) {
     // Helpers
     // -----------------------------------------------------------------------
 
-    /** Recursively find the first [ViewPager2] in a view hierarchy. */
-    private fun findViewPager2(view: View): ViewPager2? {
-        if (view is ViewPager2) return view
+    /** Recursively find the first ViewPager2 in a view hierarchy. */
+    private fun findViewPager2(view: View): androidx.viewpager2.widget.ViewPager2? {
+        if (view is androidx.viewpager2.widget.ViewPager2) return view
         if (view is ViewGroup) {
             for (i in 0 until view.childCount) {
                 findViewPager2(view.getChildAt(i))?.let { return it }

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

@@ -35,6 +35,11 @@ class ShortKitFeedViewManager : SimpleViewManager<ShortKitFeedView>() {
         view.preloadId = preloadId
     }
 
+    override fun onDropViewInstance(view: ShortKitFeedView) {
+        view.destroy()
+        super.onDropViewInstance(view)
+    }
+
     companion object {
         const val REACT_CLASS = "ShortKitFeedView"
     }