@shortkitsdk/react-native 0.2.6 → 0.2.11

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

@@ -1,881 +1,263 @@
 package com.shortkit.reactnative
 
+import android.os.Handler
+import android.os.Looper
 import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.modules.core.DeviceEventManagerModule
-import com.shortkit.CarouselImage
-import com.shortkit.ContentItem
-import com.shortkit.ContentSignal
-import com.shortkit.FeedInput
-import com.shortkit.ImageCarouselItem
-import com.shortkit.FeedConfig
-import com.shortkit.FeedHeight
-import com.shortkit.FeedSource
-import com.shortkit.FeedTransitionPhase
-import com.shortkit.JsonValue
-import com.shortkit.ShortKit
-import com.shortkit.ShortKitPlayer
-import com.shortkit.VideoOverlayMode
-import com.shortkit.CarouselOverlayMode
-import com.shortkit.SurveyOverlayMode
-import com.shortkit.AdOverlayMode
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.cancel
-import kotlinx.coroutines.launch
-import org.json.JSONArray
-import org.json.JSONObject
 
+/**
+ * Thin TurboModule that delegates all logic to [ShortKitBridge].
+ *
+ * Responsibilities:
+ *  - Forward every @ReactMethod to the bridge
+ *  - Handle event emission via RCTDeviceEventEmitter
+ *  - Buffer operations that arrive before initialize() creates the bridge
+ */
 class ShortKitModule(reactContext: ReactApplicationContext) :
     NativeShortKitModuleSpec(reactContext) {
 
     companion object {
         const val NAME = "ShortKitModule"
-
-        /** Static reference for Fabric view access (mirrors iOS ShortKitBridge.shared). */
-        @Volatile
-        var shared: ShortKitModule? = null
-            private set
     }
 
-    // -----------------------------------------------------------------------
-    // State
-    // -----------------------------------------------------------------------
-
-    private var shortKit: ShortKit? = null
-    private var scope: CoroutineScope? = null
+    private var bridge: ShortKitBridge? = null
+    private var pendingBridgeOps: MutableList<() -> Unit>? = null
     private var listenerCount = 0
-    @Volatile
-    private var hasListeners = false
-    private var pendingFeedItems: String? = null
-    private var pendingAppendItems: String? = null
+    @Volatile private var hasListeners = false
 
-    /** Expose the underlying SDK for the Fabric feed view manager. */
-    val sdk: ShortKit? get() = shortKit
-
-    // -----------------------------------------------------------------------
+    // -----------------------------------------------------------------
     // Module boilerplate
-    // -----------------------------------------------------------------------
+    // -----------------------------------------------------------------
 
     override fun getName(): String = NAME
 
     override fun initialize() {
         super.initialize()
-        shared = this
     }
 
     override fun onCatalystInstanceDestroy() {
-        teardown()
-        if (shared === this) shared = null
+        bridge?.teardown()
+        bridge = null
         super.onCatalystInstanceDestroy()
     }
 
-    // -----------------------------------------------------------------------
-    // Event listeners
-    // -----------------------------------------------------------------------
+    // -----------------------------------------------------------------
+    // Event listener management
+    // -----------------------------------------------------------------
 
-    override fun addListener(eventType: String?) {
+    @ReactMethod
+    fun addListener(eventType: String?) {
         listenerCount++
         hasListeners = true
     }
 
-    override fun removeListeners(count: Double) {
+    @ReactMethod
+    fun removeListeners(count: Double) {
         listenerCount = maxOf(0, listenerCount - count.toInt())
         hasListeners = listenerCount > 0
     }
 
-    // -----------------------------------------------------------------------
-    // Lifecycle methods
-    // -----------------------------------------------------------------------
+    // -----------------------------------------------------------------
+    // Lifecycle
+    // -----------------------------------------------------------------
 
     @ReactMethod
     override fun initialize(
         apiKey: String,
-        config: String,
+        hasLoadingView: Boolean,
         clientAppName: String?,
         clientAppVersion: String?,
         customDimensions: String?
     ) {
-        // Tear down any existing instance (re-init safety)
-        teardown()
-
-        val feedConfig = parseFeedConfig(config)
-        val dims = parseCustomDimensions(customDimensions)
+        bridge?.teardown()
+        bridge = null
 
         val context = reactApplicationContext
 
-        val sdk = ShortKit(
-            context = context,
-            apiKey = apiKey,
-            config = feedConfig,
-            userId = null,
-            adProvider = null,
-            clientAppName = clientAppName,
-            clientAppVersion = clientAppVersion,
-            customDimensions = dims
-        )
-        this.shortKit = sdk
-        shared = this
-
-        // Replay any feed items that arrived before initialization
-        pendingFeedItems?.let { json ->
-            parseFeedInputs(json)?.let { sdk.setFeedItems(it) }
-            pendingFeedItems = null
-        }
-        pendingAppendItems?.let { json ->
-            parseFeedInputs(json)?.let { sdk.appendFeedItems(it) }
-            pendingAppendItems = null
-        }
-
-        subscribeToFlows(sdk.player)
+        Handler(Looper.getMainLooper()).post {
+            bridge = ShortKitBridge(
+                apiKey = apiKey,
+                context = context,
+                hasLoadingView = hasLoadingView,
+                clientAppName = clientAppName,
+                clientAppVersion = clientAppVersion,
+                customDimensionsJSON = customDimensions,
+                emitEvent = { name, body -> sendEvent(name, body) }
+            )
 
-        sdk.delegate = object : com.shortkit.ShortKitDelegate {
-            override fun onContentTapped(contentId: String, index: Int) {
-                val params = Arguments.createMap().apply {
-                    putString("contentId", contentId)
-                    putInt("index", index)
-                }
-                sendEvent("onContentTapped", params)
-            }
+            pendingBridgeOps?.forEach { it() }
+            pendingBridgeOps = null
         }
     }
 
+    @ReactMethod
+    override fun destroy() {
+        bridge?.teardown()
+        bridge = null
+    }
+
     @ReactMethod
     override fun setUserId(userId: String) {
-        shortKit?.setUserId(userId)
+        bridge?.setUserId(userId)
     }
 
     @ReactMethod
     override fun clearUserId() {
-        shortKit?.clearUserId()
+        bridge?.clearUserId()
     }
 
     @ReactMethod
     override fun onPause() {
-        shortKit?.pause()
+        bridge?.onPause()
     }
 
-    /// Called when the app foregrounds. We do NOT auto-resume here because:
-    /// 1. The user may have manually paused before backgrounding.
-    /// 2. The ShortKit SDK's internal lifecycle management already resumes
-    ///    playback when appropriate via Activity lifecycle callbacks.
     @ReactMethod
     override fun onResume() {
-        // No-op: let the SDK's internal lifecycle handle resume
+        bridge?.onResume()
     }
 
-    @ReactMethod
-    override fun destroy() {
-        teardown()
-    }
-
-    // -----------------------------------------------------------------------
+    // -----------------------------------------------------------------
     // Player controls
-    // -----------------------------------------------------------------------
+    // -----------------------------------------------------------------
 
     @ReactMethod
-    override fun play() {
-        shortKit?.player?.play()
-    }
+    override fun play() { bridge?.play() }
 
     @ReactMethod
-    override fun pause() {
-        shortKit?.player?.pause()
-    }
+    override fun pause() { bridge?.pause() }
 
     @ReactMethod
-    override fun seek(seconds: Double) {
-        shortKit?.player?.seek(seconds)
-    }
+    override fun seek(seconds: Double) { bridge?.seek(seconds) }
 
     @ReactMethod
-    override fun seekAndPlay(seconds: Double) {
-        shortKit?.player?.seekAndPlay(seconds)
-    }
+    override fun seekAndPlay(seconds: Double) { bridge?.seekAndPlay(seconds) }
 
     @ReactMethod
-    override fun skipToNext() {
-        shortKit?.player?.skipToNext()
-    }
+    override fun skipToNext() { bridge?.skipToNext() }
 
     @ReactMethod
-    override fun skipToPrevious() {
-        shortKit?.player?.skipToPrevious()
-    }
+    override fun skipToPrevious() { bridge?.skipToPrevious() }
 
     @ReactMethod
-    override fun setMuted(muted: Boolean) {
-        shortKit?.player?.setMuted(muted)
-    }
+    override fun setMuted(muted: Boolean) { bridge?.setMuted(muted) }
 
     @ReactMethod
-    override fun setPlaybackRate(rate: Double) {
-        shortKit?.player?.setPlaybackRate(rate.toFloat())
-    }
+    override fun setPlaybackRate(rate: Double) { bridge?.setPlaybackRate(rate) }
 
     @ReactMethod
-    override fun setCaptionsEnabled(enabled: Boolean) {
-        shortKit?.player?.setCaptionsEnabled(enabled)
-    }
+    override fun setCaptionsEnabled(enabled: Boolean) { bridge?.setCaptionsEnabled(enabled) }
 
     @ReactMethod
-    override fun selectCaptionTrack(language: String) {
-        shortKit?.player?.selectCaptionTrack(language)
-    }
+    override fun selectCaptionTrack(language: String) { bridge?.selectCaptionTrack(language) }
 
     @ReactMethod
-    override fun sendContentSignal(signal: String) {
-        val contentSignal = if (signal == "positive") ContentSignal.POSITIVE else ContentSignal.NEGATIVE
-        shortKit?.player?.sendContentSignal(contentSignal)
-    }
+    override fun sendContentSignal(signal: String) { bridge?.sendContentSignal(signal) }
 
     @ReactMethod
-    override fun setMaxBitrate(bitrate: Double) {
-        shortKit?.player?.setMaxBitrate(bitrate.toInt())
-    }
+    override fun setMaxBitrate(bitrate: Double) { bridge?.setMaxBitrate(bitrate) }
 
-    // -----------------------------------------------------------------------
+    // -----------------------------------------------------------------
     // Custom feed
-    // -----------------------------------------------------------------------
+    // -----------------------------------------------------------------
 
     @ReactMethod
-    override fun setFeedItems(items: String) {
-        val sdk = shortKit
-        if (sdk != null) {
-            val parsed = parseFeedInputs(items) ?: return
-            sdk.setFeedItems(parsed)
+    override fun setFeedItems(feedId: String, items: String) {
+        val b = bridge
+        if (b != null) {
+            b.setFeedItems(feedId, items)
         } else {
-            pendingFeedItems = items
+            bufferOp { bridge?.setFeedItems(feedId, items) }
         }
     }
 
     @ReactMethod
-    override fun appendFeedItems(items: String) {
-        val sdk = shortKit
-        if (sdk != null) {
-            val parsed = parseFeedInputs(items) ?: return
-            sdk.appendFeedItems(parsed)
+    override fun appendFeedItems(feedId: String, items: String) {
+        val b = bridge
+        if (b != null) {
+            b.appendFeedItems(feedId, items)
         } else {
-            pendingAppendItems = items
+            bufferOp { bridge?.appendFeedItems(feedId, items) }
         }
     }
 
     @ReactMethod
-    override fun fetchContent(limit: Double, promise: com.facebook.react.bridge.Promise) {
-        val sdk = shortKit
-        if (sdk == null) {
+    override fun fetchContent(limit: Double, filterJSON: String?, promise: Promise) {
+        val b = bridge
+        if (b == null) {
             promise.resolve("[]")
             return
         }
-        scope?.launch {
-            try {
-                val items = sdk.fetchContent(limit.toInt())
-                val arr = JSONArray()
-                for (item in items) {
-                    arr.put(JSONObject(serializeContentItemToJSON(item)))
-                }
-                promise.resolve(arr.toString())
-            } catch (e: Exception) {
-                promise.resolve("[]")
-            }
-        }
+        b.fetchContent(limit.toInt(), filterJSON) { result -> promise.resolve(result) }
     }
 
-    // -----------------------------------------------------------------------
-    // Storyboard / Seek Thumbnails
-    // -----------------------------------------------------------------------
-
     @ReactMethod
-    override fun prefetchStoryboard(playbackId: String) {
-        shortKit?.player?.prefetchStoryboard(playbackId)
+    override fun applyFilter(feedId: String, filterJSON: String?) {
+        val b = bridge
+        if (b != null) {
+            b.applyFilter(feedId, filterJSON)
+        } else {
+            bufferOp { bridge?.applyFilter(feedId, filterJSON) }
+        }
     }
 
     @ReactMethod
-    override fun getStoryboardData(playbackId: String, promise: com.facebook.react.bridge.Promise) {
-        val player = shortKit?.player
-        if (player == null) {
-            promise.resolve(null)
-            return
-        }
-        // Try cached data first
-        val json = player.getStoryboardData(playbackId)
-        if (json != null) {
-            promise.resolve(json)
+    override fun preloadFeed(configJSON: String, promise: Promise) {
+        val b = bridge
+        if (b == null) {
+            promise.resolve("")
             return
         }
-        // Trigger prefetch and retry after a short delay
-        player.prefetchStoryboard(playbackId)
-        scope?.launch {
-            // Wait for prefetch to complete (poll with timeout)
-            var retries = 0
-            while (retries < 30) { // 3 seconds max
-                kotlinx.coroutines.delay(100)
-                val data = player.getStoryboardData(playbackId)
-                if (data != null) {
-                    promise.resolve(data)
-                    return@launch
-                }
-                retries++
-            }
-            promise.resolve(null)
-        }
-    }
-
-    // -----------------------------------------------------------------------
-    // Overlay lifecycle events (called by Fabric view)
-    // -----------------------------------------------------------------------
-
-    fun emitOverlayEvent(name: String, item: ContentItem) {
-        val params = Arguments.createMap().apply {
-            putString("item", serializeContentItemToJSON(item))
-        }
-        sendEvent(name, params)
-    }
-
-    fun emitOverlayEvent(name: String, params: WritableMap) {
-        sendEvent(name, params)
+        b.preloadFeed(configJSON) { result -> promise.resolve(result) }
     }
 
-    // -----------------------------------------------------------------------
-    // Carousel overlay lifecycle events
-    // -----------------------------------------------------------------------
+    // -----------------------------------------------------------------
+    // Storyboard / Seek Thumbnails
+    // -----------------------------------------------------------------
 
-    fun emitCarouselOverlayEvent(name: String, params: WritableMap) {
-        sendEvent(name, params)
+    @ReactMethod
+    override fun prefetchStoryboard(playbackId: String) {
+        bridge?.prefetchStoryboard(playbackId)
     }
 
-    // -----------------------------------------------------------------------
-    // Flow subscriptions
-    // -----------------------------------------------------------------------
-
-    private fun subscribeToFlows(player: ShortKitPlayer) {
-        scope?.cancel()
-        val newScope = CoroutineScope(Dispatchers.Main + SupervisorJob())
-        scope = newScope
-
-        // Player state
-        newScope.launch {
-            player.playerState.collect { state ->
-                val params = Arguments.createMap().apply {
-                    putString("state", playerStateString(state))
-                    if (state is com.shortkit.PlayerState.Error) {
-                        putString("errorMessage", state.message)
-                    }
-                }
-                sendEvent("onPlayerStateChanged", params)
-            }
-        }
-
-        // Current item
-        newScope.launch {
-            player.currentItem.collect { item ->
-                if (item != null) {
-                    sendEvent("onCurrentItemChanged", contentItemMap(item))
-                }
-            }
-        }
-
-        // Time updates
-        newScope.launch {
-            player.time.collect { time ->
-                val params = Arguments.createMap().apply {
-                    putDouble("current", time.currentMs / 1000.0)
-                    putDouble("duration", time.durationMs / 1000.0)
-                    putDouble("buffered", time.bufferedMs / 1000.0)
-                }
-                sendEvent("onTimeUpdate", params)
-            }
-        }
-
-        // Muted state
-        newScope.launch {
-            player.isMuted.collect { muted ->
-                val params = Arguments.createMap().apply {
-                    putBoolean("isMuted", muted)
-                }
-                sendEvent("onMutedChanged", params)
-            }
-        }
-
-        // Playback rate
-        newScope.launch {
-            player.playbackRate.collect { rate ->
-                val params = Arguments.createMap().apply {
-                    putDouble("rate", rate.toDouble())
-                }
-                sendEvent("onPlaybackRateChanged", params)
-            }
-        }
-
-        // Captions enabled
-        newScope.launch {
-            player.captionsEnabled.collect { enabled ->
-                val params = Arguments.createMap().apply {
-                    putBoolean("enabled", enabled)
-                }
-                sendEvent("onCaptionsEnabledChanged", params)
-            }
-        }
-
-        // Active caption track
-        newScope.launch {
-            player.activeCaptionTrack.collect { track ->
-                if (track != null) {
-                    val params = Arguments.createMap().apply {
-                        putString("language", track.language)
-                        putString("label", track.label)
-                        putString("sourceUrl", track.url ?: "")
-                    }
-                    sendEvent("onActiveCaptionTrackChanged", params)
-                }
-            }
-        }
-
-        // Active cue (ms -> seconds)
-        newScope.launch {
-            player.activeCue.collect { cue ->
-                if (cue != null) {
-                    val params = Arguments.createMap().apply {
-                        putString("text", cue.text)
-                        putDouble("startTime", cue.startMs / 1000.0)
-                        putDouble("endTime", cue.endMs / 1000.0)
-                    }
-                    sendEvent("onActiveCueChanged", params)
-                }
-            }
-        }
-
-        // Did loop
-        newScope.launch {
-            player.didLoop.collect { event ->
-                val params = Arguments.createMap().apply {
-                    putString("contentId", event.contentId)
-                    putInt("loopCount", event.loopCount)
-                }
-                sendEvent("onDidLoop", params)
-            }
-        }
-
-        // Feed transition
-        newScope.launch {
-            player.feedTransition.collect { event ->
-                val params = Arguments.createMap().apply {
-                    putString("phase", when (event.phase) {
-                        FeedTransitionPhase.BEGAN -> "began"
-                        FeedTransitionPhase.ENDED -> "ended"
-                    })
-                    putString("direction", when (event.direction) {
-                        com.shortkit.FeedDirection.FORWARD -> "forward"
-                        com.shortkit.FeedDirection.BACKWARD -> "backward"
-                        else -> "forward"
-                    })
-                    if (event.from != null) {
-                        putString("fromItem", serializeContentItemToJSON(event.from!!))
-                    }
-                    if (event.to != null) {
-                        putString("toItem", serializeContentItemToJSON(event.to!!))
-                    }
-                }
-                sendEvent("onFeedTransition", params)
-            }
-        }
-
-        // Format change (Long -> Double for bitrate)
-        newScope.launch {
-            player.formatChange.collect { event ->
-                val params = Arguments.createMap().apply {
-                    putString("contentId", event.contentId)
-                    putDouble("fromBitrate", event.fromBitrate.toDouble())
-                    putDouble("toBitrate", event.toBitrate.toDouble())
-                    putString("fromResolution", event.fromResolution ?: "")
-                    putString("toResolution", event.toResolution ?: "")
-                }
-                sendEvent("onFormatChange", params)
-            }
-        }
-
-        // Prefetched ahead count
-        newScope.launch {
-            player.prefetchedAheadCount.collect { count ->
-                val params = Arguments.createMap().apply {
-                    putInt("count", count)
-                }
-                sendEvent("onPrefetchedAheadCountChanged", params)
-            }
-        }
-
-        // Remaining content count
-        newScope.launch {
-            player.remainingContentCount.collect { count ->
-                val params = Arguments.createMap().apply {
-                    putInt("count", count)
-                }
-                sendEvent("onRemainingContentCountChanged", params)
-            }
+    @ReactMethod
+    override fun getStoryboardData(playbackId: String, promise: Promise) {
+        val b = bridge
+        if (b == null) {
+            promise.resolve(null)
+            return
         }
+        b.getStoryboardData(playbackId) { result -> promise.resolve(result) }
     }
 
-    // -----------------------------------------------------------------------
+    // -----------------------------------------------------------------
     // Event emission
-    // -----------------------------------------------------------------------
+    // -----------------------------------------------------------------
 
     private fun sendEvent(name: String, params: WritableMap) {
-        if (!hasListeners) return
+        // 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.
         try {
             reactApplicationContext
                 .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
                 .emit(name, params)
-        } catch (_: Exception) {
-            // Context may not have an active catalyst instance during teardown
+        } catch (e: Exception) {
+            android.util.Log.e("SK:Module", "sendEvent($name) EXCEPTION: ${e.message}", e)
         }
     }
 
-    // -----------------------------------------------------------------------
-    // Teardown
-    // -----------------------------------------------------------------------
+    // -----------------------------------------------------------------
+    // Op buffering
+    // -----------------------------------------------------------------
 
-    private fun teardown() {
-        scope?.cancel()
-        scope = null
-        shortKit?.release()
-        shortKit = null
-        if (shared === this) shared = null
-    }
-
-    // -----------------------------------------------------------------------
-    // Content item serialization
-    // -----------------------------------------------------------------------
-
-    /**
-     * Build a flat WritableMap for `onCurrentItemChanged`.
-     * `captionTracks` and `customMetadata` are JSON-serialized strings.
-     */
-    private fun contentItemMap(item: ContentItem): WritableMap {
-        return Arguments.createMap().apply {
-            putString("id", item.id)
-            item.playbackId?.let { putString("playbackId", it) }
-            putString("title", item.title)
-            item.description?.let { putString("description", it) }
-            putDouble("duration", item.duration)
-            putString("streamingUrl", item.streamingUrl)
-            putString("thumbnailUrl", item.thumbnailUrl)
-
-            // Caption tracks as JSON string
-            putString("captionTracks", serializeCaptionTracks(item.captionTracks))
-
-            // Custom metadata as JSON string
-            item.customMetadata?.let { meta ->
-                putString("customMetadata", serializeCustomMetadata(meta))
-            }
-
-            item.author?.let { putString("author", it) }
-            item.articleUrl?.let { putString("articleUrl", it) }
-            item.commentCount?.let { putInt("commentCount", it) }
-        }
-    }
-
-    /**
-     * Serialize a full ContentItem to a JSON string for delegate/overlay events.
-     */
-    private fun serializeContentItemToJSON(item: ContentItem): String {
-        return try {
-            val obj = JSONObject().apply {
-                put("id", item.id)
-                put("title", item.title)
-                item.description?.let { put("description", it) }
-                put("duration", item.duration)
-                put("streamingUrl", item.streamingUrl)
-                put("thumbnailUrl", item.thumbnailUrl)
-                put("captionTracks", buildCaptionTracksJSONArray(item.captionTracks))
-                item.customMetadata?.let { put("customMetadata", buildCustomMetadataJSONObject(it)) }
-                item.author?.let { put("author", it) }
-                item.articleUrl?.let { put("articleUrl", it) }
-                item.commentCount?.let { put("commentCount", it) }
-            }
-            obj.toString()
-        } catch (_: Exception) {
-            "{}"
-        }
-    }
-
-    /**
-     * Serialize caption tracks list to a JSON string: `[{"language":"en","label":"English","sourceUrl":"..."}]`
-     */
-    private fun serializeCaptionTracks(tracks: List<com.shortkit.CaptionTrack>): String {
-        return try {
-            buildCaptionTracksJSONArray(tracks).toString()
-        } catch (_: Exception) {
-            "[]"
-        }
-    }
-
-    private fun buildCaptionTracksJSONArray(tracks: List<com.shortkit.CaptionTrack>): JSONArray {
-        val arr = JSONArray()
-        for (track in tracks) {
-            val obj = JSONObject().apply {
-                put("language", track.language)
-                put("label", track.label)
-                put("sourceUrl", track.url ?: "")
-            }
-            arr.put(obj)
-        }
-        return arr
-    }
-
-    /**
-     * Serialize custom metadata map to a JSON string.
-     */
-    private fun serializeCustomMetadata(meta: Map<String, JsonValue>): String {
-        return try {
-            buildCustomMetadataJSONObject(meta).toString()
-        } catch (_: Exception) {
-            "{}"
-        }
-    }
-
-    private fun buildCustomMetadataJSONObject(meta: Map<String, JsonValue>): JSONObject {
-        val obj = JSONObject()
-        for ((key, value) in meta) {
-            obj.put(key, jsonValueToAny(value))
-        }
-        return obj
-    }
-
-    /**
-     * Convert a ShortKit JsonValue sealed class to a native type suitable for JSONObject.
-     */
-    private fun jsonValueToAny(value: JsonValue): Any {
-        return when (value) {
-            is JsonValue.StringValue -> value.value
-            is JsonValue.NumberValue -> value.value
-            is JsonValue.BoolValue -> value.value
-            is JsonValue.ObjectValue -> {
-                val obj = JSONObject()
-                for ((k, v) in value.value) {
-                    obj.put(k, jsonValueToAny(v))
-                }
-                obj
-            }
-            is JsonValue.NullValue -> JSONObject.NULL
-        }
-    }
-
-    // -----------------------------------------------------------------------
-    // Player state serialization
-    // -----------------------------------------------------------------------
-
-    private fun playerStateString(state: com.shortkit.PlayerState): String {
-        return when (state) {
-            is com.shortkit.PlayerState.Idle -> "idle"
-            is com.shortkit.PlayerState.Loading -> "loading"
-            is com.shortkit.PlayerState.Ready -> "ready"
-            is com.shortkit.PlayerState.Playing -> "playing"
-            is com.shortkit.PlayerState.Paused -> "paused"
-            is com.shortkit.PlayerState.Seeking -> "seeking"
-            is com.shortkit.PlayerState.Buffering -> "buffering"
-            is com.shortkit.PlayerState.Ended -> "ended"
-            is com.shortkit.PlayerState.Error -> "error"
-        }
-    }
-
-    // -----------------------------------------------------------------------
-    // Config parsing
-    // -----------------------------------------------------------------------
-
-    /**
-     * Parse the JSON config string from JS into a FeedConfig.
-     *
-     * Expected JSON shape:
-     * ```json
-     * {
-     *   "feedHeight": "{\"type\":\"fullscreen\"}",
-     *   "overlay": "\"none\"",
-     *   "carouselMode": "\"none\"",
-     *   "surveyMode": "\"none\"",
-     *   "muteOnStart": true
-     * }
-     * ```
-     */
-    private fun parseFeedConfig(json: String): FeedConfig {
-        return try {
-            val obj = JSONObject(json)
-
-            val feedHeight = parseFeedHeight(obj.optString("feedHeight", null))
-            val muteOnStart = obj.optBoolean("muteOnStart", true)
-            val videoOverlay = parseVideoOverlay(obj.optString("overlay", null))
-
-            val feedSourceStr = obj.optString("feedSource", "algorithmic")
-            val feedSource = if (feedSourceStr == "custom") FeedSource.CUSTOM else FeedSource.ALGORITHMIC
-
-            val carouselOverlay = parseCarouselOverlay(obj.optString("carouselOverlay", null))
-
-            FeedConfig(
-                feedHeight = feedHeight,
-                videoOverlay = videoOverlay,
-                carouselOverlay = carouselOverlay,
-                surveyOverlay = SurveyOverlayMode.None,
-                adOverlay = AdOverlayMode.None,
-                muteOnStart = muteOnStart,
-                feedSource = feedSource
-            )
-        } catch (_: Exception) {
-            FeedConfig()
-        }
-    }
-
-    /**
-     * Parse a double-stringified feedHeight JSON.
-     * e.g. `"{\"type\":\"fullscreen\"}"` or `"{\"type\":\"percentage\",\"value\":0.8}"`
-     */
-    private fun parseFeedHeight(json: String?): FeedHeight {
-        if (json.isNullOrEmpty()) return FeedHeight.Fullscreen
-        return try {
-            val obj = JSONObject(json)
-            when (obj.optString("type")) {
-                "percentage" -> {
-                    val value = obj.optDouble("value", 1.0)
-                    FeedHeight.Percentage(value.toFloat())
-                }
-                else -> FeedHeight.Fullscreen
-            }
-        } catch (_: Exception) {
-            FeedHeight.Fullscreen
-        }
-    }
-
-    /**
-     * Parse a double-stringified overlay JSON.
-     * - `"\"none\""` -> None
-     * - `"{\"type\":\"custom\"}"` -> Custom with bridge overlay factory
-     */
-    private fun parseVideoOverlay(json: String?): VideoOverlayMode {
-        if (json.isNullOrEmpty()) return VideoOverlayMode.None
-        return try {
-            // Try parsing — might be a simple string "none" or an object
-            val parsed = json.trim()
-
-            // Strip outer quotes if double-stringified simple string
-            if (parsed == "\"none\"" || parsed == "none") {
-                return VideoOverlayMode.None
-            }
-
-            // Try as JSON object
-            val inner = if (parsed.startsWith("\"") && parsed.endsWith("\"")) {
-                // Double-stringified: strip outer quotes and unescape
-                JSONObject(parsed.substring(1, parsed.length - 1).replace("\\\"", "\""))
-            } else {
-                JSONObject(parsed)
-            }
-
-            if (inner.optString("type") == "custom") {
-                // The Fabric view will handle the actual overlay view creation.
-                // For the module, we signal custom mode so the SDK allocates an overlay slot.
-                VideoOverlayMode.Custom { ShortKitOverlayBridge(reactApplicationContext) }
-            } else {
-                VideoOverlayMode.None
-            }
-        } catch (_: Exception) {
-            VideoOverlayMode.None
-        }
-    }
-
-    /**
-     * Parse a double-stringified carousel overlay JSON.
-     * - `"\"none\""` -> None
-     * - `"{\"type\":\"custom\"}"` -> Custom with bridge overlay factory
-     */
-    private fun parseCarouselOverlay(json: String?): CarouselOverlayMode {
-        if (json.isNullOrEmpty()) return CarouselOverlayMode.None
-        return try {
-            val parsed = json.trim()
-
-            if (parsed == "\"none\"" || parsed == "none") {
-                return CarouselOverlayMode.None
-            }
-
-            val inner = if (parsed.startsWith("\"") && parsed.endsWith("\"")) {
-                JSONObject(parsed.substring(1, parsed.length - 1).replace("\\\"", "\""))
-            } else {
-                JSONObject(parsed)
-            }
-
-            if (inner.optString("type") == "custom") {
-                CarouselOverlayMode.Custom { ShortKitCarouselOverlayBridge(reactApplicationContext) }
-            } else {
-                CarouselOverlayMode.None
-            }
-        } catch (_: Exception) {
-            CarouselOverlayMode.None
-        }
-    }
-
-    private fun parseFeedInputs(json: String): List<FeedInput>? {
-        return try {
-            val arr = JSONArray(json)
-            val result = mutableListOf<FeedInput>()
-            for (i in 0 until arr.length()) {
-                val obj = arr.getJSONObject(i)
-                when (obj.optString("type")) {
-                    "video" -> {
-                        val playbackId = obj.optString("playbackId", null) ?: continue
-                        result.add(FeedInput.Video(playbackId))
-                    }
-                    "imageCarousel" -> {
-                        val itemObj = obj.optJSONObject("item") ?: continue
-                        val carouselItem = parseImageCarouselItem(itemObj) ?: continue
-                        result.add(FeedInput.ImageCarousel(carouselItem))
-                    }
-                }
-            }
-            result.ifEmpty { null }
-        } catch (_: Exception) {
-            null
-        }
-    }
-
-    private fun parseImageCarouselItem(obj: JSONObject): ImageCarouselItem? {
-        val id = obj.optString("id", null) ?: return null
-        val imagesArr = obj.optJSONArray("images") ?: return null
-        val images = mutableListOf<CarouselImage>()
-        for (i in 0 until imagesArr.length()) {
-            val imgObj = imagesArr.getJSONObject(i)
-            images.add(CarouselImage(
-                url = imgObj.getString("url"),
-                alt = imgObj.optString("alt", null)
-            ))
-        }
-        return ImageCarouselItem(
-            id = id,
-            images = images,
-            autoScrollInterval = if (obj.has("autoScrollInterval")) obj.getDouble("autoScrollInterval") else null,
-            caption = obj.optString("caption", null),
-            title = obj.optString("title", null),
-            description = obj.optString("description", null),
-            author = obj.optString("author", null),
-            section = obj.optString("section", null),
-            articleUrl = obj.optString("articleUrl", null)
-        )
-    }
-
-    /**
-     * Parse optional custom dimensions JSON string into map.
-     */
-    private fun parseCustomDimensions(json: String?): Map<String, String>? {
-        if (json.isNullOrEmpty()) return null
-        return try {
-            val obj = JSONObject(json)
-            val map = mutableMapOf<String, String>()
-            val keys = obj.keys()
-            while (keys.hasNext()) {
-                val key = keys.next()
-                map[key] = obj.getString(key)
-            }
-            map
-        } catch (_: Exception) {
-            null
-        }
+    private fun bufferOp(op: () -> Unit) {
+        if (pendingBridgeOps == null) pendingBridgeOps = mutableListOf()
+        pendingBridgeOps!!.add(op)
     }
 }