bitmovin-player-react-native 0.3.1 → 0.5.0

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

@@ -0,0 +1,154 @@
+package com.bitmovin.player.reactnative
+
+import com.bitmovin.analytics.bitmovin.player.BitmovinPlayerCollector
+import com.bitmovin.player.reactnative.converter.JsonConverter
+import com.facebook.react.bridge.*
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.UIManagerModule
+
+private const val MODULE_NAME = "AnalyticsModule"
+
+@ReactModule(name = MODULE_NAME)
+class AnalyticsModule(private val context: ReactApplicationContext) : ReactContextBaseJavaModule(context) {
+    /**
+     * In-memory mapping from `nativeId`s to `BitmovinPlayerCollector` instances.
+     */
+    private val collectors: Registry<BitmovinPlayerCollector> = mutableMapOf()
+
+    /**
+     * JS exported module name.
+     */
+    override fun getName() = MODULE_NAME
+
+    /**
+     * Fetches the `BitmovinPlayerCollector` instance associated with `nativeId` from the internal registry.
+     * @param nativeId `BitmovinPlayerCollector` instance ID.
+     * @return The associated `BitmovinPlayerCollector` instance or `null`.
+     */
+    fun getCollector(nativeId: NativeId?): BitmovinPlayerCollector? {
+        if (nativeId == null) {
+            return null
+        }
+        return collectors[nativeId]
+    }
+
+    /**
+     * Creates a new `BitmovinPlayerCollector` instance inside the internal registry using the provided `config` object.
+     * @param config `BitmovinAnalyticsConfig` object received from JS.
+     */
+    @ReactMethod
+    fun initWithConfig(nativeId: NativeId, config: ReadableMap?) {
+        uiManager()?.addUIBlock { _ ->
+            JsonConverter.toAnalyticsConfig(config)?.let {
+                collectors[nativeId] = BitmovinPlayerCollector(it, context)
+            }
+        }
+    }
+
+    /**
+     * Detaches and removes the given `BitmovinPlayerCollector` from the internal registry.
+     * @param nativeId Native Id of the collector instance.
+     */
+    @ReactMethod
+    fun destroy(nativeId: NativeId) {
+        uiManager()?.addUIBlock {
+            if (collectors.containsKey(nativeId)) {
+                collectors[nativeId]?.detachPlayer()
+                collectors.remove(nativeId)
+            }
+        }
+    }
+
+    /**
+     * Attaches a `BitmovinPlayerCollector` to the `Player` instance with native Id equal to `playerId`.
+     * @param nativeId Native Id of the collector instance.
+     * @param playerId Native Id of the player instance.
+     */
+    @ReactMethod
+    fun attach(nativeId: NativeId, playerId: NativeId) {
+        uiManager()?.addUIBlock { _ ->
+            playerModule()?.getPlayer(playerId)?.let {
+                collectors[nativeId]?.attachPlayer(it)
+            }
+        }
+    }
+
+    /**
+     * Detaches the player object from a `BitmovinPlayerCollector` instance.
+     * @param nativeId Native Id of the collector instance.
+     */
+    @ReactMethod
+    fun detach(nativeId: NativeId) {
+        uiManager()?.addUIBlock { _ ->
+            collectors[nativeId]?.detachPlayer()
+        }
+    }
+
+    /**
+     * Updates the custom data config for a `BitmovinPlayerCollector` instance.
+     * @param nativeId Native Id of the collector instance.
+     * @param json Custom data config json.
+     */
+    @ReactMethod
+    fun setCustomDataOnce(nativeId: NativeId, json: ReadableMap?) {
+        uiManager()?.addUIBlock { _ ->
+            JsonConverter.toAnalyticsCustomData(json)?.let {
+                collectors[nativeId]?.setCustomDataOnce(it)
+            }
+        }
+    }
+
+    /**
+     * Sets the custom data config for a `BitmovinPlayerCollector` instance.
+     * @param nativeId Native Id of the collector instance.
+     * @param json Custom data config json.
+     */
+    @ReactMethod
+    fun setCustomData(nativeId: NativeId, json: ReadableMap?) {
+        uiManager()?.addUIBlock { _ ->
+            JsonConverter.toAnalyticsCustomData(json)?.let {
+                collectors[nativeId]?.customData = it
+            }
+        }
+    }
+
+    /**
+     * Gets the current custom data config for a `BitmovinPlayerCollector` instance.
+     * @param nativeId Native Id of the the collector instance.
+     * @param promise JS promise object.
+     */
+    @ReactMethod
+    fun getCustomData(nativeId: NativeId, promise: Promise) {
+        uiManager()?.addUIBlock { _ ->
+            collectors[nativeId]?.let {
+                promise.resolve(JsonConverter.fromAnalyticsCustomData(it.customData))
+            }
+        }
+    }
+
+    /**
+     * Gets the current user Id for a `BitmovinPlayerCollector` instance.
+     * @param nativeId Native Id of the the collector instance.
+     * @param promise JS promise object.
+     */
+    @ReactMethod
+    fun getUserId(nativeId: NativeId, promise: Promise) {
+        uiManager()?.addUIBlock { _ ->
+            collectors[nativeId]?.let {
+                promise.resolve(it.userId)
+            }
+        }
+    }
+
+    /**
+     * Helper function that gets the instantiated `UIManagerModule` from modules registry.
+     */
+    private fun uiManager(): UIManagerModule? =
+        context.getNativeModule(UIManagerModule::class.java)
+
+    /**
+     * Helper function that gets the instantiated `PlayerModule` from modules registry.
+     */
+    private fun playerModule(): PlayerModule? =
+        context.getNativeModule(PlayerModule::class.java)
+}

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

@@ -17,7 +17,9 @@ import kotlin.concurrent.withLock
  */
 typealias PrepareCallback = (ByteArray) -> ByteArray
 
-@ReactModule(name = DrmModule.name)
+private const val MODULE_NAME = "DrmModule"
+
+@ReactModule(name = MODULE_NAME)
 class DrmModule(private val context: ReactApplicationContext) : ReactContextBaseJavaModule(context) {
     /**
      * In-memory mapping from `nativeId`s to `WidevineConfig` instances.
@@ -52,10 +54,7 @@ class DrmModule(private val context: ReactApplicationContext) : ReactContextBase
     /**
      * JS exported module name.
      */
-    companion object {
-        const val name = "DrmModule"
-    }
-    override fun getName() = DrmModule.name
+    override fun getName() = MODULE_NAME
 
     /**
      * Fetches the `WidevineConfig` instance associated with `nativeId` from internal drmConfigs.

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

@@ -6,7 +6,9 @@ import com.facebook.react.bridge.*
 import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.uimanager.UIManagerModule
 
-@ReactModule(name = PlayerModule.name)
+private const val MODULE_NAME = "PlayerModule"
+
+@ReactModule(name = MODULE_NAME)
 class PlayerModule(private val context: ReactApplicationContext) : ReactContextBaseJavaModule(context) {
     /**
      * In-memory mapping from `nativeId`s to `Player` instances.
@@ -16,10 +18,7 @@ class PlayerModule(private val context: ReactApplicationContext) : ReactContextB
     /**
      * JS exported module name.
      */
-    companion object {
-        const val name = "PlayerModule"
-    }
-    override fun getName() = PlayerModule.name
+    override fun getName() = MODULE_NAME
 
     /**
      * Fetches the `Player` instance associated with `nativeId` from the internal players.
@@ -280,6 +279,43 @@ class PlayerModule(private val context: ReactApplicationContext) : ReactContextB
         }
     }
 
+    /**
+     * Schedules an `AdItem` in the `nativeId`'s associated player.
+     * @param nativeId Target player id.
+     * @param adItemJson Json representation of the `AdItem` to be scheduled.
+     */
+    @ReactMethod
+    fun scheduleAd(nativeId: NativeId, adItemJson: ReadableMap?) {
+        JsonConverter.toAdItem(adItemJson)?.let { adItem ->
+            uiManager()?.addUIBlock {
+                players[nativeId]?.scheduleAd(adItem)
+            }
+        }
+    }
+
+    /**
+     * Skips the current ad in `nativeId`'s associated player.
+     * Has no effect if the current ad is not skippable or if no ad is being played back.
+     * @param nativeId Target player id.
+     */
+    @ReactMethod
+    fun skipAd(nativeId: NativeId) {
+        uiManager()?.addUIBlock {
+            players[nativeId]?.skipAd()
+        }
+    }
+
+    /**
+     * Returns `true` while an ad is being played back or when main content playback has been paused for ad playback.
+     * @param nativeId Target player id.
+     */
+    @ReactMethod
+    fun isAd(nativeId: NativeId, promise: Promise) {
+        uiManager()?.addUIBlock {
+            promise.resolve(players[nativeId]?.isAd)
+        }
+    }
+
     /**
      * Helper function that returns the initialized `UIManager` instance.
      */

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

@@ -1,6 +1,9 @@
 package com.bitmovin.player.reactnative
 
 import android.annotation.SuppressLint
+import android.content.res.Configuration
+import android.graphics.Rect
+import android.view.View
 import android.view.ViewGroup
 import android.widget.LinearLayout
 import com.bitmovin.player.PlayerView
@@ -10,6 +13,9 @@ import com.bitmovin.player.api.event.PlayerEvent
 import com.bitmovin.player.api.event.SourceEvent
 import com.bitmovin.player.api.event.on
 import com.bitmovin.player.reactnative.converter.JsonConverter
+import com.bitmovin.player.reactnative.ui.RNPictureInPictureDelegate
+import com.bitmovin.player.reactnative.ui.RNPictureInPictureHandler
+import com.facebook.react.bridge.LifecycleEventListener
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.uimanager.events.RCTEventEmitter
@@ -20,9 +26,10 @@ import com.facebook.react.uimanager.events.RCTEventEmitter
  * exposes player events as bubbling events.
  */
 @SuppressLint("ViewConstructor")
-class RNPlayerView(context: ReactApplicationContext) : LinearLayout(context) {
+class RNPlayerView(val context: ReactApplicationContext) : LinearLayout(context),
+    LifecycleEventListener, View.OnLayoutChangeListener, RNPictureInPictureDelegate {
     /**
-     * Reference to the shared player view set as child.
+     * Associated bitmovin's `PlayerView`.
      */
     var playerView: PlayerView? = null
 
@@ -35,6 +42,57 @@ class RNPlayerView(context: ReactApplicationContext) : LinearLayout(context) {
             playerView?.player = value
         }
 
+    /**
+     * Object that handles PiP mode changes in React Native.
+     */
+    var pictureInPictureHandler: RNPictureInPictureHandler? = null
+
+    /**
+     * Whether this view should pause video playback when activity's onPause is called.
+     * By default, `shouldPausePlaybackOnActivityPause` is set to false when entering PiP mode.
+     */
+    private var shouldPausePlaybackOnActivityPause = true
+
+    /**
+     * Register this view as an activity lifecycle listener on initialization.
+     */
+    init {
+        context.addLifecycleEventListener(this)
+    }
+
+    /**
+     * Cleans up the resources and listeners produced by this view.
+     */
+    fun dispose() {
+        stopBubblingEvents()
+        context.removeLifecycleEventListener(this)
+        playerView?.removeOnLayoutChangeListener(this)
+    }
+
+    /**
+     * Activity's onResume
+     */
+    override fun onHostResume() {
+        playerView?.onResume()
+    }
+
+    /**
+     * Activity's onPause
+     */
+    override fun onHostPause() {
+        if (shouldPausePlaybackOnActivityPause) {
+            playerView?.onPause()
+        }
+        shouldPausePlaybackOnActivityPause = true
+    }
+
+    /**
+     * Activity's onDestroy
+     */
+    override fun onHostDestroy() {
+        playerView?.onDestroy()
+    }
+
     /**
      * Set the given `playerView` as child and start bubbling events.
      * @param playerView Shared player view instance.
@@ -44,6 +102,71 @@ class RNPlayerView(context: ReactApplicationContext) : LinearLayout(context) {
         if (playerView.parent != this) {
             (playerView.parent as ViewGroup?)?.removeView(playerView)
             addView(playerView)
+            startBubblingEvents()
+        }
+        pictureInPictureHandler?.let {
+            it.setDelegate(this)
+            playerView.setPictureInPictureHandler(it)
+            playerView.addOnLayoutChangeListener(this)
+        }
+    }
+
+    /**
+     * Called whenever this view's activity configuration changes.
+     */
+    override fun onConfigurationChanged(newConfig: Configuration?) {
+        super.onConfigurationChanged(newConfig)
+        pictureInPictureHandler?.onConfigurationChanged(newConfig)
+    }
+
+    /**
+     * Called when the player has just entered PiP mode.
+     */
+    override fun onEnterPictureInPicture() {
+        // Playback shouldn't be paused when entering PiP mode.
+        shouldPausePlaybackOnActivityPause = false
+    }
+
+    /**
+     * Called when the player has just exited PiP mode.
+     */
+    override fun onExitPictureInPicture() {
+        // Explicitly call `exitPictureInPicture()` on PlayerView when exiting PiP state, otherwise
+        // the `PictureInPictureExit` event won't get dispatched.
+        playerView?.exitPictureInPicture()
+    }
+
+    /**
+     * Called when the player's PiP mode changes with a new configuration object.
+     */
+    override fun onPictureInPictureModeChanged(isInPictureInPictureMode: Boolean, newConfig: Configuration?) {
+        playerView?.onPictureInPictureModeChanged(isInPictureInPictureMode, newConfig)
+    }
+
+    /**
+     * Called whenever the PiP handler needs to compute the PlayerView's global visible rect.
+     */
+    override fun setSourceRectHint(sourceRectHint: Rect) {
+        playerView?.getGlobalVisibleRect(sourceRectHint)
+    }
+
+    /**
+     * Called whenever PlayerView's layout changes.
+     */
+    override fun onLayoutChange(
+        view: View?,
+        left: Int,
+        top: Int,
+        right: Int,
+        bottom: Int,
+        oldLeft: Int,
+        oldTop: Int,
+        oldRight: Int,
+        oldBottom: Int,
+    ) {
+        if (left != oldLeft || right != oldRight || top != oldTop || bottom != oldBottom) {
+            // Update source rect hint whenever the player's layout change
+            pictureInPictureHandler?.updateSourceRectHint()
         }
     }
 
@@ -153,6 +276,20 @@ class RNPlayerView(context: ReactApplicationContext) : LinearLayout(context) {
         emitEvent("seeked", it)
     }
 
+    /**
+     * `onStallStarted` event callback.
+     */
+    private val onStallStarted: (PlayerEvent.StallStarted) -> Unit = {
+        emitEvent("stallStarted", it)
+    }
+
+    /**
+     * `onStallEnded` event callback.
+     */
+    private val onStallEnded: (PlayerEvent.StallEnded) -> Unit = {
+        emitEvent("stallEnded", it)
+    }
+
     /**
      * `onTimeChanged` event callback.
      */
@@ -216,6 +353,139 @@ class RNPlayerView(context: ReactApplicationContext) : LinearLayout(context) {
         emitEvent("subtitleRemoved", it)
     }
 
+    /**
+     * `onPictureInPictureAvailabilityChanged` event callback.
+     */
+    private val onPictureInPictureAvailabilityChanged: (PlayerEvent.PictureInPictureAvailabilityChanged) -> Unit = {
+        emitEvent("pictureInPictureAvailabilityChanged", it)
+    }
+
+    /**
+     * `onPictureInPictureEnter` event callback.
+     */
+    private val onPictureInPictureEnter: (PlayerEvent.PictureInPictureEnter) -> Unit = {
+        emitEvent("pictureInPictureEnter", it)
+    }
+
+    /**
+     * `onPictureInPictureExit` event callback.
+     */
+    private val onPictureInPictureExit: (PlayerEvent.PictureInPictureExit) -> Unit = {
+        emitEvent("pictureInPictureExit", it)
+    }
+
+    /**
+     * `onAdBreakFinished` event callback.
+     */
+    private val onAdBreakFinished: (PlayerEvent.AdBreakFinished) -> Unit = {
+        emitEvent("adBreakFinished", it)
+    }
+
+    /**
+     * `onAdBreakStarted` event callback.
+     */
+    private val onAdBreakStarted: (PlayerEvent.AdBreakStarted) -> Unit = {
+        emitEvent("adBreakStarted", it)
+    }
+
+    /**
+     * `onAdClicked` event callback.
+     */
+    private val onAdClicked: (PlayerEvent.AdClicked) -> Unit = {
+        emitEvent("adClicked", it)
+    }
+
+    /**
+     * `onAdError` event callback.
+     */
+    private val onAdError: (PlayerEvent.AdError) -> Unit = {
+        emitEvent("adError", it)
+    }
+
+    /**
+     * `onAdFinished` event callback.
+     */
+    private val onAdFinished: (PlayerEvent.AdFinished) -> Unit = {
+        emitEvent("adFinished", it)
+    }
+
+    /**
+     * `onAdManifestLoad` event callback.
+     */
+    private val onAdManifestLoad: (PlayerEvent.AdManifestLoad) -> Unit = {
+        emitEvent("adManifestLoad", it)
+    }
+
+    /**
+     * `onAdManifestLoaded` event callback.
+     */
+    private val onAdManifestLoaded: (PlayerEvent.AdManifestLoaded) -> Unit = {
+        emitEvent("adManifestLoaded", it)
+    }
+
+    /**
+     * `onAdQuartile` event callback.
+     */
+    private val onAdQuartile: (PlayerEvent.AdQuartile) -> Unit = {
+        emitEvent("adQuartile", it)
+    }
+
+    /**
+     * `onAdScheduled` event callback.
+     */
+    private val onAdScheduled: (PlayerEvent.AdScheduled) -> Unit = {
+        emitEvent("adScheduled", it)
+    }
+
+    /**
+     * `onAdSkipped` event callback.
+     */
+    private val onAdSkipped: (PlayerEvent.AdSkipped) -> Unit = {
+        emitEvent("adSkipped", it)
+    }
+
+    /**
+     * `onAdStarted` event callback.
+     */
+    private val onAdStarted: (PlayerEvent.AdStarted) -> Unit = {
+        emitEvent("adStarted", it)
+    }
+
+    /**
+     * `onVideoPlaybackQualityChanged` event callback.
+     */
+    private val onVideoPlaybackQualityChanged: (PlayerEvent.VideoPlaybackQualityChanged) -> Unit = {
+        emitEvent("videoPlaybackQualityChanged", it)
+    }
+
+    /**
+     * `onFullscreenEnabled` event callback.
+     */
+    private val onFullscreenEnabled: (PlayerEvent.FullscreenEnabled) -> Unit = {
+      emitEvent("fullscreenEnabled", it)
+    }
+
+    /**
+     * `onFullscreenEnabled` event callback.
+     */
+    private val onFullscreenDisabled: (PlayerEvent.FullscreenDisabled) -> Unit = {
+      emitEvent("fullscreenDisabled", it)
+    }
+
+    /**
+     * `onFullscreenEnter` event callback.
+     */
+    private val onFullscreenEnter: (PlayerEvent.FullscreenEnter) -> Unit = {
+      emitEvent("fullscreenEnter", it)
+    }
+
+    /**
+     * `onFullscreenEnter` event callback.
+     */
+    private val onFullscreenExit: (PlayerEvent.FullscreenExit) -> Unit = {
+      emitEvent("fullscreenExit", it)
+    }
+
     /**
      * Start listening and emitting player events as bubbling events to the js side.
      */
@@ -234,6 +504,8 @@ class RNPlayerView(context: ReactApplicationContext) : LinearLayout(context) {
             on(onPlaybackFinished)
             on(onSeek)
             on(onSeeked)
+            on(onStallStarted)
+            on(onStallEnded)
             on(onTimeChanged)
             on(onSourceLoad)
             on(onSourceLoaded)
@@ -243,6 +515,27 @@ class RNPlayerView(context: ReactApplicationContext) : LinearLayout(context) {
             on(onSubtitleAdded)
             on(onSubtitleChanged)
             on(onSubtitleRemoved)
+            on(onAdBreakFinished)
+            on(onAdBreakStarted)
+            on(onAdClicked)
+            on(onAdError)
+            on(onAdFinished)
+            on(onAdManifestLoad)
+            on(onAdManifestLoaded)
+            on(onAdQuartile)
+            on(onAdScheduled)
+            on(onAdSkipped)
+            on(onAdStarted)
+            on(onVideoPlaybackQualityChanged)
+        }
+        playerView?.apply {
+            on(onPictureInPictureAvailabilityChanged)
+            on(onPictureInPictureEnter)
+            on(onPictureInPictureExit)
+            on(onFullscreenEnabled)
+            on(onFullscreenDisabled)
+            on(onFullscreenEnter)
+            on(onFullscreenExit)
         }
     }
 
@@ -264,6 +557,8 @@ class RNPlayerView(context: ReactApplicationContext) : LinearLayout(context) {
             off(onPlaybackFinished)
             off(onSeek)
             off(onSeeked)
+            off(onStallStarted)
+            off(onStallEnded)
             off(onTimeChanged)
             off(onSourceLoad)
             off(onSourceLoaded)
@@ -273,6 +568,27 @@ class RNPlayerView(context: ReactApplicationContext) : LinearLayout(context) {
             off(onSubtitleAdded)
             off(onSubtitleChanged)
             off(onSubtitleRemoved)
+            off(onAdBreakFinished)
+            off(onAdBreakStarted)
+            off(onAdClicked)
+            off(onAdError)
+            off(onAdFinished)
+            off(onAdManifestLoad)
+            off(onAdManifestLoaded)
+            off(onAdQuartile)
+            off(onAdScheduled)
+            off(onAdSkipped)
+            off(onAdStarted)
+            off(onVideoPlaybackQualityChanged)
+        }
+        playerView?.apply {
+            off(onPictureInPictureAvailabilityChanged)
+            off(onPictureInPictureEnter)
+            off(onPictureInPictureExit)
+            off(onFullscreenEnabled)
+            off(onFullscreenDisabled)
+            off(onFullscreenEnter)
+            off(onFullscreenExit)
         }
     }