bitmovin-player-react-native 0.1.0 → 0.2.1

package/android/src/main/java/com/bitmovin/player/reactnative/PlayerModule.kt

@@ -2,24 +2,19 @@ package com.bitmovin.player.reactnative
 
 import com.bitmovin.player.api.Player
 import com.bitmovin.player.reactnative.converter.JsonConverter
-import com.facebook.react.bridge.Promise
-import com.facebook.react.bridge.ReadableMap
-import com.facebook.react.bridge.ReactMethod
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactContextBaseJavaModule
-import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.bridge.*
+import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.uimanager.UIManagerModule
-import java.util.UUID
 
 @ReactModule(name = PlayerModule.name)
 class PlayerModule(private val context: ReactApplicationContext) : ReactContextBaseJavaModule(context) {
     /**
-     * In-memory mapping of `id` <-> `Player`.
+     * In-memory mapping from `nativeId`s to `Player` instances.
      */
-    private var registry: MutableMap<String, Player> = mutableMapOf()
+    private val players: Registry<Player> = mutableMapOf()
 
     /**
-     * Exported module name to JS.
+     * JS exported module name.
      */
     companion object {
         const val name = "PlayerModule"
@@ -27,184 +22,180 @@ class PlayerModule(private val context: ReactApplicationContext) : ReactContextB
     override fun getName() = PlayerModule.name
 
     /**
-     * Fetch the `Player` instance with id equal to `playerId` inside this module's `registry`.
-     * @param playerId Target player to look inside registry.
+     * Fetches the `Player` instance associated with `nativeId` from the internal players.
+     * @param nativeId `Player` instance ID.
+     * @return The associated `Player` instance or `null`.
      */
-    fun getPlayer(playerId: String?): Player? {
-        if (playerId == null) {
+    fun getPlayer(nativeId: NativeId?): Player? {
+        if (nativeId == null) {
             return null
         }
-        return registry[playerId]
+        return players[nativeId]
     }
 
     /**
-     * Synchronously generate a random UUID for `Player`s native id when no `nativeId` is provided
-     * by the user.
-     * @return Random UUID RFC 4122 version 4.
-     */
-    @ReactMethod(isBlockingSynchronousMethod = true)
-    fun generateUUIDv4(): String = UUID.randomUUID().toString()
-
-    /**
-     * Create a new `Player` instance for the given `config` if no one exists already.
-     * @param config Player configuration options sent from JS.
+     * Creates a new `Player` instance inside the internal players using the provided `config` object.
+     * @param config `PlayerConfig` object received from JS.
      */
     @ReactMethod
-    fun initWithConfig(playerId: String, config: ReadableMap?) {
+    fun initWithConfig(nativeId: NativeId, config: ReadableMap?) {
         uiManager()?.addUIBlock {
-            if (!registry.containsKey(playerId)) {
-                JsonConverter.toPlayerConfig(config)?.let {
-                    registry[playerId] = Player.create(context, it)
+            if (!players.containsKey(nativeId)) {
+                JsonConverter.toPlayerConfig(config).let {
+                    players[nativeId] = Player.create(context, it)
                 }
             }
         }
     }
 
     /**
-     * Load the source of the given `playerId` with `config` options from JS.
-     * @param playerId Target player.
+     * Load the source of the given `nativeId` with `config` options from JS.
+     * @param nativeId Target player.
      * @param config Source configuration options from JS.
      */
     @ReactMethod
-    fun loadSource(playerId: String, config: ReadableMap?) {
+    fun loadSource(nativeId: NativeId, sourceNativeId: String) {
         uiManager()?.addUIBlock {
-            JsonConverter.toSourceConfig(config)?.let {
-                registry[playerId]?.load(it)
+            sourceModule()?.getSource(sourceNativeId)?.let {
+                players[nativeId]?.load(it)
             }
         }
     }
 
     /**
-     * Call `.unload()` on `playerId`'s player.
-     * @param playerId Target player Id.
+     * Call `.unload()` on `nativeId`'s player.
+     * @param nativeId Target player Id.
      */
     @ReactMethod
-    fun unload(playerId: String) {
+    fun unload(nativeId: NativeId) {
         uiManager()?.addUIBlock {
-            registry[playerId]?.unload()
+            players[nativeId]?.unload()
         }
     }
 
     /**
-     * Call `.play()` on `playerId`'s player.
-     * @param playerId Target player Id.
+     * Call `.play()` on `nativeId`'s player.
+     * @param nativeId Target player Id.
      */
     @ReactMethod
-    fun play(playerId: String) {
+    fun play(nativeId: NativeId) {
         uiManager()?.addUIBlock {
-            registry[playerId]?.play()
+            players[nativeId]?.play()
         }
     }
 
     /**
-     * Call `.pause()` on `playerId`'s player.
-     * @param playerId Target player Id.
+     * Call `.pause()` on `nativeId`'s player.
+     * @param nativeId Target player Id.
      */
     @ReactMethod
-    fun pause(playerId: String) {
+    fun pause(nativeId: NativeId) {
         uiManager()?.addUIBlock {
-            registry[playerId]?.pause()
+            players[nativeId]?.pause()
         }
     }
 
     /**
-     * Call `.seek(time:)` on `playerId`'s player.
-     * @param playerId Target player Id.
+     * Call `.seek(time:)` on `nativeId`'s player.
+     * @param nativeId Target player Id.
      * @param time Seek time in seconds.
      */
     @ReactMethod
-    fun seek(playerId: String, time: Double) {
+    fun seek(nativeId: NativeId, time: Double) {
         uiManager()?.addUIBlock {
-            registry[playerId]?.seek(time)
+            players[nativeId]?.seek(time)
         }
     }
 
     /**
-     * Call `.mute()` on `playerId`'s player.
-     * @param playerId Target player Id.
+     * Call `.mute()` on `nativeId`'s player.
+     * @param nativeId Target player Id.
      */
     @ReactMethod
-    fun mute(playerId: String) {
+    fun mute(nativeId: NativeId) {
         uiManager()?.addUIBlock {
-            registry[playerId]?.mute()
+            players[nativeId]?.mute()
         }
     }
 
     /**
-     * Call `.unmute()` on `playerId`'s player.
-     * @param playerId Target player Id.
+     * Call `.unmute()` on `nativeId`'s player.
+     * @param nativeId Target player Id.
      */
     @ReactMethod
-    fun unmute(playerId: String) {
+    fun unmute(nativeId: NativeId) {
         uiManager()?.addUIBlock {
-            registry[playerId]?.unmute()
+            players[nativeId]?.unmute()
         }
     }
 
     /**
-     * Call `.destroy()` on `playerId`'s player.
-     * @param playerId Target player Id.
+     * Call `.destroy()` on `nativeId`'s player.
+     * @param nativeId Target player Id.
      */
     @ReactMethod
-    fun destroy(playerId: String) {
+    fun destroy(nativeId: NativeId) {
         uiManager()?.addUIBlock {
-            registry[playerId]?.destroy()
+            players[nativeId]?.let {
+                it.destroy()
+                players.remove(nativeId)
+            }
         }
     }
 
     /**
-     * Call `.setVolume(volume:)` on `playerId`'s player.
-     * @param playerId Target player Id.
+     * Call `.setVolume(volume:)` on `nativeId`'s player.
+     * @param nativeId Target player Id.
      * @param volume Volume level integer between 0 to 100.
      */
     @ReactMethod
-    fun setVolume(playerId: String, volume: Int) {
+    fun setVolume(nativeId: NativeId, volume: Int) {
         uiManager()?.addUIBlock {
-            registry[playerId]?.volume = volume
+            players[nativeId]?.volume = volume
         }
     }
 
     /**
-     * Resolve `playerId`'s current volume.
-     * @param playerId Target player Id.
+     * Resolve `nativeId`'s current volume.
+     * @param nativeId Target player Id.
      * @param promise JS promise object.
      */
     @ReactMethod
-    fun getVolume(playerId: String, promise: Promise) {
+    fun getVolume(nativeId: NativeId, promise: Promise) {
         uiManager()?.addUIBlock {
-            promise.resolve(registry[playerId]?.volume)
+            promise.resolve(players[nativeId]?.volume)
         }
     }
 
     /**
-     * Resolve the source of `playerId`'s player.
-     * @param playerId Target player Id.
+     * Resolve the source of `nativeId`'s player.
+     * @param nativeId Target player Id.
      * @param promise JS promise object.
      */
     @ReactMethod
-    fun source(playerId: String, promise: Promise) {
+    fun source(nativeId: NativeId, promise: Promise) {
         uiManager()?.addUIBlock {
-            promise.resolve(JsonConverter.fromSource(registry[playerId]?.source))
+            promise.resolve(JsonConverter.fromSource(players[nativeId]?.source))
         }
     }
 
     /**
-     * Resolve `playerId`'s current playback time.
-     * @param playerId Target player Id.
+     * Resolve `nativeId`'s current playback time.
+     * @param nativeId Target player Id.
      * @param promise JS promise object.
      */
     @ReactMethod
-    fun currentTime(playerId: String, mode: String?, promise: Promise) {
+    fun currentTime(nativeId: NativeId, mode: String?, promise: Promise) {
         uiManager()?.addUIBlock {
             var timeOffset: Double = 0.0
             if (mode != null) {
                 timeOffset = if (mode == "relative") {
-                    registry[playerId]?.playbackTimeOffsetToRelativeTime ?: 0.0
+                    players[nativeId]?.playbackTimeOffsetToRelativeTime ?: 0.0
                 } else {
-                    registry[playerId]?.playbackTimeOffsetToAbsoluteTime ?: 0.0
+                    players[nativeId]?.playbackTimeOffsetToAbsoluteTime ?: 0.0
                 }
             }
-            val currentTime = registry[playerId]?.currentTime
+            val currentTime = players[nativeId]?.currentTime
             if (currentTime != null) {
                 promise.resolve(currentTime + timeOffset)
             }
@@ -212,62 +203,80 @@ class PlayerModule(private val context: ReactApplicationContext) : ReactContextB
     }
 
     /**
-     * Resolve `playerId`'s current source duration.
-     * @param playerId Target player Id.
+     * Resolve `nativeId`'s current source duration.
+     * @param nativeId Target player Id.
      * @param promise JS promise object.
      */
     @ReactMethod
-    fun duration(playerId: String, promise: Promise) {
+    fun duration(nativeId: NativeId, promise: Promise) {
         uiManager()?.addUIBlock {
-            promise.resolve(registry[playerId]?.duration)
+            promise.resolve(players[nativeId]?.duration)
         }
     }
 
     /**
-     * Resolve `playerId`'s current muted state.
-     * @param playerId Target player Id.
+     * Resolve `nativeId`'s current muted state.
+     * @param nativeId Target player Id.
      * @param promise JS promise object.
      */
     @ReactMethod
-    fun isMuted(playerId: String, promise: Promise) {
+    fun isMuted(nativeId: NativeId, promise: Promise) {
         uiManager()?.addUIBlock {
-            promise.resolve(registry[playerId]?.isMuted)
+            promise.resolve(players[nativeId]?.isMuted)
         }
     }
 
     /**
-     * Resolve `playerId`'s current playing state.
-     * @param playerId Target player Id.
+     * Resolve `nativeId`'s current playing state.
+     * @param nativeId Target player Id.
      * @param promise JS promise object.
      */
     @ReactMethod
-    fun isPlaying(playerId: String, promise: Promise) {
+    fun isPlaying(nativeId: NativeId, promise: Promise) {
         uiManager()?.addUIBlock {
-            promise.resolve(registry[playerId]?.isPlaying)
+            promise.resolve(players[nativeId]?.isPlaying)
         }
     }
 
     /**
-     * Resolve `playerId`'s current paused state.
-     * @param playerId Target player Id.
+     * Resolve `nativeId`'s current paused state.
+     * @param nativeId Target player Id.
      * @param promise JS promise object.
      */
     @ReactMethod
-    fun isPaused(playerId: String, promise: Promise) {
+    fun isPaused(nativeId: NativeId, promise: Promise) {
         uiManager()?.addUIBlock {
-            promise.resolve(registry[playerId]?.isPaused)
+            promise.resolve(players[nativeId]?.isPaused)
         }
     }
 
     /**
-     * Resolve `playerId`'s current live state.
-     * @param playerId Target player Id.
+     * Resolve `nativeId`'s current live state.
+     * @param nativeId Target player Id.
      * @param promise JS promise object.
      */
     @ReactMethod
-    fun isLive(playerId: String, promise: Promise) {
+    fun isLive(nativeId: NativeId, promise: Promise) {
         uiManager()?.addUIBlock {
-            promise.resolve(registry[playerId]?.isLive)
+            promise.resolve(players[nativeId]?.isLive)
+        }
+    }
+
+    /**
+     * Resolve `nativeId`'s player available subtitle tracks.
+     * @param nativeId Target player Id.
+     * @param promise JS promise object.
+     */
+    @ReactMethod
+    fun getAvailableSubtitles(nativeId: NativeId, promise: Promise) {
+        uiManager()?.addUIBlock {
+            val subtitleTracks = Arguments.createArray()
+            players[nativeId]?.source?.availableSubtitleTracks?.let { tracks ->
+                tracks.forEach {
+                    subtitleTracks.pushMap(JsonConverter.fromSubtitleTrack(it))
+                }
+            }
+            promise.resolve(subtitleTracks)
         }
     }
 
@@ -276,4 +285,10 @@ class PlayerModule(private val context: ReactApplicationContext) : ReactContextB
      */
     private fun uiManager(): UIManagerModule? =
         context.getNativeModule(UIManagerModule::class.java)
-}
+
+    /**
+     * Helper function that returns the initialized `SourceModule` instance.
+     */
+    private fun sourceModule(): SourceModule? =
+        context.getNativeModule(SourceModule::class.java)
+}

package/android/src/main/java/com/bitmovin/player/reactnative/RNPlayerView.kt

@@ -195,54 +195,85 @@ class RNPlayerView(context: ReactApplicationContext) : LinearLayout(context) {
         emitEvent("sourceWarning", it)
     }
 
+    /**
+     * `onSubtitleAdded` event callback.
+     */
+    private val onSubtitleAdded: (SourceEvent.SubtitleTrackAdded) -> Unit = {
+        emitEvent("subtitleAdded", it)
+    }
+
+    /**
+     * `onSubtitleChanged` event callback.
+     */
+    private val onSubtitleChanged: (SourceEvent.SubtitleTrackChanged) -> Unit = {
+        emitEvent("subtitleChanged", it)
+    }
+
+    /**
+     * `onSubtitleRemoved` event callback.
+     */
+    private val onSubtitleRemoved: (SourceEvent.SubtitleTrackRemoved) -> Unit = {
+        emitEvent("subtitleRemoved", it)
+    }
+
     /**
      * Start listening and emitting player events as bubbling events to the js side.
      */
     fun startBubblingEvents() {
-        player?.on(onEvent)
-        player?.on(onPlayerError)
-        player?.on(onPlayerWarning)
-        player?.on(onDestroy)
-        player?.on(onMuted)
-        player?.on(onUnmuted)
-        player?.on(onReady)
-        player?.on(onPaused)
-        player?.on(onPlay)
-        player?.on(onPlaying)
-        player?.on(onPlaybackFinished)
-        player?.on(onSeek)
-        player?.on(onSeeked)
-        player?.on(onTimeChanged)
-        player?.on(onSourceLoad)
-        player?.on(onSourceLoaded)
-        player?.on(onSourceUnloaded)
-        player?.on(onSourceError)
-        player?.on(onSourceWarning)
+        player?.apply {
+            on(onEvent)
+            on(onPlayerError)
+            on(onPlayerWarning)
+            on(onDestroy)
+            on(onMuted)
+            on(onUnmuted)
+            on(onReady)
+            on(onPaused)
+            on(onPlay)
+            on(onPlaying)
+            on(onPlaybackFinished)
+            on(onSeek)
+            on(onSeeked)
+            on(onTimeChanged)
+            on(onSourceLoad)
+            on(onSourceLoaded)
+            on(onSourceUnloaded)
+            on(onSourceError)
+            on(onSourceWarning)
+            on(onSubtitleAdded)
+            on(onSubtitleChanged)
+            on(onSubtitleRemoved)
+        }
     }
 
     /**
      * Stop listening for player events and cease to emit bubbling events.
      */
     fun stopBubblingEvents() {
-        player?.off(onEvent)
-        player?.off(onPlayerError)
-        player?.off(onPlayerWarning)
-        player?.off(onDestroy)
-        player?.off(onMuted)
-        player?.off(onUnmuted)
-        player?.off(onReady)
-        player?.off(onPaused)
-        player?.off(onPlay)
-        player?.off(onPlaying)
-        player?.off(onPlaybackFinished)
-        player?.off(onSeek)
-        player?.off(onSeeked)
-        player?.off(onTimeChanged)
-        player?.off(onSourceLoad)
-        player?.off(onSourceLoaded)
-        player?.off(onSourceUnloaded)
-        player?.off(onSourceError)
-        player?.off(onSourceWarning)
+        player?.apply {
+            off(onEvent)
+            off(onPlayerError)
+            off(onPlayerWarning)
+            off(onDestroy)
+            off(onMuted)
+            off(onUnmuted)
+            off(onReady)
+            off(onPaused)
+            off(onPlay)
+            off(onPlaying)
+            off(onPlaybackFinished)
+            off(onSeek)
+            off(onSeeked)
+            off(onTimeChanged)
+            off(onSourceLoad)
+            off(onSourceLoaded)
+            off(onSourceUnloaded)
+            off(onSourceError)
+            off(onSourceWarning)
+            off(onSubtitleAdded)
+            off(onSubtitleChanged)
+            off(onSubtitleRemoved)
+        }
     }
 
     /**

package/android/src/main/java/com/bitmovin/player/reactnative/RNPlayerViewManager.kt

@@ -1,11 +1,12 @@
 package com.bitmovin.player.reactnative
 
+import android.os.Handler
+import android.os.Looper
 import android.view.ViewGroup.LayoutParams
 import com.bitmovin.player.PlayerView
 import com.facebook.react.bridge.*
 import com.facebook.react.uimanager.SimpleViewManager
 import com.facebook.react.uimanager.ThemedReactContext
-import com.facebook.react.uimanager.UIManagerModule
 
 class RNPlayerViewManager(private val context: ReactApplicationContext) : SimpleViewManager<RNPlayerView>() {
     /**
@@ -13,7 +14,6 @@ class RNPlayerViewManager(private val context: ReactApplicationContext) : Simple
      */
     enum class Commands {
         ATTACH_PLAYER,
-        DETACH_PLAYER,
     }
 
     /**
@@ -51,6 +51,9 @@ class RNPlayerViewManager(private val context: ReactApplicationContext) : Simple
         "sourceUnloaded" to "onSourceUnloaded",
         "sourceError" to "onSourceError",
         "sourceWarning" to "onSourceWarning",
+        "subtitleAdded" to "onSubtitleAdded",
+        "subtitleChanged" to "onSubtitleChanged",
+        "subtitleRemoved" to "onSubtitleRemoved",
     )
 
     /**
@@ -72,13 +75,12 @@ class RNPlayerViewManager(private val context: ReactApplicationContext) : Simple
      * @return map between names (used in js) and command ids (used in native code).
      */
     override fun getCommandsMap(): MutableMap<String, Int> = mutableMapOf(
-        "attachPlayer" to Commands.ATTACH_PLAYER.ordinal,
-        "detachPlayer" to Commands.DETACH_PLAYER.ordinal,
+        "attachPlayer" to Commands.ATTACH_PLAYER.ordinal
     )
 
     /**
      * Callback triggered in response to command dispatches from the js side.
-     * @param root Root native view of the targeted component.
+     * @param view Root native view of the targeted component.
      * @param commandId Command number identifier. It's a number even though RN sends it as a string.
      * @param args Arguments list sent from the js side.
      */
@@ -87,7 +89,6 @@ class RNPlayerViewManager(private val context: ReactApplicationContext) : Simple
         commandId?.toInt()?.let {
             when (it) {
                 Commands.ATTACH_PLAYER.ordinal -> attachPlayer(view, args?.getString(1))
-                Commands.DETACH_PLAYER.ordinal -> detachPlayer(view, args?.getString(1))
                 else -> {}
             }
         }
@@ -98,8 +99,8 @@ class RNPlayerViewManager(private val context: ReactApplicationContext) : Simple
      * @param view Target `RNPlayerView`.
      * @param playerId `Player` instance id inside `PlayerModule`'s registry.
      */
-    private fun attachPlayer(view: RNPlayerView, playerId: String?) {
-        uiManager()?.addUIBlock {
+    private fun attachPlayer(view: RNPlayerView, playerId: NativeId?) {
+        Handler(Looper.getMainLooper()).post {
             val player = getPlayerModule()?.getPlayer(playerId)
             if (view.playerView != null) {
                 view.player = player
@@ -114,26 +115,9 @@ class RNPlayerViewManager(private val context: ReactApplicationContext) : Simple
         }
     }
 
-    /**
-     * Stop sending `Player` bubbling events from `PlayerView`.
-     * @param view Target `RNPlayerView`.
-     * @param playerId `Player` instance id inside `PlayerModule`'s registry.
-     */
-    private fun detachPlayer(view: RNPlayerView, playerId: String?) {
-        uiManager()?.addUIBlock {
-            view.stopBubblingEvents()
-        }
-    }
-
     /**
      * Helper function that gets the instantiated `PlayerModule` from modules registry.
      */
     private fun getPlayerModule(): PlayerModule? =
         context.getNativeModule(PlayerModule::class.java)
-
-    /**
-     * Helper function that returns the initialized `UIManager` instance.
-     */
-    private fun uiManager(): UIManagerModule? =
-        context.getNativeModule(UIManagerModule::class.java)
-}
+}

package/android/src/main/java/com/bitmovin/player/reactnative/RNPlayerViewPackage.kt

@@ -17,7 +17,10 @@ class RNPlayerViewPackage : ReactPackage {
      */
     override fun createNativeModules(reactContext: ReactApplicationContext): MutableList<NativeModule> {
         return mutableListOf(
+            UuidModule(reactContext),
             PlayerModule(reactContext),
+            SourceModule(reactContext),
+            DrmModule(reactContext),
             RNPlayerViewManager(reactContext),
         )
     }

package/android/src/main/java/com/bitmovin/player/reactnative/Registry.kt

@@ -0,0 +1,11 @@
+package com.bitmovin.player.reactnative
+
+/**
+ * Represents the `UUID` string used as index for a certain registry object.
+ */
+typealias NativeId = String
+
+/**
+ * Represents an in memory storage facility that associates an object of type `T` with a certain `NativeId`.
+ */
+typealias Registry<T> = MutableMap<NativeId, T>