bitmovin-player-react-native 0.5.0 → 0.6.0

package/README.md

@@ -69,9 +69,10 @@ Features of the native mobile Player SDKs are progressively being implemented in
 | Playback of DRM-protected assets | :white_check_mark: Available since v0.2.0 |
 | Subtitles & Captions             | :white_check_mark: Available since v0.2.0 |
 | Advertising                      | :white_check_mark: Available since v0.4.0 |
+| Analytics                        | :white_check_mark: Available since v0.5.0 |
 | Playlist API                     | :x: Not available                         |
+| Casting                          | :x: Not available                         |
 | Offline Playback                 | :x: Not available                         |
-| Analytics                        | :x: Coming Q1 2023                        |
 
 ## Installation
 
@@ -460,9 +461,9 @@ const drmSource: SourceConfig = {
 };
 ```
 
-The [`FairplayConfig`](https://github.com/bitmovin/bitmovin-player-react-native/blob/development/src/drm.ts#L10) interface provides a bunch of hooks that can be used to fetch and transform different DRM related data. Check out the [docs](https://github.com/bitmovin/bitmovin-player-react-native/blob/development/src/drm.ts#L10) for a complete list and detailed information on them.
+The [`FairplayConfig`](https://github.com/bitmovin/bitmovin-player-react-native/blob/development/src/drm/fairplayConfig.ts) interface provides a bunch of hooks that can be used to fetch and transform different DRM related data. Check out the [docs]([https://github.com/bitmovin/bitmovin-player-react-native/blob/development/src/drm/fairplayConfig.ts](https://github.com/bitmovin/bitmovin-player-react-native/blob/development/src/drm/fairplayConfig.ts)) for a complete list and detailed information on them.
 
-Also, don't forget to check out the [example](https://github.com/bitmovin/bitmovin-player-react-native/tree/development/example) app for a complete iOS/Android [DRM example](https://github.com/bitmovin/bitmovin-player-react-native/blob/development/example/src/screens/BasicDRMPlayback.tsx).
+Also, don't forget to check out the [example](https://github.com/bitmovin/bitmovin-player-react-native/tree/development/example) app for a complete iOS/Android [DRM example](https://github.com/bitmovin/bitmovin-player-react-native/blob/development/example/src/screens/BasicDrmPlayback.tsx).
 
 ### Adding external subtitle tracks
 

package/RNBitmovinPlayer.podspec

@@ -19,7 +19,7 @@ Pod::Spec.new do |s|
   s.source_files = "ios/**/*.{h,m,mm,swift}"
 
   s.dependency "React-Core"
-  s.dependency "BitmovinPlayer", "3.32.0"
+  s.dependency "BitmovinPlayer", "3.36.0"
   s.dependency "BitmovinAnalyticsCollector/Core", "2.9.4"
   s.dependency "BitmovinAnalyticsCollector/BitmovinPlayer", "2.9.4"
   s.ios.dependency "GoogleAds-IMA-iOS-SDK", "3.17.0"

package/android/build.gradle

@@ -53,6 +53,6 @@ dependencies {
     implementation 'com.google.ads.interactivemedia.v3:interactivemedia:3.26.0'
     implementation 'com.google.android.gms:play-services-ads-identifier:18.0.1'
     implementation 'com.bitmovin.analytics:collector-bitmovin-player:2.12.1'
-    implementation 'com.bitmovin.player:player:3.26.1'
+    implementation 'com.bitmovin.player:player:3.35.0'
     implementation 'com.facebook.react:react-native:+'
 }

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

@@ -0,0 +1,47 @@
+package com.bitmovin.player.reactnative
+
+import com.bitmovin.player.api.event.Event
+import com.bitmovin.player.api.event.EventEmitter
+import kotlin.reflect.KClass
+
+private data class Subscription<E : Event>(
+    val eventClass: KClass<out E>,
+    val action: (E) -> Unit,
+)
+
+/**
+ * Attaches and detaches listener for the provided forwarding events on the current [EventEmitter] instance and
+ * relays the received events together with their associated name to the provided event output.
+ */
+class EventRelay<E : EventEmitter<T>, T : Event>(
+    /**
+     * List of events that should be relayed and their associated name.
+     */
+    forwardingEventClassesAndNameMapping: Map<KClass<out T>, String>,
+    /**
+     * Is called for every relayed event together with its associated name.
+     */
+    private val eventOutput: (String, Event) -> Unit
+) {
+    private val eventListeners = forwardingEventClassesAndNameMapping.map {
+        Subscription(it.key) { event -> eventOutput(it.value, event) }
+    }
+
+    /**
+     * The [EventEmitter] for which the events are relayed.
+     */
+    var eventEmitter: E? = null
+        set(value) {
+            field?.detachListeners(eventListeners)
+            field = value
+            value?.attachListeners(eventListeners)
+        }
+}
+
+private fun <T : Event, E : T> EventEmitter<T>.attachListeners(eventListener: List<Subscription<E>>) {
+    eventListener.forEach { on(it.eventClass, it.action) }
+}
+
+private fun <T : Event, E : T> EventEmitter<T>.detachListeners(eventListener: List<Subscription<E>>) {
+    eventListener.forEach { off(it.eventClass, it.action) }
+}

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

@@ -261,6 +261,38 @@ class PlayerModule(private val context: ReactApplicationContext) : ReactContextB
         }
     }
 
+    /**
+     * Resolve `nativeId`'s player available audio tracks.
+     * @param nativeId Target player Id.
+     * @param promise JS promise object.
+     */
+    @ReactMethod
+    fun getAvailableAudioTracks(nativeId: NativeId, promise: Promise) {
+        uiManager()?.addUIBlock {
+            val audioTracks = Arguments.createArray()
+            players[nativeId]?.source?.availableAudioTracks?.let { tracks ->
+                tracks.forEach {
+                    audioTracks.pushMap(JsonConverter.fromAudioTrack(it))
+                }
+            }
+            promise.resolve(audioTracks)
+        }
+    }
+
+    /**
+     * Set `nativeId`'s player audio track.
+     * @param nativeId Target player Id.
+     * @param trackIdentifier The audio track identifier.
+     * @param promise JS promise object.
+     */
+    @ReactMethod
+    fun setAudioTrack(nativeId: NativeId, trackIdentifier: String, promise: Promise) {
+        uiManager()?.addUIBlock {
+            players[nativeId]?.source?.setAudioTrack(trackIdentifier)
+            promise.resolve(null)
+        }
+    }
+
     /**
      * Resolve `nativeId`'s player available subtitle tracks.
      * @param nativeId Target player Id.
@@ -279,6 +311,20 @@ class PlayerModule(private val context: ReactApplicationContext) : ReactContextB
         }
     }
 
+    /**
+     * Set `nativeId`'s player subtitle track.
+     * @param nativeId Target player Id.
+     * @param trackIdentifier The subtitle track identifier.
+     * @param promise JS promise object.
+     */
+    @ReactMethod
+    fun setSubtitleTrack(nativeId: NativeId, trackIdentifier: String?, promise: Promise) {
+        uiManager()?.addUIBlock {
+            players[nativeId]?.source?.setSubtitleTrack(trackIdentifier)
+            promise.resolve(null)
+        }
+    }
+
     /**
      * Schedules an `AdItem` in the `nativeId`'s associated player.
      * @param nativeId Target player id.

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

@@ -11,7 +11,6 @@ import com.bitmovin.player.api.Player
 import com.bitmovin.player.api.event.Event
 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
@@ -19,6 +18,59 @@ 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
+import kotlin.reflect.KClass
+
+private val EVENT_CLASS_TO_REACT_NATIVE_NAME_MAPPING = mapOf(
+    PlayerEvent::class to "event",
+    PlayerEvent.Error::class to "playerError",
+    PlayerEvent.Warning::class to "playerWarning",
+    PlayerEvent.Destroy::class to "destroy",
+    PlayerEvent.Muted::class to "muted",
+    PlayerEvent.Unmuted::class to "unmuted",
+    PlayerEvent.Ready::class to "ready",
+    PlayerEvent.Paused::class to "paused",
+    PlayerEvent.Play::class to "play",
+    PlayerEvent.Playing::class to "playing",
+    PlayerEvent.PlaybackFinished::class to "playbackFinished",
+    PlayerEvent.Seek::class to "seek",
+    PlayerEvent.Seeked::class to "seeked",
+    PlayerEvent.StallStarted::class to "stallStarted",
+    PlayerEvent.StallEnded::class to "stallEnded",
+    PlayerEvent.TimeChanged::class to "timeChanged",
+    SourceEvent.Load::class to "sourceLoad",
+    SourceEvent.Loaded::class to "sourceLoaded",
+    SourceEvent.Unloaded::class to "sourceUnloaded",
+    SourceEvent.Error::class to "sourceError",
+    SourceEvent.Warning::class to "sourceWarning",
+    SourceEvent.SubtitleTrackAdded::class to "subtitleAdded",
+    SourceEvent.SubtitleTrackChanged::class to "subtitleChanged",
+    SourceEvent.SubtitleTrackRemoved::class to "subtitleRemoved",
+    SourceEvent.AudioTrackAdded::class to "audioAdded",
+    SourceEvent.AudioTrackChanged::class to "audioChanged",
+    SourceEvent.AudioTrackRemoved::class to "audioRemoved",
+    PlayerEvent.AdBreakFinished::class to "adBreakFinished",
+    PlayerEvent.AdBreakStarted::class to "adBreakStarted",
+    PlayerEvent.AdClicked::class to "adClicked",
+    PlayerEvent.AdError::class to "adError",
+    PlayerEvent.AdFinished::class to "adFinished",
+    PlayerEvent.AdManifestLoad::class to "adManifestLoad",
+    PlayerEvent.AdManifestLoaded::class to "adManifestLoaded",
+    PlayerEvent.AdQuartile::class to "adQuartile",
+    PlayerEvent.AdScheduled::class to "adScheduled",
+    PlayerEvent.AdSkipped::class to "adSkipped",
+    PlayerEvent.AdStarted::class to "adStarted",
+    PlayerEvent.VideoPlaybackQualityChanged::class to "videoPlaybackQualityChanged",
+)
+
+private val EVENT_CLASS_TO_REACT_NATIVE_NAME_MAPPING_UI = mapOf<KClass<out Event>, String>(
+    PlayerEvent.PictureInPictureAvailabilityChanged::class to "pictureInPictureAvailabilityChanged",
+    PlayerEvent.PictureInPictureEnter::class to "pictureInPictureEnter",
+    PlayerEvent.PictureInPictureExit::class to "pictureInPictureExit",
+    PlayerEvent.FullscreenEnabled::class to "fullscreenEnabled",
+    PlayerEvent.FullscreenDisabled::class to "fullscreenDisabled",
+    PlayerEvent.FullscreenEnter::class to "fullscreenEnter",
+    PlayerEvent.FullscreenExit::class to "fullscreenExit",
+)
 
 /**
  * Native view wrapper for component instances. It both serves as the main view
@@ -28,10 +80,26 @@ import com.facebook.react.uimanager.events.RCTEventEmitter
 @SuppressLint("ViewConstructor")
 class RNPlayerView(val context: ReactApplicationContext) : LinearLayout(context),
     LifecycleEventListener, View.OnLayoutChangeListener, RNPictureInPictureDelegate {
+    /**
+     * Relays the provided set of events, emitted by the player, together with the associated name
+     * to the `eventOutput` callback.
+     */
+    private val playerEventRelay = EventRelay<Player, Event>(EVENT_CLASS_TO_REACT_NATIVE_NAME_MAPPING, ::emitEvent)
+    /**
+     * Relays the provided set of events, emitted by the player view, together with the associated name
+     * to the `eventOutput` callback.
+     */
+    private val viewEventRelay = EventRelay<PlayerView, Event>(EVENT_CLASS_TO_REACT_NATIVE_NAME_MAPPING_UI, ::emitEvent)
+
     /**
      * Associated bitmovin's `PlayerView`.
      */
     var playerView: PlayerView? = null
+        set(value) {
+            field = value
+            viewEventRelay.eventEmitter = field
+            playerEventRelay.eventEmitter = field?.player
+        }
 
     /**
      * Handy property accessor for `playerView`'s player instance.
@@ -40,6 +108,7 @@ class RNPlayerView(val context: ReactApplicationContext) : LinearLayout(context)
         get() = playerView?.player
         set(value) {
             playerView?.player = value
+            playerEventRelay.eventEmitter = value
         }
 
     /**
@@ -64,7 +133,8 @@ class RNPlayerView(val context: ReactApplicationContext) : LinearLayout(context)
      * Cleans up the resources and listeners produced by this view.
      */
     fun dispose() {
-        stopBubblingEvents()
+        viewEventRelay.eventEmitter = null
+        playerEventRelay.eventEmitter = null
         context.removeLifecycleEventListener(this)
         playerView?.removeOnLayoutChangeListener(this)
     }
@@ -102,7 +172,6 @@ class RNPlayerView(val context: ReactApplicationContext) : LinearLayout(context)
         if (playerView.parent != this) {
             (playerView.parent as ViewGroup?)?.removeView(playerView)
             addView(playerView)
-            startBubblingEvents()
         }
         pictureInPictureHandler?.let {
             it.setDelegate(this)
@@ -180,418 +249,12 @@ class RNPlayerView(val context: ReactApplicationContext) : LinearLayout(context)
         post {
             measure(
                 MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY),
-                MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY))
+                MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY)
+            )
             layout(left, top, right, bottom)
         }
     }
 
-    /**
-     * `onEvent` event callback.
-     */
-    private val onEvent: (PlayerEvent) -> Unit = {
-        emitEvent("event", it)
-    }
-
-    /**
-     * `onPlayerError` event callback.
-     */
-    private val onPlayerError: (PlayerEvent.Error) -> Unit = {
-        emitEvent("playerError", it)
-    }
-
-    /**
-     * `onPlayerWarning` event callback.
-     */
-    private val onPlayerWarning: (PlayerEvent.Warning) -> Unit = {
-        emitEvent("playerWarning", it)
-    }
-
-    /**
-     * `onDestroy` event callback.
-     */
-    private val onDestroy: (PlayerEvent.Destroy) -> Unit = {
-        emitEvent("destroy", it)
-    }
-
-    /**
-     * `onMuted` event callback.
-     */
-    private val onMuted: (PlayerEvent.Muted) -> Unit = {
-        emitEvent("muted", it)
-    }
-
-    /**
-     * `onUnmuted` event callback.
-     */
-    private val onUnmuted: (PlayerEvent.Unmuted) -> Unit = {
-        emitEvent("unmuted", it)
-    }
-
-    /**
-     * `onReady` event callback.
-     */
-    private val onReady: (PlayerEvent.Ready) -> Unit = {
-        emitEvent("ready", it)
-    }
-
-    /**
-     * `onPaused` event callback.
-     */
-    private val onPaused: (PlayerEvent.Paused) -> Unit = {
-        emitEvent("paused", it)
-    }
-
-    /**
-     * `onPlay` event callback.
-     */
-    private val onPlay: (PlayerEvent.Play) -> Unit = {
-        emitEvent("play", it)
-    }
-
-    /**
-     * `onPlaying` event callback.
-     */
-    private val onPlaying: (PlayerEvent.Playing) -> Unit = {
-        emitEvent("playing", it)
-    }
-
-    /**
-     * `onPlaybackFinished` event callback.
-     */
-    private val onPlaybackFinished: (PlayerEvent.PlaybackFinished) -> Unit = {
-        emitEvent("playbackFinished", it)
-    }
-
-    /**
-     * `onSeek` event callback.
-     */
-    private val onSeek: (PlayerEvent.Seek) -> Unit = {
-        emitEvent("seek", it)
-    }
-
-    /**
-     * `onSeeked` event callback.
-     */
-    private val onSeeked: (PlayerEvent.Seeked) -> Unit = {
-        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.
-     */
-    private val onTimeChanged: (PlayerEvent.TimeChanged) -> Unit = {
-        emitEvent("timeChanged", it)
-    }
-
-    /**
-     * `onSourceLoad` event callback.
-     */
-    private val onSourceLoad: (SourceEvent.Load) -> Unit = {
-        emitEvent("sourceLoad", it)
-    }
-
-    /**
-     * `onSourceLoaded` event callback.
-     */
-    private val onSourceLoaded: (SourceEvent.Loaded) -> Unit = {
-        emitEvent("sourceLoaded", it)
-    }
-
-    /**
-     * `onSourceUnloaded` event callback.
-     */
-    private val onSourceUnloaded: (SourceEvent.Unloaded) -> Unit = {
-        emitEvent("sourceUnloaded", it)
-    }
-
-    /**
-     * `onSourceError` event callback.
-     */
-    private val onSourceError: (SourceEvent.Error) -> Unit = {
-        emitEvent("sourceError", it)
-    }
-
-    /**
-     * `onSourceWarning` event callback.
-     */
-    private val onSourceWarning: (SourceEvent.Warning) -> Unit = {
-        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)
-    }
-
-    /**
-     * `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.
-     */
-    fun startBubblingEvents() {
-        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(onStallStarted)
-            on(onStallEnded)
-            on(onTimeChanged)
-            on(onSourceLoad)
-            on(onSourceLoaded)
-            on(onSourceUnloaded)
-            on(onSourceError)
-            on(onSourceWarning)
-            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)
-        }
-    }
-
-    /**
-     * Stop listening for player events and cease to emit bubbling events.
-     */
-    fun stopBubblingEvents() {
-        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(onStallStarted)
-            off(onStallEnded)
-            off(onTimeChanged)
-            off(onSourceLoad)
-            off(onSourceLoaded)
-            off(onSourceUnloaded)
-            off(onSourceError)
-            off(onSourceWarning)
-            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)
-        }
-    }
-
     /**
      * Emits a bubbling event with payload to js.
      * @param event Native event name.

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

@@ -78,6 +78,9 @@ class RNPlayerViewManager(private val context: ReactApplicationContext) : Simple
         "sourceUnloaded" to "onSourceUnloaded",
         "sourceError" to "onSourceError",
         "sourceWarning" to "onSourceWarning",
+        "audioAdded" to "onAudioAdded",
+        "audioChanged" to "onAudioChanged",
+        "audioRemoved" to "onAudioRemoved",
         "subtitleAdded" to "onSubtitleAdded",
         "subtitleChanged" to "onSubtitleChanged",
         "subtitleRemoved" to "onSubtitleRemoved",