@shortkitsdk/react-native 0.1.0

package/ShortKitReactNative.podspec

@@ -0,0 +1,19 @@
+require 'json'
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name         = "ShortKitReactNative"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = "https://github.com/shortkit/shortkit"
+  s.license      = package["license"]
+  s.author       = "ShortKit"
+  s.platforms    = { :ios => "16.0" }
+  s.source       = { :git => "https://github.com/shortkit/shortkit.git", :tag => "v#{s.version}" }
+  s.source_files = "ios/*.{h,m,mm,cpp,swift}"
+  s.requires_arc = true
+
+  s.dependency "ShortKit"
+
+  install_modules_dependencies(s)
+end

package/android/build.gradle.kts

@@ -0,0 +1,34 @@
+plugins {
+    id("com.android.library")
+    id("org.jetbrains.kotlin.android")
+    id("com.facebook.react")
+}
+
+android {
+    namespace = "com.shortkit.reactnative"
+    compileSdk = 35
+
+    defaultConfig {
+        minSdk = 24
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = "17"
+    }
+
+    sourceSets {
+        named("main") {
+            java.srcDirs("src/main/java")
+        }
+    }
+}
+
+dependencies {
+    implementation("com.facebook.react:react-android")
+    implementation("dev.shortkit:shortkit:0.1.0")
+}

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

@@ -0,0 +1,249 @@
+package com.shortkit.reactnative
+
+import android.content.Context
+import android.content.ContextWrapper
+import android.util.Log
+import android.view.View
+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
+
+/**
+ * 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.
+ *
+ * Android equivalent of iOS `ShortKitFeedView.swift`.
+ */
+class ShortKitFeedView(context: Context) : FrameLayout(context) {
+
+    // -----------------------------------------------------------------------
+    // Props (set by ViewManager)
+    // -----------------------------------------------------------------------
+
+    var config: String? = null
+    var overlayType: String? = null
+
+    // -----------------------------------------------------------------------
+    // Fragment management
+    // -----------------------------------------------------------------------
+
+    private var feedFragment: ShortKitFeedFragment? = null
+    private var fragmentContainerId: Int = View.generateViewId()
+
+    init {
+        id = fragmentContainerId
+    }
+
+    // -----------------------------------------------------------------------
+    // Scroll tracking
+    // -----------------------------------------------------------------------
+
+    private var viewPager: ViewPager2? = null
+    private var pageChangeCallback: ViewPager2.OnPageChangeCallback? = null
+
+    /** Overlay for the currently active cell (nativeID="overlay-current"). */
+    private var currentOverlayView: View? = null
+
+    /** Overlay for the upcoming cell (nativeID="overlay-next"). */
+    private var nextOverlayView: View? = null
+
+    /** The page index from which the current scroll gesture started. */
+    private var currentPage: Int = 0
+
+    // -----------------------------------------------------------------------
+    // Lifecycle
+    // -----------------------------------------------------------------------
+
+    override fun onAttachedToWindow() {
+        super.onAttachedToWindow()
+        embedFeedFragmentIfNeeded()
+    }
+
+    override fun onDetachedFromWindow() {
+        teardownScrollTracking()
+        removeFeedFragment()
+        super.onDetachedFromWindow()
+    }
+
+    // -----------------------------------------------------------------------
+    // Fragment containment
+    // -----------------------------------------------------------------------
+
+    private fun embedFeedFragmentIfNeeded() {
+        if (feedFragment != null) return
+
+        val sdk = ShortKitModule.shared?.sdk ?: run {
+            Log.w(TAG, "ShortKit SDK not initialized. Call ShortKitModule.initialize() first.")
+            return
+        }
+
+        val activity = getReactActivity() ?: run {
+            Log.w(TAG, "Could not find hosting Activity.")
+            return
+        }
+
+        val fragment = ShortKitFeedFragment.newInstance(sdk)
+
+        try {
+            activity.supportFragmentManager
+                .beginTransaction()
+                .replace(fragmentContainerId, fragment)
+                .commitNowAllowingStateLoss()
+            this.feedFragment = fragment  // Only assign after successful commit
+            setupScrollTracking(fragment)
+        } catch (e: Exception) {
+            Log.e(TAG, "Failed to embed feed fragment", e)
+        }
+    }
+
+    private fun removeFeedFragment() {
+        val fragment = feedFragment ?: return
+        feedFragment = null  // Clear immediately to prevent leaks on early return
+
+        try {
+            val activity = getReactActivity() ?: return
+            activity.supportFragmentManager
+                .beginTransaction()
+                .remove(fragment)
+                .commitNowAllowingStateLoss()
+        } catch (e: IllegalStateException) {
+            // Expected during Activity teardown — fragment already being destroyed
+        } catch (e: Exception) {
+            Log.e(TAG, "Unexpected error removing feed fragment", e)
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // Scroll tracking
+    // -----------------------------------------------------------------------
+
+    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() {
+        pageChangeCallback?.let { viewPager?.unregisterOnPageChangeCallback(it) }
+        pageChangeCallback = null
+        viewPager = null
+        currentOverlayView?.translationY = 0f
+        nextOverlayView?.translationY = 0f
+        currentOverlayView = null
+        nextOverlayView = null
+    }
+
+    private fun handleScrollOffset(
+        position: Int,
+        positionOffset: Float,
+        positionOffsetPixels: Int
+    ) {
+        val cellHeight = height.toFloat()
+        if (cellHeight <= 0) return
+
+        // 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())
+        }
+
+        // Update currentPage when the scroll settles
+        if (positionOffset == 0f) {
+            currentPage = position
+        }
+
+        // Find the overlay views if not cached
+        if (currentOverlayView == null || nextOverlayView == null) {
+            findOverlayViews()
+        }
+
+        // Current overlay follows the active cell
+        currentOverlayView?.translationY = -delta
+
+        // Next overlay: positioned one page ahead in the scroll direction
+        if (delta >= 0) {
+            // Forward scroll (or idle): next cell is below
+            nextOverlayView?.translationY = cellHeight - delta
+        } else {
+            // Backward scroll: next cell is above
+            nextOverlayView?.translationY = -cellHeight - delta
+        }
+    }
+
+    /**
+     * Find the sibling RN overlay views by nativeID. In the Fabric hierarchy,
+     * the ShortKitFeedView and the overlay containers are children of the
+     * same parent (wrapped by ShortKitFeed.tsx with overflow: hidden).
+     */
+    private fun findOverlayViews() {
+        val parent = parent as? ViewGroup ?: return
+
+        for (i in 0 until parent.childCount) {
+            val sibling = parent.getChildAt(i)
+            if (sibling === this) continue
+            if (currentOverlayView == null) {
+                currentOverlayView = ReactFindViewUtil.findView(sibling, "overlay-current")
+            }
+            if (nextOverlayView == null) {
+                nextOverlayView = ReactFindViewUtil.findView(sibling, "overlay-next")
+            }
+        }
+    }
+
+    /** Recursively find the first [ViewPager2] in a view hierarchy. */
+    private fun findViewPager2(view: View): ViewPager2? {
+        if (view is ViewPager2) return view
+        if (view is ViewGroup) {
+            for (i in 0 until view.childCount) {
+                findViewPager2(view.getChildAt(i))?.let { return it }
+            }
+        }
+        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
+        while (ctx is ContextWrapper) {
+            if (ctx is FragmentActivity) return ctx
+            ctx = ctx.baseContext
+        }
+        return null
+    }
+
+    companion object {
+        private const val TAG = "ShortKitFeedView"
+    }
+}

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

@@ -0,0 +1,32 @@
+package com.shortkit.reactnative
+
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+
+@ReactModule(name = ShortKitFeedViewManager.REACT_CLASS)
+class ShortKitFeedViewManager : SimpleViewManager<ShortKitFeedView>() {
+
+    override fun getName(): String = REACT_CLASS
+
+    override fun createViewInstance(context: ThemedReactContext): ShortKitFeedView {
+        return ShortKitFeedView(context)
+    }
+
+    @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
+    }
+
+
+    companion object {
+        const val REACT_CLASS = "ShortKitFeedView"
+    }
+}