@shortkitsdk/react-native 0.2.27 → 0.2.29

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

@@ -835,6 +835,14 @@ class ShortKitBridge(
         }
     }
 
+    fun refresh(feedId: String) {
+        val fragment = feedRegistry[feedId]?.get()
+        if (fragment != null) {
+            Handler(Looper.getMainLooper()).post { fragment.refresh() }
+        }
+        // No pending ops — refresh on unregistered feed is a no-op
+    }
+
     // ------------------------------------------------------------------
     // Fetch content
     // ------------------------------------------------------------------

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

@@ -230,6 +230,16 @@ class ShortKitModule(reactContext: ReactApplicationContext) :
         }
     }
 
+    @ReactMethod
+    override fun refresh(feedId: String) {
+        val b = bridge
+        if (b != null) {
+            b.refresh(feedId)
+        } else {
+            // No buffering — refresh before bridge is ready is a no-op
+        }
+    }
+
     @ReactMethod
     override fun preloadFeed(configJSON: String, itemsJSON: String?, promise: Promise) {
         val b = bridge

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

@@ -4,6 +4,7 @@ import android.content.Context
 import android.view.MotionEvent
 import android.widget.FrameLayout
 import com.shortkit.sdk.config.PlayerClickAction
+import com.shortkit.sdk.config.FeedConfig
 import com.shortkit.sdk.config.PlayerConfig
 import com.shortkit.sdk.config.VideoOverlayMode
 import com.shortkit.sdk.model.ContentItem
@@ -106,6 +107,9 @@ class ShortKitPlayerNativeView(context: Context) : FrameLayout(context) {
                 loop = obj.optBoolean("loop", true),
                 muteOnStart = obj.optBoolean("muteOnStart", true),
                 videoOverlay = parseOverlay(obj),
+                feedConfig = obj.optString("feedConfig", "").let { fcStr ->
+                    if (fcStr.isNotEmpty()) ShortKitBridge.parseFeedConfig(fcStr, context) else FeedConfig()
+                },
             )
         } catch (_: Exception) {
             PlayerConfig()

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

@@ -5,28 +5,40 @@ import android.widget.FrameLayout
 import com.shortkit.sdk.config.PlayerClickAction
 import com.shortkit.sdk.config.VideoOverlayMode
 import com.shortkit.sdk.config.WidgetConfig
-import com.shortkit.sdk.model.ContentItem
 import com.shortkit.sdk.widget.ShortKitWidgetView
+import com.shortkit.sdk.config.FeedConfig
 import com.shortkit.sdk.model.FeedFilter
+import com.shortkit.sdk.model.WidgetInput
 import org.json.JSONArray
 import org.json.JSONObject
 
 /**
  * Fabric native view wrapping [ShortKitWidgetView] for use as a
  * horizontal video carousel in React Native.
+ *
+ * Props:
+ *  - `config`: JSON string with WidgetConfig values
+ *  - `items`: JSON string with WidgetInput array (compact playback-ID form)
  */
 class ShortKitWidgetNativeView(context: Context) : FrameLayout(context) {
 
     private var widgetView: ShortKitWidgetView? = null
     private var configJson: String? = null
     private var itemsJson: String? = null
+    private var parsedConfig: WidgetConfig = WidgetConfig()
+    private var parsedItems: List<WidgetInput> = emptyList()
 
     var config: String?
         get() = configJson
         set(value) {
             if (value == configJson) return
             configJson = value
-            rebuildIfNeeded()
+            parsedConfig = parseWidgetConfig(value)
+            // If widget is already built, rebuild to pick up new config.
+            if (widgetView != null) {
+                removeWidget()
+                embedWidgetIfNeeded()
+            }
         }
 
     var items: String?
@@ -34,39 +46,38 @@ class ShortKitWidgetNativeView(context: Context) : FrameLayout(context) {
         set(value) {
             if (value == itemsJson) return
             itemsJson = value
-            applyItems()
+            parsedItems = parseWidgetInputs(value) ?: emptyList()
+            // Post-mount update on an existing widget.
+            widgetView?.configure(parsedItems)
         }
 
     override fun onAttachedToWindow() {
         super.onAttachedToWindow()
-        rebuildIfNeeded()
+        embedWidgetIfNeeded()
     }
 
     override fun onDetachedFromWindow() {
         super.onDetachedFromWindow()
+        removeWidget()
     }
 
-    private fun rebuildIfNeeded() {
+    private fun embedWidgetIfNeeded() {
         if (widgetView != null) return
-
         val sdk = ShortKitBridge.shared?.sdk ?: return
-        val widgetConfig = parseWidgetConfig(configJson)
 
+        // Pass items at initialize time so the widget never races the server
+        // fetch — analogous to the feed's `feedItems` prop wiring.
         val view = ShortKitWidgetView(context).apply {
             layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
         }
-        view.initialize(sdk, widgetConfig)
+        view.initialize(sdk, parsedConfig, parsedItems)
         addView(view)
         widgetView = view
-
-        applyItems()
     }
 
-    private fun applyItems() {
-        val json = itemsJson ?: return
-        val view = widgetView ?: return
-        val contentItems = parseContentItems(json) ?: return
-        view.configure(contentItems)
+    private fun removeWidget() {
+        widgetView?.let { removeView(it) }
+        widgetView = null
     }
 
     private fun parseWidgetConfig(json: String?): WidgetConfig {
@@ -91,6 +102,9 @@ class ShortKitWidgetNativeView(context: Context) : FrameLayout(context) {
                 filter = obj.optString("filter", "").let { filterStr ->
                     if (filterStr.isNotEmpty()) ShortKitBridge.parseFeedFilterToModel(filterStr) else null
                 },
+                feedConfig = obj.optString("feedConfig", "").let { fcStr ->
+                    if (fcStr.isNotEmpty()) ShortKitBridge.parseFeedConfig(fcStr, context) else FeedConfig()
+                },
             )
         } catch (_: Exception) {
             WidgetConfig()
@@ -107,29 +121,27 @@ class ShortKitWidgetNativeView(context: Context) : FrameLayout(context) {
         return VideoOverlayMode.None
     }
 
-    private fun parseContentItems(json: String): List<ContentItem>? {
+    /**
+     * Parse a JSON array of `WidgetInput` values (compact playback-ID form).
+     * Mirrors the JS `WidgetInput` type:
+     *   `{ type: 'video'; playbackId: string; fallbackUrl?: string }`.
+     */
+    private fun parseWidgetInputs(json: String?): List<WidgetInput>? {
+        if (json.isNullOrEmpty()) return null
         return try {
             val arr = JSONArray(json)
-            val items = mutableListOf<ContentItem>()
+            val out = mutableListOf<WidgetInput>()
             for (i in 0 until arr.length()) {
                 val obj = arr.getJSONObject(i)
-                items.add(
-                    ContentItem(
-                        id = obj.getString("id"),
-                        title = obj.getString("title"),
-                        description = obj.optString("description", null),
-                        duration = obj.getDouble("duration"),
-                        streamingUrl = obj.getString("streamingUrl"),
-                        thumbnailUrl = obj.getString("thumbnailUrl"),
-                        captionTracks = emptyList(),
-                        customMetadata = null,
-                        author = obj.optString("author", null),
-                        articleUrl = obj.optString("articleUrl", null),
-                        commentCount = if (obj.has("commentCount")) obj.getInt("commentCount") else null,
-                    )
-                )
+                if (obj.optString("type") != "video") continue
+                val playbackId = obj.optString("playbackId", "")
+                if (playbackId.isEmpty()) continue
+                val fallbackUrl = if (obj.has("fallbackUrl") && !obj.isNull("fallbackUrl")) {
+                    obj.getString("fallbackUrl")
+                } else null
+                out.add(WidgetInput.Video(playbackId = playbackId, fallbackUrl = fallbackUrl))
             }
-            items
+            out
         } catch (_: Exception) {
             null
         }

package/ios/ReactVideoCarouselOverlayHost.swift

@@ -324,7 +324,13 @@ import ShortKitSDK
                 } else {
                     carouselItemJSON = "{}"
                 }
+                // Tag with active surface's feedId so per-<ShortKitFeed>
+                // subscribers can filter to their own feed instance — same
+                // pattern as the other per-feed events. surfaceId continues
+                // to identify the React overlay host (a separate concern).
+                let feedId = self.bridge?.activeSurfaceFeedIdPublic() ?? ""
                 self.bridge?.emit("onCarouselActiveVideoCompleted", body: [
+                    "feedId": feedId,
                     "surfaceId": self.surfaceId,
                     "contentItem": contentItemJSON,
                     "indexInCarousel": event.indexInCarousel,

package/ios/ShortKitBridge.swift

@@ -72,7 +72,6 @@ import ShortKitSDK
 
         // Wire per-feed refresh state callback (scoped by feedId)
         vc.onRefreshStateChanged = { [weak self] state in
-            NSLog("[ShortKit Bridge] onRefreshStateChangedPerFeed feedId=%@ status=%@", id, "\(state)")
             var body: [String: Any] = ["feedId": id]
             switch state {
             case .idle:
@@ -101,6 +100,34 @@ import ShortKitSDK
             ])
         }
 
+        // Wire per-feed transition event. The FVC fires this closure from
+        // handleSwipe(to:) — one per transition, bound to this feed. This
+        // replaces the global `player.feedTransition` subscription pattern
+        // (which fanned every feed's transitions out to every mounted
+        // <ShortKitFeed>, causing cross-feed state pollution). Structural
+        // fix: callback literally cannot fire on the wrong feed.
+        vc.onFeedTransition = { [weak self] event in
+            guard let self else { return }
+            var body: [String: Any] = [
+                "feedId": id,
+                "phase": Self.transitionPhaseString(event.phase),
+                "direction": Self.transitionDirectionString(event.direction)
+            ]
+            // Serialize from the underlying FeedItem (not event.from/to
+            // which are nil for non-content cells). See the docstring on
+            // `serializeFeedItemIdentityJSON` for the why — in short, this
+            // ensures carousels/ads/surveys come through with a populated
+            // `id`, so JS-side hosts can track feed position for any cell
+            // type.
+            if let fromFeedItem = event.fromFeedItem {
+                body["fromItem"] = self.serializeFeedItemIdentityJSON(fromFeedItem)
+            }
+            if let toFeedItem = event.toFeedItem {
+                body["toItem"] = self.serializeFeedItemIdentityJSON(toFeedItem)
+            }
+            self.emitOnMain("onFeedTransition", body: body)
+        }
+
         // Replay buffered operations on the next run-loop tick so the VC's
         // view hierarchy is fully set up after didMoveToWindow returns.
         if let ops = pendingOps.removeValue(forKey: id) {
@@ -122,6 +149,24 @@ import ShortKitSDK
         return feedRegistry[id]?.vc
     }
 
+    /// Look up the feedId for the currently-active surface. Used by events
+    /// that originate in shared singletons (player Combine publishers, the
+    /// `ShortKitDelegate`) and must be attributed to one feed for the JS
+    /// wrapper's feedId filter to work. Returns `""` if no active surface
+    /// or if the active surface isn't in the registry — consumers should
+    /// treat empty feedId as "unknown/global" (JS wrapper accepts it as a
+    /// fallback for forward compatibility with older native builds).
+    private func activeSurfaceFeedId() -> String {
+        return feedRegistry.first(where: { $0.value.vc?.isActiveSurface == true })?.key ?? ""
+    }
+
+    /// Internal accessor for `activeSurfaceFeedId()` so cross-file emit
+    /// sites (e.g. `ReactVideoCarouselOverlayHost`) can tag emits with
+    /// the active feed's feedId without duplicating the lookup logic.
+    internal func activeSurfaceFeedIdPublic() -> String {
+        return activeSurfaceFeedId()
+    }
+
     // MARK: - Init
 
     @objc public init(
@@ -404,6 +449,14 @@ import ShortKitSDK
         }
     }
 
+    @objc public func refresh(_ feedId: String) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self else { return }
+            self.feedViewController(for: feedId)?.refresh()
+            // No pending ops buffer — refresh on a not-yet-registered feed is a no-op
+        }
+    }
+
     @objc public func fetchContent(_ limit: Int, filterJSON: String?, completion: @escaping (String) -> Void) {
         let filter = filterJSON.flatMap { Self.parseFeedFilter($0) }
         Task {
@@ -422,29 +475,21 @@ import ShortKitSDK
         let config = Self.parseFeedConfig(configJSON)
         let preload: FeedPreload?
 
-        NSLog("[ShortKit Bridge] preloadFeed called — feedSource: %@, hasItemsJSON: %@",
-              config.feedSource == .custom ? "custom" : "algorithmic",
-              itemsJSON != nil ? "yes (\(itemsJSON!.prefix(100))...)" : "no")
-
         if config.feedSource == .custom {
             guard let json = itemsJSON, let items = Self.parseFeedInputs(json) else {
-                NSLog("[ShortKit Bridge] ❌ preloadFeed: feedSource=custom but no valid items — returning empty")
                 completion("")
                 return
             }
-            NSLog("[ShortKit Bridge] preloadFeed: creating custom preload with %d items", items.count)
             preload = shortKit?.preloadFeed(items: items)
         } else {
             preload = shortKit?.preloadFeed(filter: config.filter)
         }
 
         guard let preload else {
-            NSLog("[ShortKit Bridge] ❌ preloadFeed: shortKit?.preloadFeed returned nil")
             completion("")
             return
         }
         let uuid = UUID().uuidString
-        NSLog("[ShortKit Bridge] ✅ preloadFeed: created handle %@", uuid)
         preloadHandles[uuid] = preload
         activeFeedId = uuid
         completion(uuid)
@@ -545,38 +590,34 @@ import ShortKitSDK
             }
             .store(in: &cancellables)
 
-        // Did loop
+        // Did loop — tagged with active surface's feedId. `player.didLoop`
+        // is a singleton Combine publisher on the shared player (only one
+        // item plays at a time). The event semantically belongs to
+        // whichever feed owns the active surface; tag with that feedId so
+        // JS consumers bound to specific feeds can filter.
         player.didLoop
             .receive(on: DispatchQueue.main)
             .sink { [weak self] event in
-                self?.emit("onDidLoop", body: [
+                guard let self else { return }
+                let feedId = self.activeSurfaceFeedId()
+                self.emit("onDidLoop", body: [
+                    "feedId": feedId,
                     "contentId": event.contentId,
                     "loopCount": event.loopCount
                 ])
             }
             .store(in: &cancellables)
 
-        // Feed transition — deferred to next run-loop tick so emission doesn't
-        // contend with Core Animation's commit phase during swipe settle.
-        player.feedTransition
-            .receive(on: DispatchQueue.main)
-            .sink { [weak self] event in
-                guard let self else { return }
-                var body: [String: Any] = [
-                    "phase": Self.transitionPhaseString(event.phase),
-                    "direction": Self.transitionDirectionString(event.direction)
-                ]
-                if let from = event.from {
-                    body["fromItem"] = self.serializeContentItemToJSON(from)
-                }
-                if let to = event.to {
-                    body["toItem"] = self.serializeContentItemToJSON(to)
-                }
-                DispatchQueue.main.async { [weak self] in
-                    self?.emit("onFeedTransition", body: body)
-                }
-            }
-            .store(in: &cancellables)
+        // NOTE: The global `player.feedTransition` subscription used to live
+        // here. It's been removed — feed transitions are now emitted to RN
+        // via the per-FVC `vc.onFeedTransition` closure wired in
+        // `registerFeed(id:viewController:)` above. This eliminates the
+        // cross-feed routing bug where every mounted <ShortKitFeed>
+        // consumer received every feed's transitions.
+        //
+        // `player.sendFeedTransition` is still called by FVC.handleSwipe
+        // for backward compatibility with native iOS consumers that
+        // subscribe to `ShortKit.player.feedTransition` directly.
 
         // Feed scroll phase — coalesced: only emit .dragging on first touch
         // (transition from settled), drop intermediate .dragging events. Always
@@ -605,11 +646,16 @@ import ShortKitSDK
             }
             .store(in: &cancellables)
 
-        // Format change
+        // Format change — tagged with active surface's feedId. Same
+        // reasoning as onDidLoop: fires from shared player singleton, but
+        // semantically belongs to whichever feed owns the active surface.
         player.formatChange
             .receive(on: DispatchQueue.main)
             .sink { [weak self] event in
-                self?.emit("onFormatChange", body: [
+                guard let self else { return }
+                let feedId = self.activeSurfaceFeedId()
+                self.emit("onFormatChange", body: [
+                    "feedId": feedId,
                     "contentId": event.contentId,
                     "fromBitrate": Double(event.fromBitrate),
                     "toBitrate": Double(event.toBitrate),
@@ -675,6 +721,52 @@ import ShortKitSDK
         return json
     }
 
+    /// Serialize a `FeedItem` to a ContentItem-shaped JSON string for the
+    /// `onFeedTransition` event. For `.content` cells this is the real
+    /// `ContentItem`. For every other cell kind (adSlot, imageCarousel,
+    /// survey, videoCarousel) there is no playable `ContentItem`, so we
+    /// synthesize a minimal one whose ONLY meaningful field is `id`.
+    ///
+    /// Why: JS hosts use `event.to` as an identity cursor for resume-on-
+    /// tab-return (`setFeedItems(startAt:)`). Before this synthesis, non-
+    /// content cells came through as `to=null` and the host's stored
+    /// resume id stayed pinned to the last regular video — causing the
+    /// SDK to re-seed the feed at the wrong index on tab return, which
+    /// in turn caused black carousel cells + wrong audio (see repro
+    /// analysis in debug.log, apr 2026).
+    ///
+    /// Scope: this is a bridge-only synthesis. It never flows back into
+    /// the Swift SDK (pool, cache, FeedDataSource, etc. all still see the
+    /// real `FeedItem` / `ContentItem?` and treat non-content cells
+    /// honestly). JS-side consumers should ONLY read `.id` / `.playbackId`
+    /// from `onFeedTransition` items — deeper fields are placeholders for
+    /// non-content cells.
+    ///
+    /// TODO: when we want to expose richer per-cell metadata on the JS
+    /// side, migrate to a proper FeedPosition event payload rather than
+    /// extending this synthesis. See the long-term fix plan.
+    private func serializeFeedItemIdentityJSON(_ feedItem: FeedItem) -> String {
+        if let contentItem = feedItem.contentItem {
+            return serializeContentItemToJSON(contentItem)
+        }
+        let synthetic = ContentItem(
+            id: feedItem.id,
+            playbackId: nil,
+            title: "",
+            description: nil,
+            duration: 0,
+            streamingUrl: "",
+            thumbnailUrl: "",
+            captionTracks: [],
+            customMetadata: nil,
+            author: nil,
+            articleUrl: nil,
+            commentCount: nil,
+            fallbackUrl: nil
+        )
+        return serializeContentItemToJSON(synthetic)
+    }
+
     /// Build an NSDictionary from a ContentItem with fields matching the JS spec.
     /// `captionTracks` and `customMetadata` are JSON-serialized strings.
     private static func contentItemDict(_ item: ContentItem) -> [String: Any] {
@@ -999,7 +1091,14 @@ import ShortKitSDK
 
 extension ShortKitBridge: ShortKitDelegate {
     public func shortKit(_ shortKit: ShortKit, didTapContent contentId: String, at index: Int) {
+        // Tag with active surface's feedId. The delegate is a singleton
+        // (the bridge), so we use the activeSurface lookup to attribute
+        // this tap to the feed it originated from. Without the tag, every
+        // mounted <ShortKitFeed> consumer would fire onContentTapped on
+        // every tap — including taps in sibling feeds.
+        let feedId = activeSurfaceFeedId()
         emitOnMain("onContentTapped", body: [
+            "feedId": feedId,
             "contentId": contentId,
             "index": index
         ])
@@ -1030,10 +1129,18 @@ extension ShortKitBridge: ShortKitDelegate {
                 self.itemCache[item.id] = item
             }
         }
+        // Capture the feedId synchronously before the async Task — after
+        // the await, activeSurface may have shifted (user swiped tabs).
+        // The fetch semantically belongs to whichever feed initiated it,
+        // which at this delegate-call moment is the active surface.
+        let feedId = activeSurfaceFeedId()
         Task {
             let data = try? JSONEncoder().encode(items)
             let json = data.flatMap { String(data: $0, encoding: .utf8) } ?? "[]"
-            self.emitOnMain("onDidFetchContentItems", body: ["items": json])
+            self.emitOnMain("onDidFetchContentItems", body: [
+                "feedId": feedId,
+                "items": json
+            ])
         }
     }
 }