@shortkitsdk/react-native 0.2.11 → 0.2.12

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

@@ -24,8 +24,10 @@ 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.VideoOverlayMode
+import com.shortkit.sdk.feed.FeedPreload
 import com.shortkit.sdk.feed.ShortKitFeedFragment
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -74,6 +76,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,17 +141,23 @@ 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 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,
@@ -159,8 +168,10 @@ class ShortKitBridge(
                     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 +202,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 +218,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
             }
         }
@@ -378,7 +395,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 +467,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 +510,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 +574,7 @@ class ShortKitBridge(
     // Preload handle management
     // ------------------------------------------------------------------
 
-    fun consumePreload(id: String): Any? {
+    fun consumePreload(id: String): FeedPreload? {
         return preloadHandles.remove(id)
     }
 
@@ -714,13 +744,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 +1006,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"
     }

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

@@ -205,13 +205,13 @@ class ShortKitModule(reactContext: ReactApplicationContext) :
     }
 
     @ReactMethod
-    override fun preloadFeed(configJSON: String, promise: Promise) {
+    override fun preloadFeed(configJSON: String, itemsJSON: String?, promise: Promise) {
         val b = bridge
         if (b == null) {
             promise.resolve("")
             return
         }
-        b.preloadFeed(configJSON) { result -> promise.resolve(result) }
+        b.preloadFeed(configJSON, itemsJSON) { result -> promise.resolve(result) }
     }
 
     // -----------------------------------------------------------------
@@ -238,15 +238,48 @@ class ShortKitModule(reactContext: ReactApplicationContext) :
     // -----------------------------------------------------------------
 
     private fun sendEvent(name: String, params: WritableMap) {
-        // NOTE: In RN 0.78 new architecture, the codegen EventEmitter<T> does
-        // NOT call the legacy addListener/removeListeners methods, so the
-        // hasListeners flag stays false forever. We skip the guard and always
-        // emit. The try/catch handles the case where the catalyst instance
-        // is torn down.
+        // Use the codegen-generated emitOn* methods which route through
+        // mEventEmitterCallback (JSI direct channel). The legacy
+        // DeviceEventManagerModule.RCTDeviceEventEmitter path does NOT
+        // reach codegen EventEmitter<T> subscribers in RN 0.78 new arch.
         try {
-            reactApplicationContext
-                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-                .emit(name, params)
+            when (name) {
+                "onPlayerStateChanged" -> emitOnPlayerStateChanged(params)
+                "onCurrentItemChanged" -> emitOnCurrentItemChanged(params)
+                "onTimeUpdate" -> emitOnTimeUpdate(params)
+                "onMutedChanged" -> emitOnMutedChanged(params)
+                "onPlaybackRateChanged" -> emitOnPlaybackRateChanged(params)
+                "onCaptionsEnabledChanged" -> emitOnCaptionsEnabledChanged(params)
+                "onActiveCaptionTrackChanged" -> emitOnActiveCaptionTrackChanged(params)
+                "onActiveCueChanged" -> emitOnActiveCueChanged(params)
+                "onDidLoop" -> emitOnDidLoop(params)
+                "onFeedTransition" -> emitOnFeedTransition(params)
+                "onFeedScrollPhase" -> emitOnFeedScrollPhase(params)
+                "onFormatChange" -> emitOnFormatChange(params)
+                "onPrefetchedAheadCountChanged" -> emitOnPrefetchedAheadCountChanged(params)
+                "onRemainingContentCountChanged" -> emitOnRemainingContentCountChanged(params)
+                "onSurveyResponse" -> emitOnSurveyResponse(params)
+                "onContentTapped" -> emitOnContentTapped(params)
+                "onDismiss" -> emitOnDismiss(params)
+                "onRefreshRequested" -> emitOnRefreshRequested(params)
+                "onDidFetchContentItems" -> emitOnDidFetchContentItems(params)
+                "onFeedReady" -> emitOnFeedReady(params)
+                "onOverlayActiveChanged" -> emitOnOverlayActiveChanged(params)
+                "onOverlayPlayerStateChanged" -> emitOnOverlayPlayerStateChanged(params)
+                "onOverlayMutedChanged" -> emitOnOverlayMutedChanged(params)
+                "onOverlayPlaybackRateChanged" -> emitOnOverlayPlaybackRateChanged(params)
+                "onOverlayCaptionsEnabledChanged" -> emitOnOverlayCaptionsEnabledChanged(params)
+                "onOverlayActiveCueChanged" -> emitOnOverlayActiveCueChanged(params)
+                "onOverlayFeedScrollPhaseChanged" -> emitOnOverlayFeedScrollPhaseChanged(params)
+                "onOverlayTimeUpdate" -> emitOnOverlayTimeUpdate(params)
+                "onOverlayFullState" -> emitOnOverlayFullState(params)
+                else -> {
+                    android.util.Log.w("SK:Module", "sendEvent: unknown event name '$name', using legacy emitter")
+                    reactApplicationContext
+                        .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                        .emit(name, params)
+                }
+            }
         } catch (e: Exception) {
             android.util.Log.e("SK:Module", "sendEvent($name) EXCEPTION: ${e.message}", e)
         }

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

@@ -1,6 +1,7 @@
 package com.shortkit.reactnative
 
 import android.content.Context
+import android.view.MotionEvent
 import android.widget.FrameLayout
 import com.shortkit.sdk.config.PlayerClickAction
 import com.shortkit.sdk.config.PlayerConfig
@@ -42,6 +43,14 @@ class ShortKitPlayerNativeView(context: Context) : FrameLayout(context) {
             applyActive()
         }
 
+    override fun onInterceptTouchEvent(ev: MotionEvent): Boolean {
+        return super.onInterceptTouchEvent(ev)
+    }
+
+    override fun dispatchTouchEvent(ev: MotionEvent): Boolean {
+        return super.dispatchTouchEvent(ev)
+    }
+
     override fun onAttachedToWindow() {
         super.onAttachedToWindow()
         rebuildIfNeeded()

package/ios/ReactOverlayHost.swift

@@ -165,41 +165,27 @@ import ShortKitSDK
     /// Emit all cached state as individual events. Called from activatePlayback()
     /// (deferred) and can be called whenever we need to synchronize JS state.
     private func emitFullState() {
-        bridge?.emit("onOverlayActiveChanged", body: [
-            "surfaceId": surfaceId, "isActive": true
-        ])
-        bridge?.emit("onOverlayPlayerStateChanged", body: [
-            "surfaceId": surfaceId, "playerState": cachedPlayerState
-        ])
-        bridge?.emit("onOverlayMutedChanged", body: [
-            "surfaceId": surfaceId, "isMuted": cachedIsMuted
-        ])
-        bridge?.emit("onOverlayPlaybackRateChanged", body: [
-            "surfaceId": surfaceId, "playbackRate": cachedPlaybackRate
-        ])
-        bridge?.emit("onOverlayCaptionsEnabledChanged", body: [
-            "surfaceId": surfaceId, "captionsEnabled": cachedCaptionsEnabled
-        ])
+        var body: [String: Any] = [
+            "surfaceId": surfaceId,
+            "isActive": true,
+            "playerState": cachedPlayerState,
+            "isMuted": cachedIsMuted,
+            "playbackRate": cachedPlaybackRate,
+            "captionsEnabled": cachedCaptionsEnabled,
+        ]
         if let cue = cachedActiveCue,
            let cueData = try? JSONSerialization.data(withJSONObject: cue),
            let cueJson = String(data: cueData, encoding: .utf8) {
-            bridge?.emit("onOverlayActiveCueChanged", body: [
-                "surfaceId": surfaceId, "activeCue": cueJson
-            ])
+            body["activeCue"] = cueJson
         } else {
-            bridge?.emit("onOverlayActiveCueChanged", body: [
-                "surfaceId": surfaceId, "activeCue": NSNull()
-            ])
+            body["activeCue"] = NSNull()
         }
         if let scrollPhase = cachedFeedScrollPhase {
-            bridge?.emit("onOverlayFeedScrollPhaseChanged", body: [
-                "surfaceId": surfaceId, "feedScrollPhase": scrollPhase
-            ])
+            body["feedScrollPhase"] = scrollPhase
         } else {
-            bridge?.emit("onOverlayFeedScrollPhaseChanged", body: [
-                "surfaceId": surfaceId, "feedScrollPhase": NSNull()
-            ])
+            body["feedScrollPhase"] = NSNull()
         }
+        bridge?.emit("onOverlayFullState", body: body)
     }
 
     // MARK: - Surface Creation