@granite-js/video 1.0.0

package/android/src/main/java/run/granite/video/GraniteVideoView.kt

@@ -0,0 +1,384 @@
+package run.granite.video
+
+import android.content.Context
+import android.widget.FrameLayout
+import run.granite.video.provider.*
+
+/**
+ * Video view that wraps a GraniteVideoProvider.
+ *
+ * Provider selection:
+ * - Default: Uses the provider set via GraniteVideoRegistry.setDefaultProvider()
+ * - Custom: Can inject a custom providerFactory for unit tests
+ *
+ * If no provider is registered, an IllegalStateException will be thrown.
+ *
+ * To change the default provider at runtime, use GraniteVideoModule.setDefaultProvider()
+ * from JavaScript before creating new video views.
+ */
+class GraniteVideoView @JvmOverloads constructor(
+    context: Context,
+    private val providerFactory: (() -> GraniteVideoProvider)? = null
+) : FrameLayout(context), GraniteVideoDelegate {
+
+    private var provider: GraniteVideoProvider? = null
+    private var playerView: android.view.View? = null
+
+    // State
+    private var paused: Boolean = true
+    private var muted: Boolean = false
+    private var volume: Float = 1.0f
+    private var rate: Float = 1.0f
+    private var repeat: Boolean = false
+    private var resizeMode: String = "contain"
+
+    // Event listener
+    var eventListener: GraniteVideoEventListener? = null
+
+    // Expose provider for testing
+    val currentProvider: GraniteVideoProvider?
+        get() = provider
+
+    init {
+        setupProvider(context)
+    }
+
+    private fun setupProvider(context: Context) {
+        // Create provider using:
+        // 1. Custom factory (for testing)
+        // 2. Default from registry (set via GraniteVideoRegistry.setDefaultProvider)
+        provider = providerFactory?.invoke()
+            ?: GraniteVideoRegistry.createProvider()
+            ?: throw IllegalStateException(
+                "No video provider registered. Either register a provider via " +
+                "GraniteVideoRegistry.registerFactory() or enable the default provider " +
+                "by setting GRANITE_VIDEO_DEFAULT_PROVIDER=true."
+            )
+
+        provider?.delegate = this
+
+        // Create player view
+        playerView = provider?.createPlayerView(context)
+        playerView?.let {
+            it.layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
+            addView(it)
+        }
+    }
+
+    // Source
+    fun setSource(source: Map<String, Any>?) {
+        source ?: return
+
+        val videoSource = GraniteVideoSource(
+            uri = source["uri"] as? String,
+            type = source["type"] as? String,
+            startPosition = (source["startPosition"] as? Number)?.toDouble() ?: 0.0,
+            cropStart = (source["cropStart"] as? Number)?.toDouble() ?: 0.0,
+            cropEnd = (source["cropEnd"] as? Number)?.toDouble() ?: 0.0,
+            headers = @Suppress("UNCHECKED_CAST") (source["headers"] as? Map<String, String>)
+        )
+
+        provider?.loadSource(videoSource)
+
+        if (!paused) {
+            provider?.play()
+        }
+    }
+
+    // Playback Control
+    fun setPaused(paused: Boolean) {
+        this.paused = paused
+        if (paused) {
+            provider?.pause()
+        } else {
+            provider?.play()
+        }
+    }
+
+    fun setMuted(muted: Boolean) {
+        this.muted = muted
+        provider?.setMuted(muted)
+    }
+
+    fun setVolume(volume: Float) {
+        this.volume = volume
+        provider?.setVolume(volume)
+    }
+
+    fun setRate(rate: Float) {
+        this.rate = rate
+        provider?.setRate(rate)
+    }
+
+    fun setRepeat(repeat: Boolean) {
+        this.repeat = repeat
+        provider?.setRepeat(repeat)
+    }
+
+    fun setResizeMode(mode: String) {
+        this.resizeMode = mode
+        val resizeModeEnum = when (mode) {
+            "cover" -> GraniteVideoResizeMode.COVER
+            "stretch" -> GraniteVideoResizeMode.STRETCH
+            "none" -> GraniteVideoResizeMode.NONE
+            else -> GraniteVideoResizeMode.CONTAIN
+        }
+        provider?.setResizeMode(resizeModeEnum)
+    }
+
+    // Controls
+    fun setControls(enabled: Boolean) {
+        provider?.setControlsEnabled(enabled)
+    }
+
+    fun setFullscreen(fullscreen: Boolean) {
+        provider?.setFullscreen(fullscreen)
+    }
+
+    fun setPictureInPicture(enabled: Boolean) {
+        provider?.setPictureInPictureEnabled(enabled)
+    }
+
+    fun setPlayInBackground(enabled: Boolean) {
+        provider?.setPlayInBackground(enabled)
+    }
+
+    fun setPlayWhenInactive(enabled: Boolean) {
+        provider?.setPlayWhenInactive(enabled)
+    }
+
+    // Buffer
+    fun setBufferConfig(config: Map<String, Any>?) {
+        config ?: return
+
+        val bufferConfig = GraniteVideoBufferConfig(
+            minBufferMs = (config["minBufferMs"] as? Number)?.toInt() ?: 15000,
+            maxBufferMs = (config["maxBufferMs"] as? Number)?.toInt() ?: 50000,
+            bufferForPlaybackMs = (config["bufferForPlaybackMs"] as? Number)?.toInt() ?: 2500,
+            bufferForPlaybackAfterRebufferMs = (config["bufferForPlaybackAfterRebufferMs"] as? Number)?.toInt() ?: 5000,
+            backBufferDurationMs = (config["backBufferDurationMs"] as? Number)?.toInt() ?: 0,
+            cacheSizeMB = (config["cacheSizeMB"] as? Number)?.toInt() ?: 0
+        )
+        provider?.setBufferConfig(bufferConfig)
+    }
+
+    fun setMaxBitRate(bitRate: Int) {
+        provider?.setMaxBitRate(bitRate)
+    }
+
+    fun setMinLoadRetryCount(count: Int) {
+        provider?.setMinLoadRetryCount(count)
+    }
+
+    // Track Selection
+    fun setSelectedAudioTrack(track: Map<String, Any>?) {
+        track ?: return
+        val selectedTrack = GraniteVideoSelectedTrack(
+            type = track["type"] as? String ?: "system",
+            value = track["value"] as? String
+        )
+        provider?.setSelectedAudioTrack(selectedTrack)
+    }
+
+    fun setSelectedTextTrack(track: Map<String, Any>?) {
+        track ?: return
+        val selectedTrack = GraniteVideoSelectedTrack(
+            type = track["type"] as? String ?: "system",
+            value = track["value"] as? String
+        )
+        provider?.setSelectedTextTrack(selectedTrack)
+    }
+
+    fun setSelectedVideoTrack(type: String, value: Int) {
+        provider?.setSelectedVideoTrack(type, value)
+    }
+
+    // View Settings
+    fun setUseTextureView(useTexture: Boolean) {
+        provider?.setUseTextureView(useTexture)
+    }
+
+    fun setUseSecureView(useSecure: Boolean) {
+        provider?.setUseSecureView(useSecure)
+    }
+
+    fun setShutterColor(color: Int) {
+        provider?.setShutterColor(color)
+    }
+
+    fun setHideShutterView(hide: Boolean) {
+        provider?.setHideShutterView(hide)
+    }
+
+    // Commands
+    fun seek(time: Double, tolerance: Double = 0.0) {
+        provider?.seek(time, tolerance)
+    }
+
+    fun seekCommand(time: Double, tolerance: Double) {
+        seek(time, tolerance)
+    }
+
+    fun pauseCommand() {
+        provider?.pause()
+    }
+
+    fun resumeCommand() {
+        provider?.play()
+    }
+
+    fun setVolumeCommand(volume: Float) {
+        setVolume(volume)
+    }
+
+    fun setFullScreenCommand(fullscreen: Boolean) {
+        setFullscreen(fullscreen)
+    }
+
+    fun setSourceCommand(uri: String) {
+        setSource(mapOf("uri" to uri))
+    }
+
+    fun enterPictureInPictureCommand() {
+        provider?.enterPictureInPicture()
+    }
+
+    fun exitPictureInPictureCommand() {
+        provider?.exitPictureInPicture()
+    }
+
+    // GraniteVideoDelegate Implementation
+    override fun onLoadStart(isNetwork: Boolean, type: String, uri: String) {
+        eventListener?.onLoadStart(isNetwork, type, uri)
+    }
+
+    override fun onLoad(data: GraniteVideoLoadData) {
+        eventListener?.onLoad(data)
+    }
+
+    override fun onError(error: GraniteVideoErrorData) {
+        eventListener?.onError(error)
+    }
+
+    override fun onProgress(data: GraniteVideoProgressData) {
+        eventListener?.onProgress(data)
+    }
+
+    override fun onSeek(currentTime: Double, seekTime: Double) {
+        eventListener?.onSeek(currentTime, seekTime)
+    }
+
+    override fun onEnd() {
+        eventListener?.onEnd()
+    }
+
+    override fun onBuffer(isBuffering: Boolean) {
+        eventListener?.onBuffer(isBuffering)
+    }
+
+    override fun onBandwidthUpdate(bitrate: Double, width: Int, height: Int) {
+        eventListener?.onBandwidthUpdate(bitrate, width, height)
+    }
+
+    override fun onPlaybackStateChanged(isPlaying: Boolean, isSeeking: Boolean, isLooping: Boolean) {
+        eventListener?.onPlaybackStateChanged(isPlaying, isSeeking, isLooping)
+    }
+
+    override fun onPlaybackRateChange(rate: Float) {
+        eventListener?.onPlaybackRateChange(rate)
+    }
+
+    override fun onVolumeChange(volume: Float) {
+        eventListener?.onVolumeChange(volume)
+    }
+
+    override fun onIdle() {
+        eventListener?.onIdle()
+    }
+
+    override fun onReadyForDisplay() {
+        eventListener?.onReadyForDisplay()
+    }
+
+    override fun onAudioFocusChanged(hasAudioFocus: Boolean) {
+        eventListener?.onAudioFocusChanged(hasAudioFocus)
+    }
+
+    override fun onAudioBecomingNoisy() {
+        eventListener?.onAudioBecomingNoisy()
+    }
+
+    override fun onFullscreenPlayerWillPresent() {
+        eventListener?.onFullscreenPlayerWillPresent()
+    }
+
+    override fun onFullscreenPlayerDidPresent() {
+        eventListener?.onFullscreenPlayerDidPresent()
+    }
+
+    override fun onFullscreenPlayerWillDismiss() {
+        eventListener?.onFullscreenPlayerWillDismiss()
+    }
+
+    override fun onFullscreenPlayerDidDismiss() {
+        eventListener?.onFullscreenPlayerDidDismiss()
+    }
+
+    override fun onPictureInPictureStatusChanged(isActive: Boolean) {
+        eventListener?.onPictureInPictureStatusChanged(isActive)
+    }
+
+    override fun onControlsVisibilityChanged(isVisible: Boolean) {
+        eventListener?.onControlsVisibilityChanged(isVisible)
+    }
+
+    override fun onAspectRatioChanged(width: Double, height: Double) {
+        eventListener?.onAspectRatioChanged(width, height)
+    }
+
+    override fun onTransferEnd(uri: String, bytesTransferred: Long) {
+        eventListener?.onTransferEnd(uri, bytesTransferred)
+    }
+
+    // Cleanup
+    private fun releaseProvider() {
+        provider?.release()
+        provider = null
+    }
+
+    fun release() {
+        releaseProvider()
+    }
+
+    override fun onDetachedFromWindow() {
+        super.onDetachedFromWindow()
+        release()
+    }
+}
+
+// Event Listener Interface
+interface GraniteVideoEventListener {
+    fun onLoadStart(isNetwork: Boolean, type: String, uri: String)
+    fun onLoad(data: GraniteVideoLoadData)
+    fun onError(error: GraniteVideoErrorData)
+    fun onProgress(data: GraniteVideoProgressData)
+    fun onSeek(currentTime: Double, seekTime: Double)
+    fun onEnd()
+    fun onBuffer(isBuffering: Boolean)
+    fun onBandwidthUpdate(bitrate: Double, width: Int, height: Int)
+    fun onPlaybackStateChanged(isPlaying: Boolean, isSeeking: Boolean, isLooping: Boolean)
+    fun onPlaybackRateChange(rate: Float)
+    fun onVolumeChange(volume: Float)
+    fun onIdle()
+    fun onReadyForDisplay()
+    fun onAudioFocusChanged(hasAudioFocus: Boolean)
+    fun onAudioBecomingNoisy()
+    fun onFullscreenPlayerWillPresent()
+    fun onFullscreenPlayerDidPresent()
+    fun onFullscreenPlayerWillDismiss()
+    fun onFullscreenPlayerDidDismiss()
+    fun onPictureInPictureStatusChanged(isActive: Boolean)
+    fun onControlsVisibilityChanged(isVisible: Boolean)
+    fun onAspectRatioChanged(width: Double, height: Double)
+    fun onTransferEnd(uri: String, bytesTransferred: Long) {}
+}

package/android/src/main/java/run/granite/video/GraniteVideoViewManager.kt

@@ -0,0 +1,318 @@
+package run.granite.video
+
+import android.graphics.Color
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.SimpleViewManager
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.GraniteVideoViewManagerInterface
+import com.facebook.react.viewmanagers.GraniteVideoViewManagerDelegate
+import com.facebook.react.common.MapBuilder
+import run.granite.video.event.DefaultVideoEventDispatcherFactory
+import run.granite.video.event.VideoEventDispatcherFactory
+import run.granite.video.event.VideoEventListenerAdapter
+
+/**
+ * React Native ViewManager for GraniteVideoView.
+ *
+ * This manager supports:
+ * - Provider selection via `providerId` prop
+ * - All standard video props (source, paused, volume, etc.)
+ * - Commands for playback control
+ *
+ * The ViewManager uses dependency injection for the event dispatcher factory,
+ * making it testable without React Native context.
+ */
+@ReactModule(name = GraniteVideoViewManager.NAME)
+class GraniteVideoViewManager(
+    private val eventDispatcherFactory: VideoEventDispatcherFactory = DefaultVideoEventDispatcherFactory()
+) : SimpleViewManager<GraniteVideoView>(),
+    GraniteVideoViewManagerInterface<GraniteVideoView> {
+
+    private val mDelegate: ViewManagerDelegate<GraniteVideoView> = GraniteVideoViewManagerDelegate(this)
+
+    override fun getDelegate(): ViewManagerDelegate<GraniteVideoView> = mDelegate
+
+    override fun getName(): String = NAME
+
+    override fun createViewInstance(context: ThemedReactContext): GraniteVideoView {
+        val view = GraniteVideoView(context)
+
+        // Set up event dispatcher and listener
+        val dispatcher = eventDispatcherFactory.create(view)
+        view.eventListener = VideoEventListenerAdapter(
+            dispatcher = dispatcher,
+            viewIdProvider = { view.id }
+        )
+
+        return view
+    }
+
+    override fun onDropViewInstance(view: GraniteVideoView) {
+        super.onDropViewInstance(view)
+        view.release()
+    }
+
+    // Props
+    @ReactProp(name = "source")
+    override fun setSource(view: GraniteVideoView?, source: ReadableMap?) {
+        @Suppress("UNCHECKED_CAST")
+        view?.setSource(source?.toHashMap()?.filterValues { it != null } as? Map<String, Any>)
+    }
+
+    @ReactProp(name = "paused")
+    override fun setPaused(view: GraniteVideoView?, paused: Boolean) {
+        view?.setPaused(paused)
+    }
+
+    @ReactProp(name = "muted")
+    override fun setMuted(view: GraniteVideoView?, muted: Boolean) {
+        view?.setMuted(muted)
+    }
+
+    @ReactProp(name = "volume", defaultFloat = 1.0f)
+    override fun setVolume(view: GraniteVideoView?, volume: Float) {
+        view?.setVolume(volume)
+    }
+
+    @ReactProp(name = "rate", defaultFloat = 1.0f)
+    override fun setRate(view: GraniteVideoView?, rate: Float) {
+        view?.setRate(rate)
+    }
+
+    @ReactProp(name = "repeat")
+    override fun setRepeat(view: GraniteVideoView?, repeat: Boolean) {
+        view?.setRepeat(repeat)
+    }
+
+    @ReactProp(name = "resizeMode")
+    override fun setResizeMode(view: GraniteVideoView?, resizeMode: String?) {
+        view?.setResizeMode(resizeMode ?: "contain")
+    }
+
+    @ReactProp(name = "controls")
+    override fun setControls(view: GraniteVideoView?, controls: Boolean) {
+        view?.setControls(controls)
+    }
+
+    @ReactProp(name = "fullscreen")
+    override fun setFullscreen(view: GraniteVideoView?, fullscreen: Boolean) {
+        view?.setFullscreen(fullscreen)
+    }
+
+    @ReactProp(name = "pictureInPicture")
+    override fun setPictureInPicture(view: GraniteVideoView?, pictureInPicture: Boolean) {
+        view?.setPictureInPicture(pictureInPicture)
+    }
+
+    @ReactProp(name = "playInBackground")
+    override fun setPlayInBackground(view: GraniteVideoView?, playInBackground: Boolean) {
+        view?.setPlayInBackground(playInBackground)
+    }
+
+    @ReactProp(name = "playWhenInactive")
+    override fun setPlayWhenInactive(view: GraniteVideoView?, playWhenInactive: Boolean) {
+        view?.setPlayWhenInactive(playWhenInactive)
+    }
+
+    @ReactProp(name = "bufferConfig")
+    override fun setBufferConfig(view: GraniteVideoView?, bufferConfig: ReadableMap?) {
+        @Suppress("UNCHECKED_CAST")
+        view?.setBufferConfig(bufferConfig?.toHashMap()?.filterValues { it != null } as? Map<String, Any>)
+    }
+
+    @ReactProp(name = "maxBitRate")
+    override fun setMaxBitRate(view: GraniteVideoView?, maxBitRate: Int) {
+        view?.setMaxBitRate(maxBitRate)
+    }
+
+    @ReactProp(name = "minLoadRetryCount")
+    override fun setMinLoadRetryCount(view: GraniteVideoView?, minLoadRetryCount: Int) {
+        view?.setMinLoadRetryCount(minLoadRetryCount)
+    }
+
+    @ReactProp(name = "selectedAudioTrack")
+    override fun setSelectedAudioTrack(view: GraniteVideoView?, selectedAudioTrack: ReadableMap?) {
+        @Suppress("UNCHECKED_CAST")
+        view?.setSelectedAudioTrack(selectedAudioTrack?.toHashMap()?.filterValues { it != null } as? Map<String, Any>)
+    }
+
+    @ReactProp(name = "selectedTextTrack")
+    override fun setSelectedTextTrack(view: GraniteVideoView?, selectedTextTrack: ReadableMap?) {
+        @Suppress("UNCHECKED_CAST")
+        view?.setSelectedTextTrack(selectedTextTrack?.toHashMap()?.filterValues { it != null } as? Map<String, Any>)
+    }
+
+    @ReactProp(name = "selectedVideoTrack")
+    override fun setSelectedVideoTrack(view: GraniteVideoView?, selectedVideoTrack: ReadableMap?) {
+        val type = selectedVideoTrack?.getString("type") ?: "auto"
+        val value = selectedVideoTrack?.getInt("value") ?: 0
+        view?.setSelectedVideoTrack(type, value)
+    }
+
+    @ReactProp(name = "viewType")
+    override fun setViewType(view: GraniteVideoView?, viewType: String?) {
+        view?.setUseTextureView(viewType == "texture")
+    }
+
+    @ReactProp(name = "useTextureView")
+    override fun setUseTextureView(view: GraniteVideoView?, useTextureView: Boolean) {
+        view?.setUseTextureView(useTextureView)
+    }
+
+    @ReactProp(name = "useSecureView")
+    override fun setUseSecureView(view: GraniteVideoView?, useSecureView: Boolean) {
+        view?.setUseSecureView(useSecureView)
+    }
+
+    @ReactProp(name = "shutterColor")
+    override fun setShutterColor(view: GraniteVideoView?, shutterColor: String?) {
+        shutterColor?.let {
+            try {
+                view?.setShutterColor(Color.parseColor(it))
+            } catch (e: Exception) {
+                // Invalid color
+            }
+        }
+    }
+
+    @ReactProp(name = "hideShutterView")
+    override fun setHideShutterView(view: GraniteVideoView?, hideShutterView: Boolean) {
+        view?.setHideShutterView(hideShutterView)
+    }
+
+    // Other props with default implementations
+    @ReactProp(name = "poster")
+    override fun setPoster(view: GraniteVideoView?, poster: String?) {}
+
+    @ReactProp(name = "posterResizeMode")
+    override fun setPosterResizeMode(view: GraniteVideoView?, posterResizeMode: String?) {}
+
+    @ReactProp(name = "automaticallyWaitsToMinimizeStalling")
+    override fun setAutomaticallyWaitsToMinimizeStalling(view: GraniteVideoView?, value: Boolean) {}
+
+    @ReactProp(name = "preferredForwardBufferDuration")
+    override fun setPreferredForwardBufferDuration(view: GraniteVideoView?, value: Double) {}
+
+    @ReactProp(name = "drm")
+    override fun setDrm(view: GraniteVideoView?, drm: ReadableMap?) {}
+
+    @ReactProp(name = "localSourceEncryptionKeyScheme")
+    override fun setLocalSourceEncryptionKeyScheme(view: GraniteVideoView?, value: String?) {}
+
+    @ReactProp(name = "adTagUrl")
+    override fun setAdTagUrl(view: GraniteVideoView?, value: String?) {}
+
+    @ReactProp(name = "adLanguage")
+    override fun setAdLanguage(view: GraniteVideoView?, value: String?) {}
+
+    @ReactProp(name = "showNotificationControls")
+    override fun setShowNotificationControls(view: GraniteVideoView?, value: Boolean) {}
+
+    @ReactProp(name = "disableFocus")
+    override fun setDisableFocus(view: GraniteVideoView?, value: Boolean) {}
+
+    @ReactProp(name = "disableDisconnectError")
+    override fun setDisableDisconnectError(view: GraniteVideoView?, value: Boolean) {}
+
+    @ReactProp(name = "focusable")
+    override fun setFocusable(view: GraniteVideoView?, value: Boolean) {}
+
+    @ReactProp(name = "preventsDisplaySleepDuringVideoPlayback")
+    override fun setPreventsDisplaySleepDuringVideoPlayback(view: GraniteVideoView?, value: Boolean) {}
+
+    @ReactProp(name = "fullscreenAutorotate")
+    override fun setFullscreenAutorotate(view: GraniteVideoView?, value: Boolean) {}
+
+    @ReactProp(name = "fullscreenOrientation")
+    override fun setFullscreenOrientation(view: GraniteVideoView?, value: String?) {}
+
+    @ReactProp(name = "contentStartTime")
+    override fun setContentStartTime(view: GraniteVideoView?, value: Double) {}
+
+    @ReactProp(name = "allowsExternalPlayback")
+    override fun setAllowsExternalPlayback(view: GraniteVideoView?, value: Boolean) {}
+
+    @ReactProp(name = "audioOutput")
+    override fun setAudioOutput(view: GraniteVideoView?, value: String?) {}
+
+    @ReactProp(name = "ignoreSilentSwitch")
+    override fun setIgnoreSilentSwitch(view: GraniteVideoView?, value: String?) {}
+
+    @ReactProp(name = "mixWithOthers")
+    override fun setMixWithOthers(view: GraniteVideoView?, value: String?) {}
+
+    @ReactProp(name = "enableDebug")
+    override fun setEnableDebug(view: GraniteVideoView?, value: Boolean) {}
+
+    @ReactProp(name = "enableDebugThread")
+    override fun setEnableDebugThread(view: GraniteVideoView?, value: Boolean) {}
+
+    // Commands
+    override fun seek(view: GraniteVideoView?, time: Double, tolerance: Double) {
+        view?.seekCommand(time, tolerance)
+    }
+
+    override fun adjustVolume(view: GraniteVideoView?, volume: Float) {
+        view?.setVolumeCommand(volume)
+    }
+
+    override fun setFullScreen(view: GraniteVideoView?, fullscreen: Boolean) {
+        view?.setFullScreenCommand(fullscreen)
+    }
+
+    override fun loadSource(view: GraniteVideoView?, uri: String?) {
+        uri?.let { view?.setSourceCommand(it) }
+    }
+
+    override fun pause(view: GraniteVideoView?) {
+        view?.pauseCommand()
+    }
+
+    override fun resume(view: GraniteVideoView?) {
+        view?.resumeCommand()
+    }
+
+    override fun enterPictureInPicture(view: GraniteVideoView?) {
+        view?.enterPictureInPictureCommand()
+    }
+
+    override fun exitPictureInPicture(view: GraniteVideoView?) {
+        view?.exitPictureInPictureCommand()
+    }
+
+    // Event registration
+    override fun getExportedCustomDirectEventTypeConstants(): Map<String, Any> {
+        return MapBuilder.builder<String, Any>()
+            .put("topVideoLoadStart", MapBuilder.of("registrationName", "onVideoLoadStart"))
+            .put("topVideoLoad", MapBuilder.of("registrationName", "onVideoLoad"))
+            .put("topVideoError", MapBuilder.of("registrationName", "onVideoError"))
+            .put("topVideoProgress", MapBuilder.of("registrationName", "onVideoProgress"))
+            .put("topVideoSeek", MapBuilder.of("registrationName", "onVideoSeek"))
+            .put("topVideoEnd", MapBuilder.of("registrationName", "onVideoEnd"))
+            .put("topVideoBuffer", MapBuilder.of("registrationName", "onVideoBuffer"))
+            .put("topVideoBandwidthUpdate", MapBuilder.of("registrationName", "onVideoBandwidthUpdate"))
+            .put("topVideoPlaybackStateChanged", MapBuilder.of("registrationName", "onVideoPlaybackStateChanged"))
+            .put("topVideoPlaybackRateChange", MapBuilder.of("registrationName", "onVideoPlaybackRateChange"))
+            .put("topVideoVolumeChange", MapBuilder.of("registrationName", "onVideoVolumeChange"))
+            .put("topVideoIdle", MapBuilder.of("registrationName", "onVideoIdle"))
+            .put("topVideoReadyForDisplay", MapBuilder.of("registrationName", "onVideoReadyForDisplay"))
+            .put("topVideoAudioFocusChanged", MapBuilder.of("registrationName", "onVideoAudioFocusChanged"))
+            .put("topVideoAudioBecomingNoisy", MapBuilder.of("registrationName", "onVideoAudioBecomingNoisy"))
+            .put("topVideoFullscreenPlayerWillPresent", MapBuilder.of("registrationName", "onVideoFullscreenPlayerWillPresent"))
+            .put("topVideoFullscreenPlayerDidPresent", MapBuilder.of("registrationName", "onVideoFullscreenPlayerDidPresent"))
+            .put("topVideoFullscreenPlayerWillDismiss", MapBuilder.of("registrationName", "onVideoFullscreenPlayerWillDismiss"))
+            .put("topVideoFullscreenPlayerDidDismiss", MapBuilder.of("registrationName", "onVideoFullscreenPlayerDidDismiss"))
+            .put("topVideoPictureInPictureStatusChanged", MapBuilder.of("registrationName", "onVideoPictureInPictureStatusChanged"))
+            .put("topVideoControlsVisibilityChange", MapBuilder.of("registrationName", "onVideoControlsVisibilityChange"))
+            .put("topVideoAspectRatio", MapBuilder.of("registrationName", "onVideoAspectRatio"))
+            .put("topVideoTransferEnd", MapBuilder.of("registrationName", "onVideoTransferEnd"))
+            .build()
+    }
+
+    companion object {
+        const val NAME = "GraniteVideoView"
+    }
+}