@shortkitsdk/react-native 0.1.0

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

@@ -0,0 +1,769 @@
+package com.shortkit.reactnative
+
+import com.facebook.react.bridge.Arguments
+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.ContentItem
+import com.shortkit.ContentSignal
+import com.shortkit.FeedConfig
+import com.shortkit.FeedHeight
+import com.shortkit.FeedTransitionPhase
+import com.shortkit.JsonValue
+import com.shortkit.OverlayActionDelegate
+import com.shortkit.ShortKit
+import com.shortkit.ShortKitDelegate
+import com.shortkit.ShortKitError
+import com.shortkit.ShortKitPlayer
+import com.shortkit.SurveyOption
+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
+
+class ShortKitModule(reactContext: ReactApplicationContext) :
+    NativeShortKitModuleSpec(reactContext),
+    ShortKitDelegate {
+
+    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 listenerCount = 0
+    @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
+        super.onCatalystInstanceDestroy()
+    }
+
+    // -----------------------------------------------------------------------
+    // Event listeners
+    // -----------------------------------------------------------------------
+
+    override fun addListener(eventType: String?) {
+        listenerCount++
+        hasListeners = true
+    }
+
+    override fun removeListeners(count: Double) {
+        listenerCount = maxOf(0, listenerCount - count.toInt())
+        hasListeners = listenerCount > 0
+    }
+
+    // -----------------------------------------------------------------------
+    // Lifecycle methods
+    // -----------------------------------------------------------------------
+
+    @ReactMethod
+    override fun initialize(
+        apiKey: String,
+        config: String,
+        clientAppName: String?,
+        clientAppVersion: String?,
+        customDimensions: String?
+    ) {
+        // Tear down any existing instance (re-init safety)
+        teardown()
+
+        val feedConfig = parseFeedConfig(config)
+        val dims = parseCustomDimensions(customDimensions)
+
+        val context = reactApplicationContext
+
+        val sdk = ShortKit(
+            context = context,
+            apiKey = apiKey,
+            config = feedConfig,
+            userId = null,
+            adProvider = null,
+            clientAppName = clientAppName,
+            clientAppVersion = clientAppVersion,
+            customDimensions = dims
+        )
+        sdk.delegate = this
+        sdk.overlayActionDelegate = overlayDelegate
+
+        this.shortKit = sdk
+        shared = this
+
+        subscribeToFlows(sdk.player)
+    }
+
+    @ReactMethod
+    override fun setUserId(userId: String) {
+        shortKit?.setUserId(userId)
+    }
+
+    @ReactMethod
+    override fun clearUserId() {
+        shortKit?.clearUserId()
+    }
+
+    @ReactMethod
+    override fun onPause() {
+        shortKit?.pause()
+    }
+
+    /// 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
+    }
+
+    @ReactMethod
+    override fun destroy() {
+        teardown()
+    }
+
+    // -----------------------------------------------------------------------
+    // Player controls
+    // -----------------------------------------------------------------------
+
+    @ReactMethod
+    override fun play() {
+        shortKit?.player?.play()
+    }
+
+    @ReactMethod
+    override fun pause() {
+        shortKit?.player?.pause()
+    }
+
+    @ReactMethod
+    override fun seek(seconds: Double) {
+        shortKit?.player?.seek(seconds)
+    }
+
+    @ReactMethod
+    override fun seekAndPlay(seconds: Double) {
+        shortKit?.player?.seekAndPlay(seconds)
+    }
+
+    @ReactMethod
+    override fun skipToNext() {
+        shortKit?.player?.skipToNext()
+    }
+
+    @ReactMethod
+    override fun skipToPrevious() {
+        shortKit?.player?.skipToPrevious()
+    }
+
+    @ReactMethod
+    override fun setMuted(muted: Boolean) {
+        shortKit?.player?.setMuted(muted)
+    }
+
+    @ReactMethod
+    override fun setPlaybackRate(rate: Double) {
+        shortKit?.player?.setPlaybackRate(rate.toFloat())
+    }
+
+    @ReactMethod
+    override fun setCaptionsEnabled(enabled: Boolean) {
+        shortKit?.player?.setCaptionsEnabled(enabled)
+    }
+
+    @ReactMethod
+    override fun selectCaptionTrack(language: String) {
+        shortKit?.player?.selectCaptionTrack(language)
+    }
+
+    @ReactMethod
+    override fun sendContentSignal(signal: String) {
+        val contentSignal = if (signal == "positive") ContentSignal.POSITIVE else ContentSignal.NEGATIVE
+        shortKit?.player?.sendContentSignal(contentSignal)
+    }
+
+    @ReactMethod
+    override fun setMaxBitrate(bitrate: Double) {
+        shortKit?.player?.setMaxBitrate(bitrate.toInt())
+    }
+
+    // -----------------------------------------------------------------------
+    // ShortKitDelegate
+    // -----------------------------------------------------------------------
+
+    override fun onError(error: ShortKitError) {
+        val params = Arguments.createMap().apply {
+            when (error) {
+                is ShortKitError.NetworkError -> {
+                    putString("code", "network_error")
+                    putString("message", error.cause?.localizedMessage ?: "Network error")
+                }
+                is ShortKitError.ApiError -> {
+                    putString("code", "api_error")
+                    putString("message", error.message ?: "API error")
+                }
+                is ShortKitError.PlayerError -> {
+                    putString("code", error.code)
+                    putString("message", error.message ?: "Player error")
+                }
+                is ShortKitError.ConfigError -> {
+                    putString("code", "config_error")
+                    putString("message", error.message ?: "Config error")
+                }
+                is ShortKitError.AuthError -> {
+                    putString("code", "auth_error")
+                    putString("message", "Invalid API key")
+                }
+            }
+        }
+        sendEvent("onError", params)
+    }
+
+    override fun onShareTapped(item: ContentItem) {
+        val params = Arguments.createMap().apply {
+            putString("item", serializeContentItemToJSON(item))
+        }
+        sendEvent("onShareTapped", params)
+    }
+
+    override fun onSurveyResponse(surveyId: String, option: SurveyOption) {
+        val params = Arguments.createMap().apply {
+            putString("surveyId", surveyId)
+            putString("optionId", option.id)
+            putString("optionText", option.text)
+        }
+        sendEvent("onSurveyResponse", params)
+    }
+
+    // We implement the optional delegate methods as no-ops; events are handled
+    // via StateFlow/SharedFlow subscriptions instead.
+    override fun onFeedReady() {}
+    override fun onContentChanged(item: ContentItem) {}
+    override fun onFeedEmpty() {}
+
+    // -----------------------------------------------------------------------
+    // OverlayActionDelegate (separate object to avoid signature clash with
+    // ShortKitDelegate.onShareTapped)
+    // -----------------------------------------------------------------------
+
+    private val overlayDelegate = object : OverlayActionDelegate {
+        override fun onReadMoreTapped(item: ContentItem) {
+            val params = Arguments.createMap().apply {
+                putString("item", serializeContentItemToJSON(item))
+            }
+            sendEvent("onArticleTapped", params)
+        }
+
+        override fun onShareTapped(item: ContentItem) {
+            val params = Arguments.createMap().apply {
+                putString("item", serializeContentItemToJSON(item))
+            }
+            sendEvent("onOverlayShareTapped", params)
+        }
+
+        override fun onCommentTapped(item: ContentItem) {
+            val params = Arguments.createMap().apply {
+                putString("item", serializeContentItemToJSON(item))
+            }
+            sendEvent("onCommentTapped", params)
+        }
+
+        override fun onSaveTapped(item: ContentItem) {
+            val params = Arguments.createMap().apply {
+                putString("item", serializeContentItemToJSON(item))
+            }
+            sendEvent("onSaveTapped", params)
+        }
+
+        override fun onLikeTapped(item: ContentItem) {
+            val params = Arguments.createMap().apply {
+                putString("item", serializeContentItemToJSON(item))
+            }
+            sendEvent("onLikeTapped", params)
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // 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)
+    }
+
+    // -----------------------------------------------------------------------
+    // 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)
+            }
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // Event emission
+    // -----------------------------------------------------------------------
+
+    private fun sendEvent(name: String, params: WritableMap) {
+        if (!hasListeners) return
+        try {
+            reactApplicationContext
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                .emit(name, params)
+        } catch (_: Exception) {
+            // Context may not have an active catalyst instance during teardown
+        }
+    }
+
+    // -----------------------------------------------------------------------
+    // Teardown
+    // -----------------------------------------------------------------------
+
+    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)
+            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))
+
+            FeedConfig(
+                feedHeight = feedHeight,
+                videoOverlay = videoOverlay,
+                carouselOverlay = CarouselOverlayMode.None,
+                surveyOverlay = SurveyOverlayMode.None,
+                adOverlay = AdOverlayMode.None,
+                muteOnStart = muteOnStart
+            )
+        } 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 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
+        }
+    }
+}