@shortkitsdk/react-native 0.2.11 → 0.2.14

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,50 @@ 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)
+                "onCarouselActiveImageChanged" -> emitOnCarouselActiveImageChanged(params)
+                "onVideoCarouselActiveVideoChanged" -> emitOnVideoCarouselActiveVideoChanged(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/ReactCarouselOverlayHost.swift

@@ -5,8 +5,8 @@ import ShortKitSDK
 /// for rendering the developer's React carousel overlay component inside a feed cell.
 ///
 /// Unlike ReactOverlayHost, this does not subscribe to player state (carousels
-/// are image-based). It emits image URLs to JS for Image.prefetch() and pushes
-/// ImageCarouselItem data as appProperties.
+/// are image-based). It delivers `isActive` and `activeImageIndex` via bridge
+/// events (routed by surfaceId) to avoid Fabric remounts.
 @objc public class ReactCarouselOverlayHost: UIView, @unchecked Sendable, CarouselOverlay {
 
     // MARK: - Configuration
@@ -20,9 +20,6 @@ import ShortKitSDK
 
     // MARK: - Eager Surface Creation
 
-    /// Eagerly create the RN surface so it's ready before the first configure().
-    /// Called by the overlay factory right after setting surfacePresenter and moduleName.
-    /// Mirrors ReactOverlayHost.attach(player:) which does the same for video overlays.
     func prepareSurface() {
         createSurfaceIfNeeded()
     }
@@ -37,6 +34,11 @@ import ShortKitSDK
     private var surface: SKFabricSurfaceWrapper?
     private var surfaceView: UIView?
     private var pendingProps: [String: Any]?
+    private var isActive = false
+    private var activeImageIndex = 0
+
+    /// Unique identifier for this overlay instance, used for event routing.
+    let surfaceId = UUID().uuidString
 
     // MARK: - Init
 
@@ -57,11 +59,11 @@ import ShortKitSDK
     // MARK: - CarouselOverlay
 
     public func configure(with item: ImageCarouselItem) {
+        isActive = false
+        activeImageIndex = 0
         createSurfaceIfNeeded()
 
         // Replace remote URLs with local file URLs for any natively-cached images.
-        // The SDK's PrefetchManager downloads images into NSCache<NSString, UIImage>
-        // which RN can't access. Writing to temp files lets RN load instantly from disk.
         var modifiedItem = item
         if let cachedImage {
             var localImages: [CarouselImage] = []
@@ -85,10 +87,12 @@ import ShortKitSDK
             )
         }
 
-        // Build props — push now if surface exists, otherwise store for later
         if let data = try? JSONEncoder().encode(modifiedItem),
            let json = String(data: data, encoding: .utf8) {
-            let props: [String: Any] = ["item": json]
+            let props: [String: Any] = [
+                "surfaceId": surfaceId,
+                "item": json,
+            ]
             if let surface {
                 surface.setProperties(props)
             } else {
@@ -97,14 +101,35 @@ import ShortKitSDK
         }
     }
 
+    public func activatePlayback() {
+        isActive = true
+        bridge?.emit("onOverlayFullState", body: [
+            "surfaceId": surfaceId,
+            "isActive": true,
+            // Include required fields for the full state event
+            "playerState": "idle",
+            "isMuted": true,
+            "playbackRate": 1.0,
+            "captionsEnabled": false,
+            "activeCue": NSNull(),
+            "feedScrollPhase": NSNull(),
+        ])
+    }
+
+    public func updateActiveImage(index: Int) {
+        activeImageIndex = index
+        bridge?.emit("onCarouselActiveImageChanged", body: [
+            "surfaceId": surfaceId,
+            "activeImageIndex": index,
+        ])
+    }
+
     /// Write a UIImage to the temp directory, returning a file:// URL string.
-    /// Uses a hash of the remote URL as the filename to avoid duplicates.
     private func writeTempImage(_ image: UIImage, for remoteURL: String) -> String? {
         let hash = remoteURL.hash
         let fileName = "sk-carousel-\(abs(hash)).jpg"
         let fileURL = URL(fileURLWithPath: NSTemporaryDirectory()).appendingPathComponent(fileName)
 
-        // Skip if already written
         if FileManager.default.fileExists(atPath: fileURL.path) {
             return fileURL.absoluteString
         }
@@ -119,10 +144,7 @@ import ShortKitSDK
     }
 
     public func resetState() {
-        // Don't clear surface props — matches video overlay (ReactOverlayHost) pattern.
-        // configure() will overwrite with new props directly, letting React do an
-        // in-place re-render (old→new) instead of an unmount+remount (old→empty→new).
-        // The overlay's synchronous reset pattern handles state transitions.
+        // Don't clear surface props — configure() will overwrite.
     }
 
     // MARK: - Surface Creation
@@ -130,7 +152,6 @@ import ShortKitSDK
     private func createSurfaceIfNeeded() {
         guard surface == nil, let presenter = surfacePresenter else { return }
 
-        // Must always dispatch to main queue — see ReactOverlayHost for details.
         DispatchQueue.main.async { [weak self] in
             guard let self, self.surface == nil else { return }
             self.installSurface(presenter: presenter)
@@ -157,7 +178,6 @@ import ShortKitSDK
         surfaceView = view
         surface = surf
 
-        // Flush any props that arrived before surface was ready
         if let pending = pendingProps {
             surf.setProperties(pending)
             pendingProps = nil

package/ios/ReactOverlayHost.swift

@@ -126,6 +126,7 @@ import ShortKitSDK
     }
 
     public func configure(with item: ContentItem) {
+        let isSameItem = item.id == currentItem?.id
         currentItem = item
         isActive = false
         timeDirty = false
@@ -140,10 +141,12 @@ import ShortKitSDK
 
         createSurfaceIfNeeded()
 
-        // Set surface properties ONCE per item. This triggers a Fabric remount,
-        // which is desired on cell reuse (new content, fresh React state).
-        // All subsequent dynamic updates go through events, not setProperties().
-        pushInitialProperties()
+        // Only push properties if the surface already exists.
+        // If the surface is still being created asynchronously,
+        // installSurface() will call pushInitialProperties() when ready.
+        if surface != nil && !isSameItem {
+            pushInitialProperties()
+        }
     }
 
     public func activatePlayback() {
@@ -165,41 +168,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
@@ -240,6 +229,15 @@ import ShortKitSDK
 
         // Push any pending properties now that the surface exists
         pushInitialProperties()
+
+        // If activatePlayback() was called before the surface was ready,
+        // emit the full state now that JS can receive events.
+        if isActive {
+            DispatchQueue.main.async { [weak self] in
+                guard let self, self.isActive else { return }
+                self.emitFullState()
+            }
+        }
     }
 
     // MARK: - Layout
@@ -418,10 +416,10 @@ import ShortKitSDK
             props["item"] = json
         }
 
-        // Initial values — may be stale by the time activatePlayback() fires,
-        // which is why activatePlayback() emits a full state flush via events.
-        props["isActive"] = false
-        props["playerState"] = "idle"
+        // Use current state — if activatePlayback() was called before the
+        // surface was created, isActive will already be true.
+        props["isActive"] = isActive
+        props["playerState"] = cachedPlayerState
         props["isMuted"] = cachedIsMuted
         props["playbackRate"] = cachedPlaybackRate
         props["captionsEnabled"] = cachedCaptionsEnabled

package/ios/ReactVideoCarouselOverlayHost.swift

@@ -0,0 +1,283 @@
+import UIKit
+import Combine
+import ShortKitSDK
+
+/// A UIView that conforms to `VideoCarouselOverlay` and hosts an `RCTFabricSurface`
+/// for rendering the developer's React video carousel overlay component inside a feed cell.
+///
+/// Pushes `VideoCarouselItem` and active video data as surface properties, and
+/// emits playback state (isActive, time, playerState, isMuted) via bridge events
+/// using the same event names as `ReactOverlayHost` (routed by `surfaceId`).
+@objc public class ReactVideoCarouselOverlayHost: UIView, @unchecked Sendable, VideoCarouselOverlay {
+
+    // MARK: - Configuration
+
+    var surfacePresenter: AnyObject?
+    weak var bridge: ShortKitBridge?
+
+    /// Module name for the RCTFabricSurface. Set by the overlay factory
+    /// based on the feed config's video carousel overlay name.
+    var videoCarouselOverlayModuleName: String = "ShortKitVideoCarouselOverlay"
+
+    // MARK: - Eager Surface Creation
+
+    func prepareSurface() {
+        createSurfaceIfNeeded()
+    }
+
+    // MARK: - State
+
+    private var surface: SKFabricSurfaceWrapper?
+    private var surfaceView: UIView?
+    private var pendingProps: [String: Any]?
+
+    /// Unique identifier for this overlay instance, used for event routing.
+    let surfaceId = UUID().uuidString
+
+    /// Cached carouselItem JSON — setProperties replaces all props, doesn't merge.
+    private var carouselItemJSON: String?
+
+    // Player state
+    private var player: ShortKitPlayer?
+    private var cancellables = Set<AnyCancellable>()
+    private var isActive = false
+    private var cachedPlayerState: String = "idle"
+    private var cachedIsMuted: Bool = true
+    private var cachedTime: (current: Double, duration: Double, buffered: Double) = (0, 0, 0)
+    private var timeCoalesceTimer: Timer?
+    private var timeDirty = false
+
+    // MARK: - Init
+
+    override init(frame: CGRect) {
+        super.init(frame: frame)
+        backgroundColor = .clear
+        isUserInteractionEnabled = true
+    }
+
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) is not supported")
+    }
+
+    deinit {
+        timeCoalesceTimer?.invalidate()
+        surface?.stop()
+    }
+
+    // MARK: - VideoCarouselOverlay
+
+    public func configure(with item: VideoCarouselItem) {
+        isActive = false
+        timeDirty = false
+        timeCoalesceTimer?.invalidate()
+        timeCoalesceTimer = nil
+        cachedTime = (0, 0, 0)
+        cachedPlayerState = "idle"
+
+        createSurfaceIfNeeded()
+
+        guard let data = try? JSONEncoder().encode(item),
+              let json = String(data: data, encoding: .utf8) else { return }
+        carouselItemJSON = json
+
+        var props: [String: Any] = [
+            "surfaceId": surfaceId,
+            "carouselItem": json,
+            "isActive": false,
+            "playerState": "idle",
+            "isMuted": cachedIsMuted,
+        ]
+        if let firstVideo = item.videos.first,
+           let videoData = try? JSONEncoder().encode(firstVideo),
+           let videoJSON = String(data: videoData, encoding: .utf8) {
+            props["activeVideo"] = videoJSON
+            props["activeVideoIndex"] = 0
+        }
+        if let surface {
+            surface.setProperties(props)
+        } else {
+            pendingProps = props
+        }
+    }
+
+    public func updateActiveVideo(index: Int, item: ContentItem) {
+        guard let data = try? JSONEncoder().encode(item),
+              let json = String(data: data, encoding: .utf8) else { return }
+
+        // Only emit when active — matches ReactOverlayHost pattern.
+        // During initial setup, configure() sets the first video via surface props.
+        // Before activation, the AsyncEventEmitter may not be initialized.
+        guard isActive else { return }
+
+        bridge?.emit("onVideoCarouselActiveVideoChanged", body: [
+            "surfaceId": surfaceId,
+            "activeVideo": json,
+            "activeVideoIndex": index,
+        ])
+    }
+
+    public func resetState() {
+        // Don't clear surface props — configure() will overwrite.
+    }
+
+    public func attach(player: ShortKitPlayer) {
+        self.player = player
+        subscribeToPlayer(player)
+        createSurfaceIfNeeded()
+    }
+
+    public func activatePlayback() {
+        isActive = true
+        startTimeCoalescing()
+
+        DispatchQueue.main.async { [weak self] in
+            guard let self, self.isActive else { return }
+            self.emitFullState()
+        }
+    }
+
+    public func deactivatePlayback() {
+        isActive = false
+        timeDirty = false
+        timeCoalesceTimer?.invalidate()
+        timeCoalesceTimer = nil
+    }
+
+    // MARK: - Player Subscriptions
+
+    private func subscribeToPlayer(_ player: ShortKitPlayer) {
+        cancellables.removeAll()
+        player.playerState
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] state in
+                guard let self else { return }
+                self.cachedPlayerState = Self.playerStateString(state)
+                if self.isActive {
+                    self.bridge?.emit("onOverlayPlayerStateChanged", body: [
+                        "surfaceId": self.surfaceId,
+                        "playerState": self.cachedPlayerState
+                    ])
+                }
+            }
+            .store(in: &cancellables)
+
+        player.isMuted
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] muted in
+                guard let self else { return }
+                self.cachedIsMuted = muted
+                if self.isActive {
+                    self.bridge?.emit("onOverlayMutedChanged", body: [
+                        "surfaceId": self.surfaceId,
+                        "isMuted": self.cachedIsMuted
+                    ])
+                }
+            }
+            .store(in: &cancellables)
+
+        player.time
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] time in
+                guard let self, self.isActive else { return }
+                self.cachedTime = (time.current, time.duration, time.buffered)
+                self.timeDirty = true
+            }
+            .store(in: &cancellables)
+    }
+
+    // MARK: - Time Coalescing
+
+    private func startTimeCoalescing() {
+        timeCoalesceTimer?.invalidate()
+        timeCoalesceTimer = Timer.scheduledTimer(withTimeInterval: 0.25, repeats: true) { [weak self] _ in
+            guard let self, self.timeDirty else { return }
+            self.timeDirty = false
+            self.bridge?.emit("onOverlayTimeUpdate", body: [
+                "surfaceId": self.surfaceId,
+                "current": self.cachedTime.current,
+                "duration": self.cachedTime.duration,
+                "buffered": self.cachedTime.buffered
+            ])
+        }
+    }
+
+    // MARK: - Full State Emission
+
+    private func emitFullState() {
+        bridge?.emit("onOverlayFullState", body: [
+            "surfaceId": surfaceId,
+            "isActive": true,
+            "playerState": cachedPlayerState,
+            "isMuted": cachedIsMuted,
+            "playbackRate": 1.0,
+            "captionsEnabled": false,
+            "activeCue": NSNull(),
+            "feedScrollPhase": NSNull(),
+        ])
+    }
+
+    // MARK: - Surface Creation
+
+    private func createSurfaceIfNeeded() {
+        guard surface == nil, let presenter = surfacePresenter else { return }
+
+        DispatchQueue.main.async { [weak self] in
+            guard let self, self.surface == nil else { return }
+            self.installSurface(presenter: presenter)
+        }
+    }
+
+    private func installSurface(presenter: AnyObject) {
+        guard let surf = SKFabricSurfaceWrapper(
+            presenter: presenter,
+            moduleName: videoCarouselOverlayModuleName,
+            initialProperties: [:]
+        ) else { return }
+        surf.start()
+
+        let view = surf.view
+        view.translatesAutoresizingMaskIntoConstraints = false
+        addSubview(view)
+        NSLayoutConstraint.activate([
+            view.topAnchor.constraint(equalTo: topAnchor),
+            view.leadingAnchor.constraint(equalTo: leadingAnchor),
+            view.trailingAnchor.constraint(equalTo: trailingAnchor),
+            view.bottomAnchor.constraint(equalTo: bottomAnchor),
+        ])
+        surfaceView = view
+        surface = surf
+
+        // Flush any props that arrived before surface was ready
+        if let pending = pendingProps {
+            surf.setProperties(pending)
+            pendingProps = nil
+        }
+    }
+
+    // MARK: - Layout
+
+    public override func layoutSubviews() {
+        super.layoutSubviews()
+        guard let surface else { return }
+        let size = bounds.size
+        guard size.width > 0, size.height > 0 else { return }
+        surface.setMinimumSize(size)
+        surface.setMaximumSize(size)
+    }
+
+    // MARK: - Helpers
+
+    private static func playerStateString(_ state: PlayerState) -> String {
+        switch state {
+        case .idle: return "idle"
+        case .loading: return "loading"
+        case .ready: return "ready"
+        case .playing: return "playing"
+        case .paused: return "paused"
+        case .seeking: return "seeking"
+        case .buffering: return "buffering"
+        case .ended: return "ended"
+        case .error(_): return "error"
+        }
+    }
+}