@pigeonmal/react-native-video 7.0.0-beta.2

package/android/src/main/java/com/twg/video/core/player/MediaItemUtils.kt

@@ -0,0 +1,152 @@
+package com.twg.video.core.player
+
+import android.util.Log
+import android.webkit.MimeTypeMap
+import androidx.annotation.OptIn
+import androidx.core.net.toUri
+import androidx.media3.common.MediaItem
+import androidx.media3.common.C
+import androidx.media3.common.MediaMetadata
+import androidx.media3.common.MimeTypes
+import androidx.media3.common.util.UnstableApi
+import com.margelo.nitro.video.BufferConfig
+import com.margelo.nitro.video.CustomVideoMetadata
+import com.margelo.nitro.video.HybridVideoPlayerSource
+import com.margelo.nitro.video.LivePlaybackParams
+import com.margelo.nitro.video.NativeDrmParams
+import com.margelo.nitro.video.NativeVideoConfig
+import com.margelo.nitro.video.SubtitleType
+import com.twg.video.core.LibraryError
+import com.twg.video.core.SourceError
+import com.twg.video.core.extensions.toStringExtension
+import com.twg.video.core.plugins.PluginsRegistry
+import com.margelo.nitro.video.ExternalForcedType
+
+private const val TAG = "MediaItemUtils"
+
+@OptIn(UnstableApi::class)
+fun createMediaItemFromVideoConfig(
+  source: HybridVideoPlayerSource
+): MediaItem {
+  val mediaItemBuilder = MediaItem.Builder()
+
+  mediaItemBuilder.setUri(source.config.uri)
+
+  source.config.drm?.let { drmParams ->
+    val drmManager = source.drmManager ?: throw LibraryError.DRMPluginNotFound
+    val drmConfiguration = drmManager.getDRMConfiguration(drmParams)
+    mediaItemBuilder.setDrmConfiguration(drmConfiguration)
+  }
+
+  source.config.bufferConfig?.livePlayback?.let { livePlaybackParams ->
+    mediaItemBuilder.setLiveConfiguration(getLiveConfiguration(livePlaybackParams))
+  }
+
+  source.config.metadata?.let { metadata ->
+    mediaItemBuilder.setMediaMetadata(getCustomMetadata(metadata))
+  }
+
+  if (!source.config.externalSubtitles.isNullOrEmpty()) {
+    mediaItemBuilder.setSubtitleConfigurations(getSubtitlesConfiguration(source.config))
+  }
+
+  when (source.config.forceType) {
+      ExternalForcedType.MPD -> MimeTypes.APPLICATION_MPD
+      ExternalForcedType.M3U8 -> MimeTypes.APPLICATION_M3U8
+      else -> null
+  }?.let { mediaItemBuilder.setMimeType(it) }
+
+  return PluginsRegistry.shared.overrideMediaItemBuilder(
+    source,
+    mediaItemBuilder
+  ).build()
+}
+
+fun getSubtitlesConfiguration(
+  config: NativeVideoConfig,
+): List<MediaItem.SubtitleConfiguration> {
+  val subtitlesConfiguration: MutableList<MediaItem.SubtitleConfiguration> = mutableListOf()
+
+  if (config.externalSubtitles != null) {
+    for ((index, subtitle) in config.externalSubtitles.withIndex()) {
+      val ext = if (subtitle.type == SubtitleType.AUTO) {
+        MimeTypeMap.getFileExtensionFromUrl(subtitle.uri)
+      } else {
+        subtitle.type.toStringExtension()
+      }
+
+      val mimeType = when (ext?.lowercase()) {
+        "srt" -> MimeTypes.APPLICATION_SUBRIP
+        "vtt" -> MimeTypes.TEXT_VTT
+        "ssa", "ass" -> MimeTypes.TEXT_SSA
+        else -> {
+          Log.e(TAG, "Unsupported subtitle extension '$ext' for URI: ${subtitle.uri}. Skipping this subtitle.")
+          continue
+        }
+      }
+
+      try {
+        val subtitleConfig = MediaItem.SubtitleConfiguration.Builder(subtitle.uri.toUri())
+          .setId("external-subtitle-$index")
+          .setMimeType(mimeType)
+          .setSelectionFlags(0) //  C.SELECTION_FLAG_DEFAULT
+          .setRoleFlags(C.ROLE_FLAG_SUBTITLE)
+          .setLabel(subtitle.label)
+          .build()
+        subtitlesConfiguration.add(subtitleConfig)
+      } catch (e: Exception) {
+        Log.e(TAG, "Error creating SubtitleConfiguration for URI ${subtitle.uri}: ${e.message}", e)
+      }
+    }
+  }
+  return subtitlesConfiguration
+}
+
+fun getLiveConfiguration(
+  livePlaybackParams: LivePlaybackParams
+): MediaItem.LiveConfiguration {
+  val liveConfiguration = MediaItem.LiveConfiguration.Builder()
+
+  livePlaybackParams.maxOffsetMs?.let {
+    if (it >= 0) {
+      liveConfiguration.setMaxOffsetMs(it.toLong())
+    }
+  }
+
+  livePlaybackParams.minOffsetMs?.let {
+    if (it >= 0) {
+      liveConfiguration.setMinOffsetMs(it.toLong())
+    }
+  }
+
+  livePlaybackParams.targetOffsetMs?.let {
+    if (it >= 0) {
+      liveConfiguration.setTargetOffsetMs(it.toLong())
+    }
+  }
+
+  livePlaybackParams.maxPlaybackSpeed?.let {
+    if (it >= 0) {
+      liveConfiguration.setMaxPlaybackSpeed(it.toFloat())
+    }
+  }
+
+  livePlaybackParams.minPlaybackSpeed?.let {
+    if (it >= 0) {
+      liveConfiguration.setMinPlaybackSpeed(it.toFloat())
+    }
+  }
+
+  return liveConfiguration.build()
+}
+
+fun getCustomMetadata(metadata: CustomVideoMetadata): MediaMetadata {
+  return MediaMetadata.Builder()
+    .setDisplayTitle(metadata.title)
+    .setTitle(metadata.title)
+    .setSubtitle(metadata.subtitle)
+    .setDescription(metadata.description)
+    .setArtist(metadata.artist)
+    .setArtworkUri(metadata.imageUri?.toUri())
+    .build()
+}

package/android/src/main/java/com/twg/video/core/player/MediaSourceUtils.kt

@@ -0,0 +1,85 @@
+package com.twg.video.core.player
+
+import android.content.Context
+import androidx.annotation.OptIn
+import androidx.media3.common.util.Util
+import androidx.media3.exoplayer.source.MediaSource
+import androidx.core.net.toUri
+import androidx.media3.common.C
+import androidx.media3.datasource.DataSource
+import androidx.media3.common.MediaItem
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.common.MediaMetadata
+import androidx.media3.exoplayer.drm.DrmSessionManager
+import androidx.media3.exoplayer.source.DefaultMediaSourceFactory
+import androidx.media3.exoplayer.source.FilteringMediaSource
+import com.margelo.nitro.video.HybridVideoPlayerSource
+import com.twg.video.core.LibraryError
+import com.twg.video.core.SourceError
+import com.twg.video.core.plugins.PluginsRegistry
+import com.margelo.nitro.video.ExternalAudio
+import androidx.media3.exoplayer.source.MergingMediaSource
+
+@OptIn(UnstableApi::class)
+@Throws(SourceError::class)
+fun buildMediaSource(context: Context, source: HybridVideoPlayerSource, mediaItem: MediaItem): MediaSource {
+
+  val dataSourceFactory = PluginsRegistry.shared.overrideMediaDataSourceFactory(
+    source,
+    buildBaseDataSourceFactory(context, source)
+  )
+
+  val mediaSourceFactory = DefaultMediaSourceFactory(dataSourceFactory)
+
+  source.config.drm?.let {
+    val drmSessionManager = source.drmSessionManager ?: throw LibraryError.DRMPluginNotFound
+    mediaSourceFactory.setDrmSessionManagerProvider { drmSessionManager }
+  }
+
+  val mediasource = PluginsRegistry.shared.overrideMediaSourceFactory(
+    source,
+    mediaSourceFactory,
+    dataSourceFactory
+  ).createMediaSource(mediaItem)
+
+  return source.config.externalAudios
+    ?.takeIf { it.isNotEmpty() }
+    ?.let { configAudioSources(mediasource, it, dataSourceFactory) }
+    ?: mediasource
+}
+
+fun configAudioSources(
+    mediaSource: MediaSource,
+    externalAudios: Array<ExternalAudio>,
+    dataSourceFactory: DataSource.Factory
+): MediaSource {
+    val sourcesToMerge = mutableListOf(mediaSource)
+
+    externalAudios.forEachIndexed { index, track ->
+        try {
+            val audioItem = MediaItem.Builder()
+                .setUri(track.uri)
+                .setMimeType(track.mimetype)
+                .setMediaMetadata(
+                    MediaMetadata.Builder()
+                        .setTitle("external-audio-$index")
+                        .build()
+                )
+                .build()
+
+          // TODO: HEADERS
+            val audioSource = FilteringMediaSource(
+                DefaultMediaSourceFactory(dataSourceFactory).createMediaSource(audioItem),
+                C.TRACK_TYPE_AUDIO
+            )
+
+            sourcesToMerge.add(audioSource)
+        } catch (e: Exception) {
+
+        }
+    }
+
+    // If no external audio was successfully added, return original mediaSource
+    return if (sourcesToMerge.size > 1) MergingMediaSource(*sourcesToMerge.toTypedArray())
+    else mediaSource
+}

package/android/src/main/java/com/twg/video/core/player/OnAudioFocusChangedListener.kt

@@ -0,0 +1,25 @@
+package com.twg.video.core.player
+
+import android.media.AudioManager
+import com.margelo.nitro.video.HybridVideoPlayerEventEmitter
+
+// TODO: We should make VideoFocusManager that will track focus globally for now lets just do simple listener
+class OnAudioFocusChangedListener : AudioManager.OnAudioFocusChangeListener {
+  private var eventEmitter: HybridVideoPlayerEventEmitter? = null
+
+  override fun onAudioFocusChange(focusChange: Int) {
+    when (focusChange) {
+      AudioManager.AUDIOFOCUS_GAIN -> eventEmitter?.onAudioFocusChange(true)
+      AudioManager.AUDIOFOCUS_LOSS -> eventEmitter?.onAudioFocusChange(false)
+      AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> eventEmitter?.onAudioFocusChange(false)
+    }
+  }
+
+  fun setEventEmitter(eventEmitter: HybridVideoPlayerEventEmitter) {
+    this.eventEmitter = eventEmitter
+  }
+
+  fun removeEventEmitter() {
+    this.eventEmitter = null
+  }
+}

package/android/src/main/java/com/twg/video/core/plugins/PluginsRegistry.kt

@@ -0,0 +1,223 @@
+package com.twg.video.core.plugins
+
+import android.util.Log
+import androidx.annotation.OptIn
+import androidx.media3.common.MediaItem
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.datasource.DataSource
+import androidx.media3.exoplayer.source.MediaSource
+import com.margelo.nitro.video.HybridVideoPlayer
+import com.margelo.nitro.video.HybridVideoPlayerSource
+import com.twg.video.BuildConfig
+import com.twg.video.core.LibraryError
+import com.twg.video.core.player.DRMManagerSpec
+import com.twg.video.view.VideoView
+import java.lang.ref.WeakReference
+
+// Keep these types for platform compatibility
+// On iOS we cannot just export HybridVideoPlayer so we need to keep this typealias
+typealias NativeVideoPlayer = HybridVideoPlayer
+typealias NativeVideoPlayerSource = HybridVideoPlayerSource
+
+class PluginsRegistry {
+  // Plugin ID -> ReactNativeVideoPluginSpec
+  private val plugins: MutableMap<String, ReactNativeVideoPluginSpec> = mutableMapOf()
+
+  companion object {
+    val shared = PluginsRegistry()
+    private const val TAG = "ReactNativeVideoPluginsRegistry"
+  }
+
+  // Public methods
+  fun register(plugin: ReactNativeVideoPluginSpec) {
+    if(hasPlugin(plugin)) {
+      plugins.replace(plugin.id, plugin)
+
+      if (BuildConfig.DEBUG) {
+        Log.d(TAG, "Replaced plugin ${plugin.name} (ID: ${plugin.id})")
+      }
+
+      return
+    }
+
+    plugins.put(plugin.id, plugin)
+
+    if (BuildConfig.DEBUG) {
+      Log.d(TAG, "Registered plugin ${plugin.name} (ID: ${plugin.id})")
+    }
+  }
+
+  @Suppress("unused")
+  fun unregister(plugin: ReactNativeVideoPluginSpec) {
+    if (!hasPlugin(plugin)) {
+      if (BuildConfig.DEBUG) {
+        Log.d(TAG, "Tried to unregister plugin ${plugin.name} (ID: ${plugin.id}), but it was not registered")
+      }
+
+      return
+    }
+
+    plugins.remove(plugin.id)
+
+    if (BuildConfig.DEBUG) {
+      Log.d(TAG, "Unregistered plugin ${plugin.name} (ID: ${plugin.id})")
+    }
+  }
+
+  // Notifications
+  @OptIn(UnstableApi::class)
+  internal fun notifyPlayerCreated(player: WeakReference<NativeVideoPlayer>) {
+    plugins.values.forEach { it.onPlayerCreated(player) }
+  }
+
+  @OptIn(UnstableApi::class)
+  internal fun notifyPlayerDestroyed(player: WeakReference<NativeVideoPlayer>) {
+    plugins.values.forEach { it.onPlayerDestroyed(player) }
+  }
+
+  @OptIn(UnstableApi::class)
+  internal fun notifyVideoViewCreated(view: WeakReference<VideoView>) {
+    plugins.values.forEach { it.onVideoViewCreated(view) }
+  }
+
+  @OptIn(UnstableApi::class)
+  internal fun notifyVideoViewDestroyed(view: WeakReference<VideoView>) {
+    plugins.values.forEach { it.onVideoViewDestroyed(view) }
+  }
+
+  // Internal methods
+
+  /**
+   * Maybe override the source with the plugins.
+   * 
+   * This method is used to override the source with the plugins.
+   * It is called when a source is created and is used to override the source with the plugins.
+   * 
+   * It is not guaranteed that the source will be overridden with the plugins.
+   * If no plugin overrides the source, the original source is returned.
+   *
+   * @param source The source instance.
+   * @return The maybe overridden source instance.
+   */
+  internal fun overrideSource(source: NativeVideoPlayerSource): NativeVideoPlayerSource {
+    var overriddenSource = source
+
+    for (plugin in plugins.values) {
+      overriddenSource = plugin.overrideSource(overriddenSource)
+    }
+
+    return overriddenSource
+  }
+
+  /**
+   * Returns the DRM manager instance from the plugins.
+   *
+   * @throws LibraryError.DRMPluginNotFound If no DRM manager is found.
+   * @return Any
+   */
+   internal fun getDRMManager(source: NativeVideoPlayerSource): DRMManagerSpec {
+    for (plugin in plugins.values) {
+      val manager = plugin.getDRMManager(source)
+
+      if (manager != null) return manager
+    }
+
+    throw LibraryError.DRMPluginNotFound
+  }
+
+  /**
+   * Maybe override the media data source factory with the plugins.
+   *
+   * If no plugin overrides the media data source factory, the original factory is returned.
+   *
+   * @param source The source instance.
+   * @param mediaDataSourceFactory The media data source factory instance.
+   * @return The maybe overridden media data source factory instance.
+   */
+  internal fun overrideMediaDataSourceFactory(
+    source: NativeVideoPlayerSource,
+    mediaDataSourceFactory: DataSource.Factory
+  ): DataSource.Factory {
+    for (plugin in plugins.values) {
+      val factory = plugin.getMediaDataSourceFactory(source, mediaDataSourceFactory)
+
+      if (factory != null) return factory
+    }
+
+    return mediaDataSourceFactory
+  }
+
+  /**
+   * Maybe override the media source factory with the plugins.
+   *
+   * If no plugin overrides the media source factory, the original factory is returned.
+   *
+   * @param source The source instance.
+   * @param mediaSourceFactory The media source factory instance.
+   * @param mediaDataSourceFactory The media data source factory instance.
+   * @return The maybe overridden media source factory instance.
+   */
+  internal fun overrideMediaSourceFactory(
+    source: NativeVideoPlayerSource,
+    mediaSourceFactory: MediaSource.Factory,
+    mediaDataSourceFactory: DataSource.Factory
+  ): MediaSource.Factory {
+    for (plugin in plugins.values) {
+      val factory = plugin.getMediaSourceFactory(source, mediaSourceFactory, mediaDataSourceFactory)
+
+      if (factory != null) return factory
+    }
+
+    return mediaSourceFactory
+  }
+
+  /**
+   * Maybe override the media item builder with the plugins.
+   *
+   * If no plugin overrides the media item builder, the original builder is returned.
+   *
+   * @param source The source instance.
+   * @param mediaItemBuilder The media item builder instance.
+   * @return The maybe overridden media item builder instance.
+   */
+  internal fun overrideMediaItemBuilder(
+    source: NativeVideoPlayerSource,
+    mediaItemBuilder: MediaItem.Builder
+  ): MediaItem.Builder {
+    for (plugin in plugins.values) {
+      val builder = plugin.getMediaItemBuilder(source, mediaItemBuilder)
+
+      if (builder != null) return builder
+    }
+
+    return mediaItemBuilder
+  }
+
+  /**
+   * Maybe disable the cache with the plugins.
+   *
+   * If no plugin disables the cache, the original cache is not disabled.
+   *
+   * @param source The source instance.
+   * @return The maybe disabled cache.
+   */
+  internal fun shouldDisableCache(source: NativeVideoPlayerSource): Boolean {
+    for (plugin in plugins.values) {
+      val shouldDisable = plugin.shouldDisableCache(source)
+
+      if (shouldDisable) return true
+    }
+
+    return false
+  }
+
+  /**
+   * Checks if a plugin is registered.
+   *
+   * @param plugin The plugin instance.
+   * @return True if the plugin is registered, false otherwise.
+   */
+  internal fun hasPlugin(plugin: ReactNativeVideoPluginSpec): Boolean {
+    return plugins.any { it.key == plugin.id }
+  }
+}

package/android/src/main/java/com/twg/video/core/plugins/ReactNativeVideoPlugin.kt

@@ -0,0 +1,173 @@
+package com.twg.video.core.plugins
+
+import androidx.media3.common.MediaItem
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.datasource.DataSource
+import androidx.media3.exoplayer.source.MediaSource
+import com.twg.video.core.player.DRMManagerSpec
+import com.twg.video.view.VideoView
+import java.lang.ref.WeakReference
+
+interface ReactNativeVideoPluginSpec {
+  /**
+   * The ID of the plugin.
+   */
+  val id: String
+
+  /**
+   * The name of the plugin.
+   */
+  val name: String
+
+  /**
+   * Called when a player is created.
+   *
+   * @param player The weak reference to the player instance.
+   */
+  @UnstableApi
+  fun onPlayerCreated(player: WeakReference<NativeVideoPlayer>)
+
+  /**
+   * Called when a player is destroyed.
+   *
+   * @param player The weak reference to the player instance.
+   */
+  @UnstableApi
+  fun onPlayerDestroyed(player: WeakReference<NativeVideoPlayer>)
+
+  /**
+   * Called when a video view is created.
+   *
+   * @param view The weak reference to the video view instance.
+   */
+  @UnstableApi
+  fun onVideoViewCreated(view: WeakReference<VideoView>)
+
+  /**
+   * Called when a video view is destroyed.
+   *
+   * @param view The weak reference to the video view instance.
+   */
+  @UnstableApi
+  fun onVideoViewDestroyed(view: WeakReference<VideoView>)
+  
+  /**
+   * Called when a source is being used to create mediaItem or MediaSource.
+   * You can use it to modify the source before it is used.
+   *
+   * @param source The source instance.
+   * @return The overridden source instance.
+   */
+  fun overrideSource(source: NativeVideoPlayerSource): NativeVideoPlayerSource
+
+  /**
+   * Called when a DRM manager is requested.
+   *
+   * @return The DRM manager instance.
+   */
+  fun getDRMManager(source: NativeVideoPlayerSource): DRMManagerSpec?
+
+
+  /**
+   * Called when a media data source factory is requested.
+   *
+   * @param source The source instance.
+   * @param mediaDataSourceFactory The media data source factory.
+   * @return The media data source factory. If null is returned, the default factory will be used.
+   */
+  fun getMediaDataSourceFactory(
+    source: NativeVideoPlayerSource,
+    mediaDataSourceFactory: DataSource.Factory
+  ): DataSource.Factory?
+
+  /**
+   * Called when a media source factory is requested.
+   *
+   * @param source The source instance.
+   * @param mediaSourceFactory The media source factory.
+   * @param mediaDataSourceFactory The media data source factory.
+   * @return The media source factory. If null is returned, the default factory will be used.
+   */
+  fun getMediaSourceFactory(
+    source: NativeVideoPlayerSource,
+    mediaSourceFactory: MediaSource.Factory,
+    mediaDataSourceFactory: DataSource.Factory
+  ): MediaSource.Factory?
+
+  /**
+   * Called when a media item builder is requested.
+   *
+   * @param source The source instance.
+   * @param mediaItemBuilder The media item builder.
+   * @return The media item builder. If null is returned, the default builder will be used.
+   */
+  fun getMediaItemBuilder(
+    source: NativeVideoPlayerSource,
+    mediaItemBuilder: MediaItem.Builder
+  ): MediaItem.Builder?
+
+  /**
+   * Called when a cache should be disabled.
+   *
+   * @param source The source instance.
+   * @return True if cache should be disabled, false otherwise.
+   */
+  fun shouldDisableCache(source: NativeVideoPlayerSource): Boolean
+}
+
+@Suppress("Unused")
+/**
+ * A helper base implementation of the ReactNativeVideoPluginSpec interface.
+ */
+open class ReactNativeVideoPlugin(override val name: String) : ReactNativeVideoPluginSpec {
+  override val id = "RNV_Plugin_${name}"
+
+  init {
+    // Automatically register the plugin when it is created
+    PluginsRegistry.shared.register(this)
+  }
+
+  @UnstableApi
+  override fun onPlayerCreated(player: WeakReference<NativeVideoPlayer>) { /* NOOP */}
+
+  @UnstableApi
+  override fun onPlayerDestroyed(player: WeakReference<NativeVideoPlayer>) { /* NOOP */}
+
+  @UnstableApi
+  override fun onVideoViewCreated(view: WeakReference<VideoView>) { /* NOOP */}
+
+  @UnstableApi
+  override fun onVideoViewDestroyed(view: WeakReference<VideoView>) { /* NOOP */}
+
+  override fun overrideSource(source: NativeVideoPlayerSource): NativeVideoPlayerSource {
+    return source
+  }
+
+  override fun getDRMManager(source: NativeVideoPlayerSource): DRMManagerSpec? { return null }
+
+  override fun getMediaDataSourceFactory(
+    source: NativeVideoPlayerSource,
+    mediaDataSourceFactory: DataSource.Factory
+  ): DataSource.Factory? {
+    return null
+  }
+
+  override fun getMediaSourceFactory(
+    source: NativeVideoPlayerSource,
+    mediaSourceFactory: MediaSource.Factory,
+    mediaDataSourceFactory: DataSource.Factory
+  ): MediaSource.Factory? {
+    return null
+  }
+
+  override fun getMediaItemBuilder(
+    source: NativeVideoPlayerSource,
+    mediaItemBuilder: MediaItem.Builder
+  ): MediaItem.Builder? {
+    return null
+  }
+
+  override fun shouldDisableCache(source: NativeVideoPlayerSource): Boolean {
+    return false
+  }
+}

package/android/src/main/java/com/twg/video/core/recivers/AudioBecomingNoisyReceiver.kt

@@ -0,0 +1,38 @@
+package com.twg.video.core.recivers
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.media.AudioManager
+import androidx.core.content.ContextCompat
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.video.HybridVideoPlayerEventEmitter
+import com.twg.video.core.LibraryError
+
+class AudioBecomingNoisyReceiver() : BroadcastReceiver() {
+  private var eventEmitter: HybridVideoPlayerEventEmitter? = null
+
+  override fun onReceive(context: Context?, intent: Intent?) {
+    if (intent?.action == AudioManager.ACTION_AUDIO_BECOMING_NOISY) {
+      eventEmitter?.onAudioBecomingNoisy()
+    }
+  }
+
+  fun setEventEmitter(eventEmitter: HybridVideoPlayerEventEmitter) {
+    val context = NitroModules.applicationContext ?: throw LibraryError.ApplicationContextNotFound
+
+    this.eventEmitter = eventEmitter
+    val intentFilter = IntentFilter(AudioManager.ACTION_AUDIO_BECOMING_NOISY)
+    ContextCompat.registerReceiver(
+      context.applicationContext,
+      this,
+      intentFilter,
+      ContextCompat.RECEIVER_NOT_EXPORTED
+    )
+  }
+
+  fun removeEventEmitter() {
+    this.eventEmitter = null
+  }
+}