@shortkitsdk/react-native 0.1.0

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

@@ -0,0 +1,101 @@
+package com.shortkit.reactnative
+
+import android.content.Context
+import android.graphics.Color
+import android.view.GestureDetector
+import android.view.MotionEvent
+import android.widget.FrameLayout
+import com.facebook.react.bridge.Arguments
+import com.shortkit.ContentItem
+import com.shortkit.FeedOverlay
+import com.shortkit.ShortKitPlayer
+
+/**
+ * A transparent [FrameLayout] that implements [FeedOverlay] and bridges
+ * overlay lifecycle calls to JS events via [ShortKitModule].
+ *
+ * The actual overlay UI is rendered by React Native on the JS side through
+ * the `OverlayManager` component. This view simply relays the SDK lifecycle
+ * events so the JS overlay knows when to configure, activate, reset, etc.
+ *
+ * Android equivalent of iOS `ShortKitOverlayBridge.swift`.
+ */
+class ShortKitOverlayBridge(context: Context) : FrameLayout(context), FeedOverlay {
+
+    // -----------------------------------------------------------------------
+    // State
+    // -----------------------------------------------------------------------
+
+    /**
+     * Stores the last configured [ContentItem] so we can pass it with
+     * lifecycle events that don't receive the item as a parameter.
+     */
+    private var currentItem: ContentItem? = null
+
+    // -----------------------------------------------------------------------
+    // Gestures
+    // -----------------------------------------------------------------------
+
+    private val gestureDetector = GestureDetector(context, object : GestureDetector.SimpleOnGestureListener() {
+        override fun onSingleTapConfirmed(e: MotionEvent): Boolean {
+            ShortKitModule.shared?.emitOverlayEvent("onOverlayTap", Arguments.createMap())
+            return true
+        }
+
+        override fun onDoubleTap(e: MotionEvent): Boolean {
+            val params = Arguments.createMap().apply {
+                putDouble("x", e.x.toDouble())
+                putDouble("y", e.y.toDouble())
+            }
+            ShortKitModule.shared?.emitOverlayEvent("onOverlayDoubleTap", params)
+            return true
+        }
+    })
+
+    // -----------------------------------------------------------------------
+    // Init
+    // -----------------------------------------------------------------------
+
+    init {
+        setBackgroundColor(Color.TRANSPARENT)
+        isClickable = true
+    }
+
+    override fun onTouchEvent(event: MotionEvent): Boolean {
+        return gestureDetector.onTouchEvent(event) || super.onTouchEvent(event)
+    }
+
+    // -----------------------------------------------------------------------
+    // FeedOverlay
+    // -----------------------------------------------------------------------
+
+    override fun attach(player: ShortKitPlayer) {
+        // No-op on the native side. The JS overlay subscribes to player
+        // state via the TurboModule's flow publishers.
+    }
+
+    override fun configure(item: ContentItem) {
+        currentItem = item
+        ShortKitModule.shared?.emitOverlayEvent("onOverlayConfigure", item)
+    }
+
+    override fun resetPlaybackProgress() {
+        val item = currentItem ?: return
+        ShortKitModule.shared?.emitOverlayEvent("onOverlayReset", item)
+    }
+
+    override fun activatePlayback() {
+        val item = currentItem ?: return
+        ShortKitModule.shared?.emitOverlayEvent("onOverlayActivate", item)
+    }
+
+    override fun fadeOutForTransition() {
+        val item = currentItem ?: return
+        ShortKitModule.shared?.emitOverlayEvent("onOverlayFadeOut", item)
+    }
+
+    override fun restoreFromTransition() {
+        val item = currentItem ?: return
+        ShortKitModule.shared?.emitOverlayEvent("onOverlayRestore", item)
+    }
+}

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

@@ -0,0 +1,40 @@
+package com.shortkit.reactnative
+
+import com.facebook.react.TurboReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.uimanager.ViewManager
+
+class ShortKitPackage : TurboReactPackage() {
+
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+        return if (name == ShortKitModule.NAME) {
+            ShortKitModule(reactContext)
+        } else {
+            null
+        }
+    }
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        return ReactModuleInfoProvider {
+            mapOf(
+                ShortKitModule.NAME to ReactModuleInfo(
+                    ShortKitModule.NAME,    // name
+                    ShortKitModule.NAME,    // className
+                    false,                  // canOverrideExistingModule
+                    false,                  // needsEagerInit
+                    false,                  // isCxxModule
+                    true                    // isTurboModule
+                )
+            )
+        }
+    }
+
+    override fun createViewManagers(
+        reactContext: ReactApplicationContext
+    ): List<ViewManager<*, *>> {
+        return listOf(ShortKitFeedViewManager())
+    }
+}

package/app.plugin.js

@@ -0,0 +1 @@
+module.exports = require('./plugin/build');

package/ios/ShortKitBridge.swift

@@ -0,0 +1,537 @@
+import Foundation
+import Combine
+import ShortKit
+
+/// Swift bridge between the ShortKit SDK and the Obj-C++ TurboModule.
+///
+/// Holds the `ShortKit` instance, subscribes to all Combine publishers on
+/// `ShortKitPlayer`, and forwards events to JS via the delegate protocol.
+@objc public class ShortKitBridge: NSObject, ShortKitDelegate {
+
+    // MARK: - Shared instance (accessed by Fabric view manager in Task 13)
+
+    @objc public static var shared: ShortKitBridge?
+
+    // MARK: - Properties
+
+    private var shortKit: ShortKit?
+    private var cancellables = Set<AnyCancellable>()
+    private weak var delegate: ShortKitBridgeDelegateProtocol?
+
+    // MARK: - Init
+
+    @objc public init(
+        apiKey: String,
+        config configJSON: String,
+        clientAppName: String?,
+        clientAppVersion: String?,
+        customDimensions customDimensionsJSON: String?,
+        delegate: ShortKitBridgeDelegateProtocol
+    ) {
+        self.delegate = delegate
+        super.init()
+
+        let feedConfig = Self.parseFeedConfig(configJSON)
+        let dimensions = Self.parseCustomDimensions(customDimensionsJSON)
+
+        let sdk = ShortKit(
+            apiKey: apiKey,
+            config: feedConfig,
+            clientAppName: clientAppName,
+            clientAppVersion: clientAppVersion,
+            customDimensions: dimensions
+        )
+        sdk.delegate = self
+        self.shortKit = sdk
+
+        ShortKitBridge.shared = self
+
+        subscribeToPublishers(sdk.player)
+    }
+
+    // MARK: - Teardown
+
+    @objc public func teardown() {
+        cancellables.removeAll()
+        shortKit = nil
+        if ShortKitBridge.shared === self {
+            ShortKitBridge.shared = nil
+        }
+    }
+
+    // MARK: - Public accessors for Fabric view
+
+    /// The underlying ShortKit instance. Used by the Fabric view manager.
+    public var sdk: ShortKit? { shortKit }
+
+    // MARK: - Lifecycle
+
+    @objc public func setUserId(_ userId: String) {
+        shortKit?.setUserId(userId)
+    }
+
+    @objc public func clearUserId() {
+        shortKit?.clearUserId()
+    }
+
+    /// Called when the app backgrounds. The ShortKit SDK handles app lifecycle
+    /// internally (AudioSessionManager, PlayerManager), so we only pause here
+    /// as a safety net. The SDK's internal handling will also fire.
+    @objc public func onPause() {
+        shortKit?.player.pause()
+    }
+
+    /// Called when the app foregrounds. We do NOT auto-play here because:
+    /// 1. The user may have manually paused before backgrounding.
+    /// 2. The ShortKit SDK's internal lifecycle management already resumes
+    ///    playback when appropriate.
+    @objc public func onResume() {
+        // No-op: let the SDK's internal lifecycle handle resume
+    }
+
+    // MARK: - Player Commands
+
+    @objc public func play() {
+        shortKit?.player.play()
+    }
+
+    /// Named `doPause` to avoid collision with NSObject.
+    @objc public func doPause() {
+        shortKit?.player.pause()
+    }
+
+    @objc public func seekTo(_ seconds: Double) {
+        shortKit?.player.seek(to: seconds)
+    }
+
+    @objc public func seekAndPlayTo(_ seconds: Double) {
+        shortKit?.player.seekAndPlay(to: seconds)
+    }
+
+    @objc public func skipToNext() {
+        shortKit?.player.skipToNext()
+    }
+
+    @objc public func skipToPrevious() {
+        shortKit?.player.skipToPrevious()
+    }
+
+    @objc public func setMuted(_ muted: Bool) {
+        shortKit?.player.setMuted(muted)
+    }
+
+    @objc public func setPlaybackRate(_ rate: Double) {
+        shortKit?.player.setPlaybackRate(Float(rate))
+    }
+
+    @objc public func setCaptionsEnabled(_ enabled: Bool) {
+        shortKit?.player.setCaptionsEnabled(enabled)
+    }
+
+    @objc public func selectCaptionTrack(_ language: String) {
+        shortKit?.player.selectCaptionTrack(language: language)
+    }
+
+    @objc public func sendContentSignal(_ signal: String) {
+        let contentSignal: ContentSignal = signal == "positive" ? .positive : .negative
+        shortKit?.player.sendContentSignal(contentSignal)
+    }
+
+    @objc public func setMaxBitrate(_ bitrate: Double) {
+        shortKit?.player.setMaxBitrate(Int(bitrate))
+    }
+
+    // MARK: - ShortKitDelegate
+
+    public func shortKit(_ shortKit: ShortKit, didEncounterError error: ShortKitError) {
+        let body: [String: Any]
+        switch error {
+        case .networkError(let underlying):
+            body = ["code": "network_error", "message": underlying.localizedDescription]
+        case .playbackError(let code, let message):
+            body = ["code": code, "message": message]
+        case .authError:
+            body = ["code": "auth_error", "message": "Invalid API key"]
+        }
+        emitOnMain("onError", body: body)
+    }
+
+    public func shortKit(_ shortKit: ShortKit, didTapShareFor item: ContentItem) {
+        emitOnMain("onShareTapped", body: ["item": serializeContentItemToJSON(item)])
+    }
+
+    public func shortKit(_ shortKit: ShortKit, didRespondToSurvey surveyId: String, with option: SurveyOption) {
+        emitOnMain("onSurveyResponse", body: [
+            "surveyId": surveyId,
+            "optionId": option.id,
+            "optionText": option.text
+        ])
+    }
+
+    // MARK: - Combine Subscriptions
+
+    private func subscribeToPublishers(_ player: ShortKitPlayer) {
+        // Player state
+        player.playerState
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] state in
+                var body: [String: Any] = ["state": Self.playerStateString(state)]
+                if case .error(let msg) = state {
+                    body["errorMessage"] = msg
+                }
+                self?.emit("onPlayerStateChanged", body: body)
+            }
+            .store(in: &cancellables)
+
+        // Current item
+        player.currentItem
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] item in
+                guard let item else { return }
+                self?.emit("onCurrentItemChanged", body: Self.contentItemDict(item))
+            }
+            .store(in: &cancellables)
+
+        // Time updates
+        player.time
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] time in
+                self?.emit("onTimeUpdate", body: [
+                    "current": time.current,
+                    "duration": time.duration,
+                    "buffered": time.buffered
+                ])
+            }
+            .store(in: &cancellables)
+
+        // Muted state
+        player.isMuted
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] muted in
+                self?.emit("onMutedChanged", body: ["isMuted": muted])
+            }
+            .store(in: &cancellables)
+
+        // Playback rate
+        player.playbackRate
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] rate in
+                self?.emit("onPlaybackRateChanged", body: ["rate": Double(rate)])
+            }
+            .store(in: &cancellables)
+
+        // Captions enabled
+        player.captionsEnabled
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] enabled in
+                self?.emit("onCaptionsEnabledChanged", body: ["enabled": enabled])
+            }
+            .store(in: &cancellables)
+
+        // Active caption track
+        player.activeCaptionTrack
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] track in
+                guard let track else { return }
+                self?.emit("onActiveCaptionTrackChanged", body: [
+                    "language": track.language,
+                    "label": track.label,
+                    "sourceUrl": track.url ?? ""
+                ])
+            }
+            .store(in: &cancellables)
+
+        // Active cue
+        player.activeCue
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] cue in
+                guard let cue else { return }
+                self?.emit("onActiveCueChanged", body: [
+                    "text": cue.text,
+                    "startTime": cue.startTime,
+                    "endTime": cue.endTime
+                ])
+            }
+            .store(in: &cancellables)
+
+        // Did loop
+        player.didLoop
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] event in
+                self?.emit("onDidLoop", body: [
+                    "contentId": event.contentId,
+                    "loopCount": event.loopCount
+                ])
+            }
+            .store(in: &cancellables)
+
+        // Feed transition
+        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)
+                }
+                self.emit("onFeedTransition", body: body)
+            }
+            .store(in: &cancellables)
+
+        // Format change
+        player.formatChange
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] event in
+                self?.emit("onFormatChange", body: [
+                    "contentId": event.contentId,
+                    "fromBitrate": Double(event.fromBitrate),
+                    "toBitrate": Double(event.toBitrate),
+                    "fromResolution": event.fromResolution,
+                    "toResolution": event.toResolution
+                ])
+            }
+            .store(in: &cancellables)
+
+        // Prefetched ahead count
+        player.prefetchedAheadCount
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] count in
+                self?.emit("onPrefetchedAheadCountChanged", body: ["count": count])
+            }
+            .store(in: &cancellables)
+    }
+
+    // MARK: - Event Emission Helpers
+
+    private func emit(_ name: String, body: [String: Any]) {
+        delegate?.emitEvent(name, body: body)
+    }
+
+    private func emitOnMain(_ name: String, body: [String: Any]) {
+        if Thread.isMainThread {
+            emit(name, body: body)
+        } else {
+            DispatchQueue.main.async { [weak self] in
+                self?.emit(name, body: body)
+            }
+        }
+    }
+
+    // MARK: - Overlay Lifecycle Events (called by Fabric view in Task 13)
+
+    /// Emit overlay lifecycle events from the Fabric view's overlay container.
+    public func emitOverlayEvent(_ name: String, item: ContentItem) {
+        emitOnMain(name, body: ["item": serializeContentItemToJSON(item)])
+    }
+
+    /// Emit a raw overlay event with an arbitrary body.
+    public func emitOverlayEvent(_ name: String, body: [String: Any]) {
+        emitOnMain(name, body: body)
+    }
+
+    /// Emit an article tap event.
+    public func emitArticleTapped(_ item: ContentItem) {
+        emitOnMain("onArticleTapped", body: ["item": serializeContentItemToJSON(item)])
+    }
+
+    /// Emit a comment tap event.
+    public func emitCommentTapped(_ item: ContentItem) {
+        emitOnMain("onCommentTapped", body: ["item": serializeContentItemToJSON(item)])
+    }
+
+    /// Emit an overlay share tap event.
+    public func emitOverlayShareTapped(_ item: ContentItem) {
+        emitOnMain("onOverlayShareTapped", body: ["item": serializeContentItemToJSON(item)])
+    }
+
+    /// Emit a save tap event.
+    public func emitSaveTapped(_ item: ContentItem) {
+        emitOnMain("onSaveTapped", body: ["item": serializeContentItemToJSON(item)])
+    }
+
+    /// Emit a like tap event.
+    public func emitLikeTapped(_ item: ContentItem) {
+        emitOnMain("onLikeTapped", body: ["item": serializeContentItemToJSON(item)])
+    }
+
+    // MARK: - Content Item Serialization
+
+    /// Serialize a ContentItem to a JSON string for bridge transport.
+    private func serializeContentItemToJSON(_ item: ContentItem) -> String {
+        guard let data = try? JSONEncoder().encode(item),
+              let json = String(data: data, encoding: .utf8) else {
+            return "{}"
+        }
+        return json
+    }
+
+    /// 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] {
+        var dict: [String: Any] = [
+            "id": item.id,
+            "title": item.title,
+            "duration": item.duration,
+            "streamingUrl": item.streamingUrl,
+            "thumbnailUrl": item.thumbnailUrl,
+        ]
+
+        if let description = item.description {
+            dict["description"] = description
+        }
+
+        // Caption tracks as JSON string
+        if let tracksData = try? JSONEncoder().encode(item.captionTracks),
+           let tracksJSON = String(data: tracksData, encoding: .utf8) {
+            dict["captionTracks"] = tracksJSON
+        } else {
+            dict["captionTracks"] = "[]"
+        }
+
+        // Custom metadata as JSON string
+        if let meta = item.customMetadata,
+           let metaData = try? JSONEncoder().encode(meta),
+           let metaJSON = String(data: metaData, encoding: .utf8) {
+            dict["customMetadata"] = metaJSON
+        }
+
+        if let author = item.author {
+            dict["author"] = author
+        }
+        if let articleUrl = item.articleUrl {
+            dict["articleUrl"] = articleUrl
+        }
+        if let commentCount = item.commentCount {
+            dict["commentCount"] = commentCount
+        }
+
+        return dict
+    }
+
+    // MARK: - Player State Serialization
+
+    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"
+        }
+    }
+
+    private static func transitionPhaseString(_ phase: FeedTransitionEvent.Phase) -> String {
+        switch phase {
+        case .began: return "began"
+        case .ended: return "ended"
+        }
+    }
+
+    private static func transitionDirectionString(_ direction: FeedTransitionEvent.Direction) -> String {
+        switch direction {
+        case .forward: return "forward"
+        case .backward: return "backward"
+        }
+    }
+
+    // MARK: - Config Parsing
+
+    /// Parse the JSON config string from JS into a FeedConfig.
+    ///
+    /// Expected JSON structure:
+    /// ```json
+    /// {"feedHeight":"{\"type\":\"fullscreen\"}","overlay":"\"none\"",
+    ///  "carouselMode":"\"none\"","surveyMode":"\"none\"","muteOnStart":true}
+    /// ```
+    private static func parseFeedConfig(_ json: String) -> FeedConfig {
+        guard let data = json.data(using: .utf8),
+              let obj = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+            return FeedConfig()
+        }
+
+        let feedHeight = parseFeedHeight(obj["feedHeight"] as? String)
+        let muteOnStart = obj["muteOnStart"] as? Bool ?? true
+        let videoOverlay = parseVideoOverlay(obj["overlay"] as? String)
+
+        return FeedConfig(
+            feedHeight: feedHeight,
+            videoOverlay: videoOverlay,
+            carouselOverlay: .none,
+            surveyOverlay: .none,
+            adOverlay: .none,
+            muteOnStart: muteOnStart
+        )
+    }
+
+    /// Parse a double-stringified overlay JSON into a `VideoOverlayMode`.
+    ///
+    /// Examples:
+    /// - `"\"none\""` → `.none`
+    /// - `"{\"type\":\"custom\"}"` → `.custom { ShortKitOverlayBridge() }`
+    private static func parseVideoOverlay(_ json: String?) -> VideoOverlayMode {
+        guard let json,
+              let data = json.data(using: .utf8),
+              let parsed = try? JSONSerialization.jsonObject(with: data) else {
+            return .none
+        }
+
+        // Case 1: Simple string "none"
+        if let str = parsed as? String, str == "none" {
+            return .none
+        }
+
+        // Case 2: Object with "type" key
+        if let obj = parsed as? [String: Any],
+           let type = obj["type"] as? String,
+           type == "custom" {
+            return .custom { @Sendable in
+                let overlay = ShortKitOverlayBridge()
+                overlay.bridge = ShortKitBridge.shared
+                return overlay
+            }
+        }
+
+        return .none
+    }
+
+    /// Parse a double-stringified feedHeight JSON.
+    /// e.g. `"{\"type\":\"fullscreen\"}"` or `"{\"type\":\"percentage\",\"value\":0.8}"`
+    private static func parseFeedHeight(_ json: String?) -> FeedHeight {
+        guard let json,
+              let data = json.data(using: .utf8),
+              let obj = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+              let type = obj["type"] as? String else {
+            return .fullscreen
+        }
+
+        switch type {
+        case "percentage":
+            if let value = obj["value"] as? Double {
+                return .percentage(CGFloat(value))
+            }
+            return .fullscreen
+        default:
+            return .fullscreen
+        }
+    }
+
+    /// Parse optional custom dimensions JSON string into dictionary.
+    private static func parseCustomDimensions(_ json: String?) -> [String: String]? {
+        guard let json,
+              let data = json.data(using: .utf8),
+              let dict = try? JSONSerialization.jsonObject(with: data) as? [String: String] else {
+            return nil
+        }
+        return dict
+    }
+}