@shortkitsdk/react-native 0.2.0 → 0.2.2

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

@@ -0,0 +1,48 @@
+package com.shortkit.reactnative
+
+import android.content.Context
+import android.graphics.Color
+import android.widget.FrameLayout
+import com.facebook.react.bridge.Arguments
+import com.shortkit.sdk.model.ImageCarouselItem
+import com.shortkit.sdk.overlay.CarouselOverlay
+import kotlinx.serialization.encodeToString
+import kotlinx.serialization.json.Json
+
+/**
+ * A transparent [FrameLayout] that implements [CarouselOverlay] and bridges
+ * carousel overlay lifecycle calls to JS events via [ShortKitModule].
+ *
+ * The actual carousel overlay UI is rendered by React Native on the JS side
+ * through the `CarouselOverlayManager` component. This view simply relays
+ * the SDK lifecycle events so the JS carousel overlay knows when to
+ * configure, activate, reset, etc.
+ *
+ * Android equivalent of iOS `ShortKitCarouselOverlayBridge.swift`.
+ */
+class ShortKitCarouselOverlayBridge(context: Context) : FrameLayout(context), CarouselOverlay {
+
+    init {
+        setBackgroundColor(Color.TRANSPARENT)
+    }
+
+    override fun configure(item: ImageCarouselItem) {
+        val json = Json.encodeToString(item)
+        val params = Arguments.createMap().apply {
+            putString("item", json)
+        }
+        ShortKitModule.shared?.emitCarouselOverlayEvent("onCarouselOverlayConfigure", params)
+    }
+
+    override fun resetState() {
+        ShortKitModule.shared?.emitCarouselOverlayEvent("onCarouselOverlayReset", Arguments.createMap())
+    }
+
+    override fun fadeOutForTransition() {
+        ShortKitModule.shared?.emitCarouselOverlayEvent("onCarouselOverlayFadeOut", Arguments.createMap())
+    }
+
+    override fun restoreFromTransition() {
+        ShortKitModule.shared?.emitCarouselOverlayEvent("onCarouselOverlayRestore", Arguments.createMap())
+    }
+}

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

@@ -51,12 +51,18 @@ class ShortKitFeedView(context: Context) : FrameLayout(context) {
     private var viewPager: ViewPager2? = null
     private var pageChangeCallback: ViewPager2.OnPageChangeCallback? = null
 
-    /** Overlay for the currently active cell (nativeID="overlay-current"). */
+    /** Video overlay for the currently active cell (nativeID="overlay-current"). */
     private var currentOverlayView: View? = null
 
-    /** Overlay for the upcoming cell (nativeID="overlay-next"). */
+    /** Video overlay for the upcoming cell (nativeID="overlay-next"). */
     private var nextOverlayView: View? = null
 
+    /** Carousel overlay for the currently active cell (nativeID="carousel-overlay-current"). */
+    private var currentCarouselOverlayView: View? = null
+
+    /** Carousel overlay for the upcoming cell (nativeID="carousel-overlay-next"). */
+    private var nextCarouselOverlayView: View? = null
+
     /** The page index used for overlay transform calculations. */
     private var currentPage: Int = 0
 
@@ -158,8 +164,12 @@ class ShortKitFeedView(context: Context) : FrameLayout(context) {
         viewPager = null
         currentOverlayView?.translationY = 0f
         nextOverlayView?.translationY = 0f
+        currentCarouselOverlayView?.translationY = 0f
+        nextCarouselOverlayView?.translationY = 0f
         currentOverlayView = null
         nextOverlayView = null
+        currentCarouselOverlayView = null
+        nextCarouselOverlayView = null
     }
 
     private fun handleScrollOffset(
@@ -193,6 +203,8 @@ class ShortKitFeedView(context: Context) : FrameLayout(context) {
                     val h = height.toFloat()
                     currentOverlayView?.translationY = 0f
                     nextOverlayView?.translationY = h
+                    currentCarouselOverlayView?.translationY = 0f
+                    nextCarouselOverlayView?.translationY = h
                 }
                 pageUpdateRunnable = runnable
                 handler.postDelayed(runnable, 80)
@@ -219,17 +231,25 @@ class ShortKitFeedView(context: Context) : FrameLayout(context) {
         if (currentOverlayView == null || nextOverlayView == null) {
             findOverlayViews()
         }
+        if (currentCarouselOverlayView == null || nextCarouselOverlayView == null) {
+            findCarouselOverlayViews()
+        }
 
-        // Current overlay follows the active cell
+        // Current overlays follow the active cell
         currentOverlayView?.translationY = -delta
+        currentCarouselOverlayView?.translationY = -delta
 
-        // Next overlay: positioned one page ahead in the scroll direction
+        // Next overlays: positioned one page ahead in the scroll direction
         if (delta >= 0) {
             // Forward scroll (or idle): next cell is below
-            nextOverlayView?.translationY = cellHeight - delta
+            val nextY = cellHeight - delta
+            nextOverlayView?.translationY = nextY
+            nextCarouselOverlayView?.translationY = nextY
         } else {
             // Backward scroll: next cell is above
-            nextOverlayView?.translationY = -cellHeight - delta
+            val nextY = -cellHeight - delta
+            nextOverlayView?.translationY = nextY
+            nextCarouselOverlayView?.translationY = nextY
         }
     }
 
@@ -260,6 +280,28 @@ class ShortKitFeedView(context: Context) : FrameLayout(context) {
         }
     }
 
+    /**
+     * Find the sibling RN carousel overlay views by nativeID.
+     */
+    private fun findCarouselOverlayViews() {
+        var ancestor = parent as? ViewGroup ?: return
+        while (true) {
+            for (i in 0 until ancestor.childCount) {
+                val child = ancestor.getChildAt(i)
+                if (child === this || isOwnAncestor(child)) continue
+
+                if (currentCarouselOverlayView == null) {
+                    currentCarouselOverlayView = ReactFindViewUtil.findView(child, "carousel-overlay-current")
+                }
+                if (nextCarouselOverlayView == null) {
+                    nextCarouselOverlayView = ReactFindViewUtil.findView(child, "carousel-overlay-next")
+                }
+            }
+            if (currentCarouselOverlayView != null && nextCarouselOverlayView != null) return
+            ancestor = ancestor.parent as? ViewGroup ?: return
+        }
+    }
+
     /** Check if the given view is an ancestor of this view. */
     private fun isOwnAncestor(view: View): Boolean {
         var current: ViewParent? = parent

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

@@ -5,10 +5,14 @@ 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.CustomFeedItem
+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
@@ -46,6 +50,8 @@ class ShortKitModule(reactContext: ReactApplicationContext) :
     private var listenerCount = 0
     @Volatile
     private var hasListeners = false
+    private var pendingFeedItems: String? = null
+    private var pendingAppendItems: String? = null
 
     /** Expose the underlying SDK for the Fabric feed view manager. */
     val sdk: ShortKit? get() = shortKit
@@ -89,6 +95,7 @@ class ShortKitModule(reactContext: ReactApplicationContext) :
     override fun initialize(
         apiKey: String,
         config: String,
+        embedId: String?,
         clientAppName: String?,
         clientAppVersion: String?,
         customDimensions: String?
@@ -105,6 +112,7 @@ class ShortKitModule(reactContext: ReactApplicationContext) :
             context = context,
             apiKey = apiKey,
             config = feedConfig,
+            embedId = embedId,
             userId = null,
             adProvider = null,
             clientAppName = clientAppName,
@@ -114,7 +122,27 @@ class ShortKitModule(reactContext: ReactApplicationContext) :
         this.shortKit = sdk
         shared = this
 
+        // Replay any feed items that arrived before initialization
+        pendingFeedItems?.let { json ->
+            parseCustomFeedItems(json)?.let { sdk.setFeedItems(it) }
+            pendingFeedItems = null
+        }
+        pendingAppendItems?.let { json ->
+            parseCustomFeedItems(json)?.let { sdk.appendFeedItems(it) }
+            pendingAppendItems = null
+        }
+
         subscribeToFlows(sdk.player)
+
+        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)
+            }
+        }
     }
 
     @ReactMethod
@@ -211,6 +239,53 @@ class ShortKitModule(reactContext: ReactApplicationContext) :
         shortKit?.player?.setMaxBitrate(bitrate.toInt())
     }
 
+    // -----------------------------------------------------------------------
+    // Custom feed
+    // -----------------------------------------------------------------------
+
+    @ReactMethod
+    override fun setFeedItems(items: String) {
+        val sdk = shortKit
+        if (sdk != null) {
+            val parsed = parseCustomFeedItems(items) ?: return
+            sdk.setFeedItems(parsed)
+        } else {
+            pendingFeedItems = items
+        }
+    }
+
+    @ReactMethod
+    override fun appendFeedItems(items: String) {
+        val sdk = shortKit
+        if (sdk != null) {
+            val parsed = parseCustomFeedItems(items) ?: return
+            sdk.appendFeedItems(parsed)
+        } else {
+            pendingAppendItems = items
+        }
+    }
+
+    @ReactMethod
+    override fun fetchContent(limit: Double, promise: com.facebook.react.bridge.Promise) {
+        val sdk = shortKit
+        if (sdk == 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("[]")
+            }
+        }
+    }
+
     // -----------------------------------------------------------------------
     // Overlay lifecycle events (called by Fabric view)
     // -----------------------------------------------------------------------
@@ -226,6 +301,14 @@ class ShortKitModule(reactContext: ReactApplicationContext) :
         sendEvent(name, params)
     }
 
+    // -----------------------------------------------------------------------
+    // Carousel overlay lifecycle events
+    // -----------------------------------------------------------------------
+
+    fun emitCarouselOverlayEvent(name: String, params: WritableMap) {
+        sendEvent(name, params)
+    }
+
     // -----------------------------------------------------------------------
     // Flow subscriptions
     // -----------------------------------------------------------------------
@@ -385,6 +468,16 @@ class ShortKitModule(reactContext: ReactApplicationContext) :
                 sendEvent("onPrefetchedAheadCountChanged", params)
             }
         }
+
+        // Remaining content count
+        newScope.launch {
+            player.remainingContentCount.collect { count ->
+                val params = Arguments.createMap().apply {
+                    putInt("count", count)
+                }
+                sendEvent("onRemainingContentCountChanged", params)
+            }
+        }
     }
 
     // -----------------------------------------------------------------------
@@ -425,6 +518,7 @@ class ShortKitModule(reactContext: ReactApplicationContext) :
     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)
@@ -575,13 +669,19 @@ class ShortKitModule(reactContext: ReactApplicationContext) :
             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 = CarouselOverlayMode.None,
+                carouselOverlay = carouselOverlay,
                 surveyOverlay = SurveyOverlayMode.None,
                 adOverlay = AdOverlayMode.None,
-                muteOnStart = muteOnStart
+                muteOnStart = muteOnStart,
+                feedSource = feedSource
             )
         } catch (_: Exception) {
             FeedConfig()
@@ -644,6 +744,84 @@ class ShortKitModule(reactContext: ReactApplicationContext) :
         }
     }
 
+    /**
+     * 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 parseCustomFeedItems(json: String): List<CustomFeedItem>? {
+        return try {
+            val arr = JSONArray(json)
+            val result = mutableListOf<CustomFeedItem>()
+            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(CustomFeedItem.Video(playbackId))
+                    }
+                    "imageCarousel" -> {
+                        val itemObj = obj.optJSONObject("item") ?: continue
+                        val carouselItem = parseImageCarouselItem(itemObj) ?: continue
+                        result.add(CustomFeedItem.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.
      */

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

@@ -2,6 +2,8 @@ package com.shortkit.reactnative
 
 import android.content.Context
 import android.graphics.Color
+import android.os.Handler
+import android.os.Looper
 import android.view.GestureDetector
 import android.view.MotionEvent
 import android.widget.FrameLayout
@@ -32,6 +34,15 @@ class ShortKitOverlayBridge(context: Context) : FrameLayout(context), FeedOverla
      */
     private var currentItem: ContentItem? = null
 
+    /**
+     * Deferred configure emission — cancelled if [activatePlayback] fires
+     * on the same message-queue iteration (handleSwipe re-configure of the
+     * active cell, not a prefetch for the next cell).
+     */
+    private var pendingConfigureRunnable: Runnable? = null
+
+    private val handler = Handler(Looper.getMainLooper())
+
     // -----------------------------------------------------------------------
     // Gestures
     // -----------------------------------------------------------------------
@@ -76,7 +87,18 @@ class ShortKitOverlayBridge(context: Context) : FrameLayout(context), FeedOverla
 
     override fun configure(item: ContentItem) {
         currentItem = item
-        ShortKitModule.shared?.emitOverlayEvent("onOverlayConfigure", item)
+
+        // Defer the configure event by one message-queue tick. If activatePlayback()
+        // fires before then (handleSwipe sequence: configure → reset → activate),
+        // the event is cancelled — preventing nextItem from being overwritten
+        // with the current cell's data.
+        pendingConfigureRunnable?.let { handler.removeCallbacks(it) }
+        val runnable = Runnable {
+            currentItem?.let { ShortKitModule.shared?.emitOverlayEvent("onOverlayConfigure", it) }
+            pendingConfigureRunnable = null
+        }
+        pendingConfigureRunnable = runnable
+        handler.post(runnable)
     }
 
     override fun resetPlaybackProgress() {
@@ -85,6 +107,11 @@ class ShortKitOverlayBridge(context: Context) : FrameLayout(context), FeedOverla
     }
 
     override fun activatePlayback() {
+        // Cancel the pending configure — it was for the current cell (part of
+        // handleSwipe), not a prefetch for the next cell.
+        pendingConfigureRunnable?.let { handler.removeCallbacks(it) }
+        pendingConfigureRunnable = null
+
         val item = currentItem ?: return
         ShortKitModule.shared?.emitOverlayEvent("onOverlayActivate", item)
     }

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

@@ -35,6 +35,10 @@ class ShortKitPackage : TurboReactPackage() {
     override fun createViewManagers(
         reactContext: ReactApplicationContext
     ): List<ViewManager<*, *>> {
-        return listOf(ShortKitFeedViewManager())
+        return listOf(
+            ShortKitFeedViewManager(),
+            ShortKitPlayerViewManager(),
+            ShortKitWidgetViewManager(),
+        )
     }
 }

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

@@ -0,0 +1,136 @@
+package com.shortkit.reactnative
+
+import android.content.Context
+import android.widget.FrameLayout
+import com.shortkit.sdk.config.PlayerClickAction
+import com.shortkit.sdk.config.PlayerConfig
+import com.shortkit.sdk.config.VideoOverlayMode
+import com.shortkit.sdk.model.ContentItem
+import com.shortkit.sdk.player.ShortKitPlayerView
+import org.json.JSONObject
+
+/**
+ * Fabric native view wrapping [ShortKitPlayerView] for use as a
+ * single-video player in React Native.
+ */
+class ShortKitPlayerNativeView(context: Context) : FrameLayout(context) {
+
+    private var playerView: ShortKitPlayerView? = null
+    private var configJson: String? = null
+    private var contentItemJson: String? = null
+
+    var config: String?
+        get() = configJson
+        set(value) {
+            if (value == configJson) return
+            configJson = value
+            rebuildIfNeeded()
+        }
+
+    var contentItem: String?
+        get() = contentItemJson
+        set(value) {
+            if (value == contentItemJson) return
+            contentItemJson = value
+            applyContentItem()
+        }
+
+    var active: Boolean = true
+        set(value) {
+            if (field == value) return
+            field = value
+            applyActive()
+        }
+
+    override fun onAttachedToWindow() {
+        super.onAttachedToWindow()
+        rebuildIfNeeded()
+    }
+
+    override fun onDetachedFromWindow() {
+        playerView?.deactivate()
+        super.onDetachedFromWindow()
+    }
+
+    private fun rebuildIfNeeded() {
+        if (playerView != null) return
+
+        val sdk = ShortKitModule.shared?.sdk ?: return
+        val playerConfig = parsePlayerConfig(configJson)
+
+        val view = ShortKitPlayerView(context).apply {
+            layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
+        }
+        view.initialize(sdk, playerConfig)
+        addView(view)
+        playerView = view
+
+        applyContentItem()
+        if (active) view.activate()
+    }
+
+    private fun applyContentItem() {
+        val json = contentItemJson ?: return
+        val view = playerView ?: return
+        val item = parseContentItem(json) ?: return
+        view.configure(item)
+    }
+
+    private fun applyActive() {
+        val view = playerView ?: return
+        if (active) view.activate() else view.deactivate()
+    }
+
+    private fun parsePlayerConfig(json: String?): PlayerConfig {
+        if (json.isNullOrEmpty()) return PlayerConfig()
+        return try {
+            val obj = JSONObject(json)
+            PlayerConfig(
+                cornerRadius = obj.optDouble("cornerRadius", 12.0).toFloat(),
+                clickAction = when (obj.optString("clickAction", "feed")) {
+                    "feed" -> PlayerClickAction.FEED
+                    "mute" -> PlayerClickAction.MUTE
+                    "none" -> PlayerClickAction.NONE
+                    else -> PlayerClickAction.FEED
+                },
+                autoplay = obj.optBoolean("autoplay", true),
+                loop = obj.optBoolean("loop", true),
+                muteOnStart = obj.optBoolean("muteOnStart", true),
+                videoOverlay = parseOverlay(obj),
+            )
+        } catch (_: Exception) {
+            PlayerConfig()
+        }
+    }
+
+    private fun parseOverlay(obj: JSONObject): VideoOverlayMode {
+        val overlay = obj.opt("overlay") ?: return VideoOverlayMode.None
+        if (overlay is JSONObject && overlay.optString("type") == "custom") {
+            return VideoOverlayMode.Custom {
+                ShortKitOverlayBridge(context)
+            }
+        }
+        return VideoOverlayMode.None
+    }
+
+    private fun parseContentItem(json: String): ContentItem? {
+        return try {
+            val obj = JSONObject(json)
+            ContentItem(
+                id = obj.getString("id"),
+                title = obj.getString("title"),
+                description = obj.optString("description", null),
+                duration = obj.getDouble("duration"),
+                streamingUrl = obj.getString("streamingUrl"),
+                thumbnailUrl = obj.getString("thumbnailUrl"),
+                captionTracks = emptyList(),
+                customMetadata = null,
+                author = obj.optString("author", null),
+                articleUrl = obj.optString("articleUrl", null),
+                commentCount = if (obj.has("commentCount")) obj.getInt("commentCount") else null,
+            )
+        } catch (_: Exception) {
+            null
+        }
+    }
+}

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

@@ -0,0 +1,35 @@
+package com.shortkit.reactnative
+
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.annotations.ReactProp
+
+@ReactModule(name = ShortKitPlayerViewManager.REACT_CLASS)
+class ShortKitPlayerViewManager : SimpleViewManager<ShortKitPlayerNativeView>() {
+
+    override fun getName(): String = REACT_CLASS
+
+    override fun createViewInstance(context: ThemedReactContext): ShortKitPlayerNativeView {
+        return ShortKitPlayerNativeView(context)
+    }
+
+    @ReactProp(name = "config")
+    fun setConfig(view: ShortKitPlayerNativeView, config: String?) {
+        view.config = config
+    }
+
+    @ReactProp(name = "contentItem")
+    fun setContentItem(view: ShortKitPlayerNativeView, contentItem: String?) {
+        view.contentItem = contentItem
+    }
+
+    @ReactProp(name = "active", defaultBoolean = true)
+    fun setActive(view: ShortKitPlayerNativeView, active: Boolean) {
+        view.active = active
+    }
+
+    companion object {
+        const val REACT_CLASS = "ShortKitPlayerView"
+    }
+}