@shortkitsdk/react-native 0.2.6 → 0.2.11

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

@@ -10,16 +10,14 @@ import android.view.ViewGroup
 import android.widget.FrameLayout
 import androidx.fragment.app.FragmentActivity
 import androidx.viewpager2.widget.ViewPager2
-import com.facebook.react.uimanager.util.ReactFindViewUtil
-import com.shortkit.ShortKitFeedFragment
+import com.shortkit.sdk.feed.ShortKitFeedFragment
 
 /**
  * Fabric native view that embeds [ShortKitFeedFragment] using Android
  * Fragment transactions. Props are set by [ShortKitFeedViewManager].
  *
- * Also tracks the feed's scroll offset via [ViewPager2.OnPageChangeCallback]
- * and applies native translation transforms to the sibling RN overlay views
- * so they move with the active cell during swipe transitions.
+ * The native SDK owns overlay lifecycle via [ReactOverlayHost] and
+ * [ReactCarouselOverlayHost] — this view is purely a fragment container.
  *
  * Android equivalent of iOS `ShortKitFeedView.swift`.
  */
@@ -30,44 +28,51 @@ class ShortKitFeedView(context: Context) : FrameLayout(context) {
     // -----------------------------------------------------------------------
 
     var config: String? = null
-    var overlayType: String? = null
+    var feedId: String? = null
+    var startAtItemId: String? = null
+    var preloadId: String? = null
 
     // -----------------------------------------------------------------------
     // Fragment management
     // -----------------------------------------------------------------------
 
     private var feedFragment: ShortKitFeedFragment? = null
+    private val fragmentContainer: FrameLayout
     private var fragmentContainerId: Int = View.generateViewId()
     private val handler = Handler(Looper.getMainLooper())
 
     init {
-        id = fragmentContainerId
+        // 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.
+        fragmentContainer = FrameLayout(context).apply {
+            id = fragmentContainerId
+            layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
+        }
+        addView(fragmentContainer)
     }
 
     // -----------------------------------------------------------------------
-    // Scroll tracking
+    // Fabric layout workarounds
     // -----------------------------------------------------------------------
 
-    private var viewPager: ViewPager2? = null
-    private var pageChangeCallback: ViewPager2.OnPageChangeCallback? = null
-
-    /** Video overlay for the currently active cell (nativeID="overlay-current"). */
-    private var currentOverlayView: View? = null
-
-    /** Video overlay for the upcoming cell (nativeID="overlay-next"). */
-    private var nextOverlayView: View? = null
-
-    /** Carousel overlay for the currently active cell (nativeID="carousel-overlay-current"). */
-    private var currentCarouselOverlayView: View? = null
-
-    /** Carousel overlay for the upcoming cell (nativeID="carousel-overlay-next"). */
-    private var nextCarouselOverlayView: View? = null
+    /**
+     * Fabric intercepts requestLayout() and doesn't propagate measure/layout
+     * to programmatically-added children. Override to schedule a manual pass.
+     */
+    override fun requestLayout() {
+        super.requestLayout()
+        @Suppress("UNNECESSARY_SAFE_CALL")
+        handler?.post(layoutRunnable)
+    }
 
-    /** The page index used for overlay transform calculations. */
-    private var currentPage: Int = 0
+    private val layoutRunnable = Runnable {
+        measure(
+            MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
+            MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY)
+        )
+        layout(left, top, right, bottom)
+    }
 
-    /** Deferred page update to avoid flashing stale metadata. */
-    private var pageUpdateRunnable: Runnable? = null
 
     // -----------------------------------------------------------------------
     // Lifecycle
@@ -79,7 +84,9 @@ class ShortKitFeedView(context: Context) : FrameLayout(context) {
     }
 
     override fun onDetachedFromWindow() {
-        teardownScrollTracking()
+        synchronized(ShortKitBridge.staticPendingFeedViews) {
+            ShortKitBridge.staticPendingFeedViews.remove(this)
+        }
         removeFeedFragment()
         super.onDetachedFromWindow()
     }
@@ -88,36 +95,78 @@ class ShortKitFeedView(context: Context) : FrameLayout(context) {
     // Fragment containment
     // -----------------------------------------------------------------------
 
-    private fun embedFeedFragmentIfNeeded() {
+    internal fun embedFeedFragmentIfNeeded() {
         if (feedFragment != null) return
 
-        val sdk = ShortKitModule.shared?.sdk ?: run {
-            Log.w(TAG, "ShortKit SDK not initialized. Call ShortKitModule.initialize() first.")
+        val sdk = ShortKitBridge.shared?.sdk ?: run {
+            synchronized(ShortKitBridge.staticPendingFeedViews) {
+                ShortKitBridge.staticPendingFeedViews.add(this)
+            }
             return
         }
 
-        val activity = getReactActivity() ?: run {
-            Log.w(TAG, "Could not find hosting Activity.")
-            return
+        val activity = getReactActivity() ?: return
+
+        val feedConfig = ShortKitBridge.parseFeedConfig(config ?: "{}", context)
+
+        preloadId?.let { id ->
+            ShortKitBridge.shared?.consumePreload(id)
         }
 
-        val fragment = ShortKitFeedFragment.newInstance(sdk)
+        val fragment = ShortKitFeedFragment.newInstance(sdk, feedConfig)
 
         try {
             activity.supportFragmentManager
                 .beginTransaction()
                 .replace(fragmentContainerId, fragment)
                 .commitNowAllowingStateLoss()
-            this.feedFragment = fragment  // Only assign after successful commit
-            setupScrollTracking(fragment)
+            this.feedFragment = fragment
+
+            // Force an immediate layout pass on the container so the fragment's
+            // ViewPager2/RecyclerView gets measured and can create cells.
+            fragmentContainer.measure(
+                MeasureSpec.makeMeasureSpec(measuredWidth, MeasureSpec.EXACTLY),
+                MeasureSpec.makeMeasureSpec(measuredHeight, MeasureSpec.EXACTLY)
+            )
+            fragmentContainer.layout(0, 0, measuredWidth, measuredHeight)
+
+            // 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)
+
+            feedId?.let { id ->
+                ShortKitBridge.shared?.registerFeed(id)
+                ShortKitBridge.shared?.registerFeedFragment(id, fragment)
+            }
         } catch (e: Exception) {
             Log.e(TAG, "Failed to embed feed fragment", e)
         }
     }
 
     private fun removeFeedFragment() {
+        feedId?.let { id ->
+            ShortKitBridge.shared?.unregisterFeed(id)
+            ShortKitBridge.shared?.unregisterFeedFragment(id)
+        }
         val fragment = feedFragment ?: return
-        feedFragment = null  // Clear immediately to prevent leaks on early return
+        feedFragment = null
 
         try {
             val activity = getReactActivity() ?: return
@@ -126,192 +175,16 @@ class ShortKitFeedView(context: Context) : FrameLayout(context) {
                 .remove(fragment)
                 .commitNowAllowingStateLoss()
         } catch (e: IllegalStateException) {
-            // Expected during Activity teardown — fragment already being destroyed
+            // Expected during Activity teardown
         } catch (e: Exception) {
             Log.e(TAG, "Unexpected error removing feed fragment", e)
         }
     }
 
     // -----------------------------------------------------------------------
-    // Scroll tracking
+    // Helpers
     // -----------------------------------------------------------------------
 
-    private fun setupScrollTracking(fragment: ShortKitFeedFragment) {
-        val pager = findViewPager2(fragment.view ?: return) ?: run {
-            Log.w(TAG, "Could not find ViewPager2 in feed fragment hierarchy.")
-            return
-        }
-        viewPager = pager
-
-        val callback = object : ViewPager2.OnPageChangeCallback() {
-            override fun onPageScrolled(
-                position: Int,
-                positionOffset: Float,
-                positionOffsetPixels: Int
-            ) {
-                handleScrollOffset(position, positionOffset, positionOffsetPixels)
-            }
-        }
-        pageChangeCallback = callback
-        pager.registerOnPageChangeCallback(callback)
-    }
-
-    private fun teardownScrollTracking() {
-        pageUpdateRunnable?.let { handler.removeCallbacks(it) }
-        pageUpdateRunnable = null
-        pageChangeCallback?.let { viewPager?.unregisterOnPageChangeCallback(it) }
-        pageChangeCallback = null
-        viewPager = null
-        currentOverlayView?.translationY = 0f
-        nextOverlayView?.translationY = 0f
-        currentCarouselOverlayView?.translationY = 0f
-        nextCarouselOverlayView?.translationY = 0f
-        currentOverlayView = null
-        nextOverlayView = null
-        currentCarouselOverlayView = null
-        nextCarouselOverlayView = null
-    }
-
-    private fun handleScrollOffset(
-        position: Int,
-        positionOffset: Float,
-        positionOffsetPixels: Int
-    ) {
-        val cellHeight = height.toFloat()
-        if (cellHeight <= 0) return
-
-        // Detect page change, but DEFER updating currentPage.
-        //
-        // Why: when the scroll settles on a new page, overlay-current still
-        // shows the OLD page's metadata (React hasn't processed OVERLAY_ACTIVATE
-        // yet). If we update currentPage immediately, delta snaps to 0 and
-        // overlay-current becomes visible with stale data.
-        //
-        // By deferring ~80ms, overlay-next (which already shows the correct
-        // data via NextOverlayProvider) stays visible at y=0 while React
-        // processes the state update.
-        if (positionOffset == 0f) {
-            if (position != currentPage && pageUpdateRunnable == null) {
-                val targetPage = position
-                val runnable = Runnable {
-                    currentPage = targetPage
-                    pageUpdateRunnable = null
-                    // Reapply overlay transforms now that currentPage is updated.
-                    // Without this, overlay-next (static NextOverlayProvider state)
-                    // stays visible at y=0 while overlay-current (live state) stays
-                    // hidden — no scroll event fires to trigger handleScrollOffset.
-                    val h = height.toFloat()
-                    currentOverlayView?.translationY = 0f
-                    nextOverlayView?.translationY = h
-                    currentCarouselOverlayView?.translationY = 0f
-                    nextCarouselOverlayView?.translationY = h
-                }
-                pageUpdateRunnable = runnable
-                handler.postDelayed(runnable, 80)
-            }
-        } else if (pageUpdateRunnable != null) {
-            // User is scrolling again — apply pending update immediately
-            // so transforms stay aligned for the new gesture.
-            handler.removeCallbacks(pageUpdateRunnable!!)
-            pageUpdateRunnable = null
-            currentPage = position
-        }
-
-        // positionOffset is 0.0 when settled, approaches 1.0 during forward scroll.
-        // position is the index of the page currently filling most of the screen.
-        val delta: Float = if (position >= currentPage) {
-            // Forward scroll (or idle)
-            positionOffsetPixels.toFloat()
-        } else {
-            // Backward scroll: position dropped below currentPage
-            -(cellHeight - positionOffsetPixels.toFloat())
-        }
-
-        // Find the overlay views if not cached
-        if (currentOverlayView == null || nextOverlayView == null) {
-            findOverlayViews()
-        }
-        if (currentCarouselOverlayView == null || nextCarouselOverlayView == null) {
-            findCarouselOverlayViews()
-        }
-
-        // Current overlays follow the active cell
-        currentOverlayView?.translationY = -delta
-        currentCarouselOverlayView?.translationY = -delta
-
-        // Next overlays: positioned one page ahead in the scroll direction
-        if (delta >= 0) {
-            // Forward scroll (or idle): next cell is below
-            val nextY = cellHeight - delta
-            nextOverlayView?.translationY = nextY
-            nextCarouselOverlayView?.translationY = nextY
-        } else {
-            // Backward scroll: next cell is above
-            val nextY = -cellHeight - delta
-            nextOverlayView?.translationY = nextY
-            nextCarouselOverlayView?.translationY = nextY
-        }
-    }
-
-    /**
-     * Find the sibling RN overlay views by nativeID.
-     *
-     * In Fabric interop, this view may be wrapped in an intermediate
-     * ViewGroup, so `getParent()` may not be the React `<View>` container
-     * from ShortKitFeed.tsx. We walk up the ancestor chain until we find
-     * the overlays.
-     */
-    private fun findOverlayViews() {
-        var ancestor = parent as? ViewGroup ?: return
-        while (true) {
-            for (i in 0 until ancestor.childCount) {
-                val child = ancestor.getChildAt(i)
-                if (child === this || isOwnAncestor(child)) continue
-
-                if (currentOverlayView == null) {
-                    currentOverlayView = ReactFindViewUtil.findView(child, "overlay-current")
-                }
-                if (nextOverlayView == null) {
-                    nextOverlayView = ReactFindViewUtil.findView(child, "overlay-next")
-                }
-            }
-            if (currentOverlayView != null && nextOverlayView != null) return
-            ancestor = ancestor.parent as? ViewGroup ?: return
-        }
-    }
-
-    /**
-     * Find the sibling RN carousel overlay views by nativeID.
-     */
-    private fun findCarouselOverlayViews() {
-        var ancestor = parent as? ViewGroup ?: return
-        while (true) {
-            for (i in 0 until ancestor.childCount) {
-                val child = ancestor.getChildAt(i)
-                if (child === this || isOwnAncestor(child)) continue
-
-                if (currentCarouselOverlayView == null) {
-                    currentCarouselOverlayView = ReactFindViewUtil.findView(child, "carousel-overlay-current")
-                }
-                if (nextCarouselOverlayView == null) {
-                    nextCarouselOverlayView = ReactFindViewUtil.findView(child, "carousel-overlay-next")
-                }
-            }
-            if (currentCarouselOverlayView != null && nextCarouselOverlayView != null) return
-            ancestor = ancestor.parent as? ViewGroup ?: return
-        }
-    }
-
-    /** Check if the given view is an ancestor of this view. */
-    private fun isOwnAncestor(view: View): Boolean {
-        var current: ViewParent? = parent
-        while (current != null) {
-            if (current === view) return true
-            current = current.parent
-        }
-        return false
-    }
-
     /** Recursively find the first [ViewPager2] in a view hierarchy. */
     private fun findViewPager2(view: View): ViewPager2? {
         if (view is ViewPager2) return view
@@ -323,13 +196,8 @@ class ShortKitFeedView(context: Context) : FrameLayout(context) {
         return null
     }
 
-    // -----------------------------------------------------------------------
-    // Helpers
-    // -----------------------------------------------------------------------
-
     /**
      * Walk the context wrapper chain to find the hosting [FragmentActivity].
-     * React Native's [ThemedReactContext] wraps the Activity, so we unwrap it.
      */
     private fun getReactActivity(): FragmentActivity? {
         var ctx = context

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

@@ -15,16 +15,25 @@ class ShortKitFeedViewManager : SimpleViewManager<ShortKitFeedView>() {
         return ShortKitFeedView(context)
     }
 
+    @ReactProp(name = "feedId")
+    fun setFeedId(view: ShortKitFeedView, feedId: String?) {
+        view.feedId = feedId
+    }
+
     @ReactProp(name = "config")
     fun setConfig(view: ShortKitFeedView, config: String?) {
         view.config = config
     }
 
-    @ReactProp(name = "overlayType", defaultString = "none")
-    fun setOverlayType(view: ShortKitFeedView, overlayType: String?) {
-        view.overlayType = overlayType
+    @ReactProp(name = "startAtItemId")
+    fun setStartAtItemId(view: ShortKitFeedView, startAtItemId: String?) {
+        view.startAtItemId = startAtItemId
     }
 
+    @ReactProp(name = "preloadId")
+    fun setPreloadId(view: ShortKitFeedView, preloadId: String?) {
+        view.preloadId = preloadId
+    }
 
     companion object {
         const val REACT_CLASS = "ShortKitFeedView"