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

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

@@ -0,0 +1,233 @@
+package com.twg.video.core
+
+import android.content.Context
+import android.media.AudioAttributes
+import android.media.AudioManager
+import android.media.AudioFocusRequest
+import android.os.Build
+import androidx.annotation.OptIn
+import androidx.annotation.RequiresApi
+import androidx.media3.common.util.UnstableApi
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.video.HybridVideoPlayer
+import com.margelo.nitro.video.MixAudioMode
+import kotlin.getValue
+import com.twg.video.core.utils.Threading
+
+@OptIn(UnstableApi::class)
+class AudioFocusManager() {
+  private val players = mutableListOf<HybridVideoPlayer>()
+  private var currentMixAudioMode: MixAudioMode? = null
+  private var audioFocusRequest: AudioFocusRequest? = null
+
+  val appContext by lazy {
+    NitroModules.applicationContext ?: throw UnknownError()
+  }
+
+  private val audioManager by lazy {
+    appContext.getSystemService(Context.AUDIO_SERVICE) as? AudioManager ?: throw UnknownError()
+  }
+
+  private val audioFocusChangeListener = AudioManager.OnAudioFocusChangeListener { focusChange ->
+    when (focusChange) {
+      AudioManager.AUDIOFOCUS_GAIN -> {
+        unDuckActivePlayers()
+      }
+      AudioManager.AUDIOFOCUS_LOSS -> {
+        pauseActivePlayers()
+        currentMixAudioMode = null
+        audioFocusRequest = null
+      }
+      AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> {
+        val mixAudioMode = determineRequiredMixMode()
+        if (mixAudioMode != MixAudioMode.MIXWITHOTHERS) {
+          pauseActivePlayers()
+          currentMixAudioMode = null
+          audioFocusRequest = null
+        }
+      }
+      AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK -> {
+        val mixAudioMode = determineRequiredMixMode()
+        when (mixAudioMode) {
+          MixAudioMode.DONOTMIX -> pauseActivePlayers()
+          else -> duckActivePlayers()
+        }
+      }
+    }
+  }
+
+  fun registerPlayer(player: HybridVideoPlayer) {
+    if (!players.contains(player)) {
+      players.add(player)
+    }
+  }
+
+  fun unregisterPlayer(player: HybridVideoPlayer) {
+    players.remove(player)
+    if (players.isEmpty()) {
+      abandonAudioFocus()
+    } else {
+      requestAudioFocusUpdate()
+    }
+  }
+
+  fun requestAudioFocusUpdate() {
+    Threading.runOnMainThread {
+      val requiredMixMode = determineRequiredMixMode()
+
+      if (requiredMixMode == null) {
+        abandonAudioFocus()
+        return@runOnMainThread
+      }
+
+      if (currentMixAudioMode != requiredMixMode) {
+        requestAudioFocus(requiredMixMode)
+      }
+    }
+  }
+
+  private fun determineRequiredMixMode(): MixAudioMode? {
+    val activePlayers = players.filter { player ->
+      player.player.isPlaying && player.player.volume != 0f
+    }
+
+    if (activePlayers.isEmpty()) {
+      return null
+    }
+
+    val anyPlayerNeedsMixWithOthers = activePlayers.any { player ->
+      player.mixAudioMode == MixAudioMode.MIXWITHOTHERS
+    }
+
+    if (anyPlayerNeedsMixWithOthers) {
+      abandonAudioFocus()
+      return MixAudioMode.MIXWITHOTHERS
+    }
+
+    val anyPlayerNeedsExclusiveFocus = activePlayers.any { player ->
+      player.mixAudioMode == MixAudioMode.DONOTMIX
+    }
+
+    val anyPlayerNeedsDucking = activePlayers.any { player ->
+      player.mixAudioMode == MixAudioMode.DUCKOTHERS
+    }
+
+    return when {
+      anyPlayerNeedsExclusiveFocus -> MixAudioMode.DONOTMIX
+      anyPlayerNeedsDucking -> MixAudioMode.DUCKOTHERS
+      else -> MixAudioMode.AUTO
+    }
+  }
+
+    private fun requestAudioFocus(mixMode: MixAudioMode) {
+    val focusType = when (mixMode) {
+      MixAudioMode.DONOTMIX -> AudioManager.AUDIOFOCUS_GAIN
+      MixAudioMode.DUCKOTHERS -> AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK
+      MixAudioMode.AUTO -> AudioManager.AUDIOFOCUS_GAIN_TRANSIENT_MAY_DUCK
+      MixAudioMode.MIXWITHOTHERS -> return // No focus needed for mix with others
+    }
+
+    val result = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      requestAudioFocusNew(focusType)
+    } else {
+      requestAudioFocusLegacy(focusType)
+    }
+
+    if (result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED) {
+      currentMixAudioMode = mixMode
+    } else {
+      currentMixAudioMode = null
+      // Pause players since audio focus couldn't be obtained
+      pauseActivePlayers()
+    }
+  }
+
+  @RequiresApi(Build.VERSION_CODES.O)
+  private fun requestAudioFocusNew(focusType: Int): Int {
+
+    audioFocusRequest = AudioFocusRequest.Builder(focusType)
+      .setAudioAttributes(
+        AudioAttributes.Builder().run {
+          setUsage(AudioAttributes.USAGE_MEDIA)
+          setContentType(AudioAttributes.CONTENT_TYPE_MOVIE)
+          build()
+        }
+      )
+      .setOnAudioFocusChangeListener(audioFocusChangeListener)
+      .build()
+
+    return audioManager.requestAudioFocus(audioFocusRequest!!)
+  }
+
+  @Suppress("DEPRECATION")
+  private fun requestAudioFocusLegacy(focusType: Int): Int {
+    return audioManager.requestAudioFocus(
+      audioFocusChangeListener,
+      AudioManager.STREAM_MUSIC,
+      focusType
+    )
+  }
+
+  private fun abandonAudioFocus() {
+    if (currentMixAudioMode != null) {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        abandonAudioFocusNew()
+      } else {
+        abandonAudioFocusLegacy()
+      }
+      currentMixAudioMode = null
+      audioFocusRequest = null
+    }
+  }
+
+  @RequiresApi(Build.VERSION_CODES.O)
+  private fun abandonAudioFocusNew() {
+    audioFocusRequest?.let { request ->
+      audioManager.abandonAudioFocusRequest(request)
+    }
+  }
+
+  @Suppress("DEPRECATION")
+  private fun abandonAudioFocusLegacy() {
+    audioManager.abandonAudioFocus(audioFocusChangeListener)
+  }
+
+  private fun pauseActivePlayers() {
+    Threading.runOnMainThread {
+      players.forEach { player ->
+        player.player.let { mediaPlayer ->
+          if (mediaPlayer.volume != 0f && mediaPlayer.isPlaying) {
+            mediaPlayer.pause()
+          }
+        }
+      }
+    }
+  }
+
+  private fun duckActivePlayers() {
+    Threading.runOnMainThread {
+      players.forEach { player ->
+        player.player.let { mediaPlayer ->
+          // We need to duck the volume to 50%. After the audio focus is regained,
+          // we will restore the volume to the user's volume.
+          mediaPlayer.volume = mediaPlayer.volume * 0.5f
+        }
+      }
+    }
+  }
+
+  private fun unDuckActivePlayers() {
+    Threading.runOnMainThread {
+      // Resume players that were paused due to audio focus loss
+      players.forEach { player ->
+        player.player.let { mediaPlayer ->
+          // Restore full volume if it was ducked
+          if (mediaPlayer.volume != 0f && mediaPlayer.volume.toDouble() != player.userVolume) {
+            mediaPlayer.volume = player.userVolume.toFloat()
+          }
+        }
+      }
+    }
+  }
+}
+

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

@@ -0,0 +1,105 @@
+package com.twg.video.core
+
+// Base class for all video errors
+abstract class VideoError(
+    open val code: String,
+    message: String
+) : Error("{%@$code::$message@%}")
+
+// Library related errors
+sealed class LibraryError(code: String, message: String) : VideoError(code, message) {
+  object Deallocated : LibraryError(
+    "library/deallocated",
+    "Object has been deallocated"
+  )
+
+  object ApplicationContextNotFound : LibraryError(
+    "library/application-context-not-found",
+    "Application context not found"
+  )
+
+  class MethodNotSupported(val methodName: String) : LibraryError(
+    "library/method-not-supported",
+    "Method $methodName() is not supported on Android"
+  )
+
+  object DRMPluginNotFound : LibraryError(
+    "library/drm-plugin-not-found",
+    "No DRM plugin have been found, please add one to the project",
+  )
+}
+
+// Player related errors
+sealed class PlayerError(code: String, message: String) : VideoError(code, message) {
+  object NotInitialized : PlayerError(
+    "player/not-initialized",
+    "Player has not been initialized (Or has been set to null)"
+  )
+
+  object AssetNotInitialized : PlayerError(
+    "player/asset-not-initialized",
+    "Asset has not been initialized (Or has been set to null)"
+  )
+
+  object InvalidSource : PlayerError(
+    "player/invalid-source",
+    "Invalid source passed to player"
+  )
+
+  object Cancelled : PlayerError(
+    "player/cancelled",
+    "Operation was cancelled"
+  )
+}
+
+// Source related errors
+sealed class SourceError(code: String, message: String) : VideoError(code, message) {
+  class InvalidUri(val uri: String) : SourceError(
+    "source/invalid-uri",
+    "Invalid source file uri: $uri"
+  )
+
+  class MissingReadFilePermission(val uri: String) : SourceError(
+    "source/missing-read-file-permission",
+    "Missing read file permission for source file at $uri"
+  )
+
+  class FileDoesNotExist(val uri: String) : SourceError(
+    "source/file-does-not-exist",
+    "File does not exist at URI: $uri"
+  )
+
+  object FailedToInitializeAsset : SourceError(
+    "source/failed-to-initialize-asset",
+    "Failed to initialize asset"
+  )
+
+  class UnsupportedContentType(val uri: String) : SourceError(
+    "source/unsupported-content-type",
+    "type of content (${uri}) is not supported"
+  )
+
+  object Cancelled : SourceError(
+    "source/cancelled",
+    "Operation was cancelled"
+  )
+}
+
+// View related errors
+sealed class VideoViewError(code: String, message: String) : VideoError(code, message) {
+  class ViewNotFound(val viewId: Int) : VideoViewError(
+    "view/not-found",
+    "View with viewId $viewId not found"
+  )
+  object ViewIsDeallocated : VideoViewError(
+    "view/deallocated",
+    "Attempt to access a view, but it has been deallocated (or not initialized)"
+  )
+  object PictureInPictureNotSupported : VideoViewError(
+    "view/picture-in-picture-not-supported",
+    "Picture in picture is not supported on this device"
+  )
+}
+
+// Unknown error
+class UnknownError : VideoError("unknown/unknown", "Unknown error")

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

@@ -0,0 +1,292 @@
+package com.twg.video.core
+
+import android.util.Log
+import androidx.annotation.OptIn
+import androidx.media3.common.util.UnstableApi
+import com.facebook.react.bridge.LifecycleEventListener
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.video.HybridVideoPlayer
+import com.margelo.nitro.video.MixAudioMode
+import com.twg.video.core.plugins.PluginsRegistry
+import com.twg.video.view.VideoView
+import java.lang.ref.WeakReference
+
+@OptIn(UnstableApi::class)
+object VideoManager : LifecycleEventListener {
+  private const val TAG = "VideoManager"
+  
+  // nitroId -> weak VideoView
+  private val views = mutableMapOf<Int, WeakReference<VideoView>>()
+  // player -> list of nitroIds of views that are using this player
+  private val players = mutableMapOf<HybridVideoPlayer, MutableList<Int>>()
+  
+  // Keep track of players that were paused due to PiP so that they can be resumed later
+  private val playersPausedForPip = mutableSetOf<HybridVideoPlayer>()
+  
+  private var currentPipVideoView: WeakReference<VideoView>? = null
+
+  var audioFocusManager = AudioFocusManager()
+
+  private var lastPlayedNitroId: Int? = null
+
+  init {
+    NitroModules.applicationContext?.apply {
+      addLifecycleEventListener(this@VideoManager)
+    }
+  }
+
+  fun requestPictureInPicture(videoView: VideoView): Boolean {
+    Log.d(TAG, "PiP requested for video nitroId: ${videoView.nitroId}")
+    
+    if (videoView.isInPictureInPicture) {
+      Log.d(TAG, "Video nitroId: ${videoView.nitroId} is already in PiP")
+      return true
+    }
+    
+    // Exit PiP from current video if there is one
+    currentPipVideoView?.get()?.let { currentPipVideo ->
+      if (currentPipVideo != videoView && currentPipVideo.isInPictureInPicture) {
+        Log.d(TAG, "Forcing exit PiP for video nitroId: ${currentPipVideo.nitroId} to make room for nitroId: ${videoView.nitroId}")
+        currentPipVideo.forceExitPictureInPicture()
+      }
+    }
+    
+    // Ensure the player that belongs to this view is attached back to this view
+    videoView.hybridPlayer?.movePlayerToVideoView(videoView)
+    
+    // Pause every other player that might be playing in the background so that only the PiP video plays
+    pauseOtherPlayers(videoView)
+    
+    // Set this video as the designated PiP video BEFORE entering PiP mode
+    // This ensures the PictureInPictureHelperFragment callbacks know which video should respond
+    currentPipVideoView = WeakReference(videoView)
+    Log.d(TAG, "Designated video nitroId: ${videoView.nitroId} as the PiP video")
+    
+    val success = videoView.internalEnterPictureInPicture()
+    Log.d(TAG, "PiP enter result for video nitroId: ${videoView.nitroId} = $success")
+    
+    if (!success) {
+      // If we failed to enter PiP, resume any players we just paused
+      resumePlayersPausedForPip()
+      currentPipVideoView = null
+      Log.w(TAG, "Failed to enter PiP, clearing designated PiP video")
+    }
+    
+    return success
+  }
+  
+  fun notifyPictureInPictureExited(videoView: VideoView) {
+    Log.d(TAG, "PiP exit notification for video nitroId: ${videoView.nitroId}")
+    currentPipVideoView?.get()?.let { currentPipVideo ->
+      if (currentPipVideo == videoView) {
+        Log.d(TAG, "Clearing PiP reference for video nitroId: ${videoView.nitroId}")
+        currentPipVideoView = null
+        // Resume any players that were paused when PiP was entered
+        resumePlayersPausedForPip()
+      }
+    }
+  }
+  
+  fun getCurrentPictureInPictureVideo(): VideoView? {
+    return currentPipVideoView?.get()
+  }
+  
+  fun setCurrentPictureInPictureVideo(videoView: VideoView) {
+    Log.d(TAG, "Setting current PiP video to nitroId: ${videoView.nitroId}")
+    currentPipVideoView = WeakReference(videoView)
+  }
+  
+  fun isAnyVideoInPictureInPicture(): Boolean {
+    return currentPipVideoView?.get()?.isInPictureInPicture == true
+  }
+  
+  fun forceExitAllPictureInPicture() {
+    currentPipVideoView?.get()?.let { currentPipVideo ->
+      if (currentPipVideo.isInPictureInPicture) {
+        currentPipVideo.forceExitPictureInPicture()
+      }
+    }
+    currentPipVideoView = null
+  }
+
+  fun maybePassPlayerToView(player: HybridVideoPlayer) {
+    val views = players[player]?.mapNotNull { getVideoViewWeakReferenceByNitroId(it)?.get() } ?: return
+    val latestView = views.lastOrNull() ?: return
+
+    player.movePlayerToVideoView(latestView)
+  }
+
+  fun registerView(view: VideoView) {
+    views[view.nitroId] = WeakReference<VideoView>(view)
+    PluginsRegistry.shared.notifyVideoViewCreated(WeakReference(view))
+  }
+
+  fun unregisterView(view: VideoView) {
+    view.hybridPlayer?.let {
+      removeViewFromPlayer(view, it)
+    }
+
+    // Clean up PiP reference if this view was in PiP
+    currentPipVideoView?.get()?.let { currentPipVideo ->
+      if (currentPipVideo == view) {
+        currentPipVideoView = null
+      }
+    }
+
+    views.remove(view.nitroId)
+    PluginsRegistry.shared.notifyVideoViewDestroyed(WeakReference(view))
+  }
+
+  fun addViewToPlayer(view: VideoView, player: HybridVideoPlayer) {
+    // Add player to list if it doesn't exist (should not happen)
+    if(!players.containsKey(player)) players[player] = mutableListOf()
+
+    // Check if view is already added to player
+    if(players[player]?.contains(view.nitroId) == true) return
+
+    // Add view to player
+    players[player]?.add(view.nitroId)
+  }
+
+  fun removeViewFromPlayer(view: VideoView, player: HybridVideoPlayer) {
+    players[player]?.remove(view.nitroId)
+
+    // If this was the last view using this player, clean up
+    if (players[player]?.isEmpty() == true) {
+      players.remove(player)
+    } else {
+      // If there are other views using this player, move to the latest one
+      maybePassPlayerToView(player)
+    }
+  }
+
+  fun registerPlayer(player: HybridVideoPlayer) {
+    if (!players.containsKey(player)) {
+      players[player] = mutableListOf()
+    }
+
+    audioFocusManager.registerPlayer(player)
+    PluginsRegistry.shared.notifyPlayerCreated(WeakReference(player))
+  }
+
+  fun unregisterPlayer(player: HybridVideoPlayer) {
+    audioFocusManager.unregisterPlayer(player)
+    PluginsRegistry.shared.notifyPlayerDestroyed(WeakReference(player))
+
+    // Remove player from any views that were using it
+    players[player]?.forEach { nitroId ->
+      views[nitroId]?.get()?.let { view ->
+        view.hybridPlayer = null
+      }
+    }
+
+    players.remove(player)
+  }
+
+  fun getPlayerByNitroId(nitroId: Int): HybridVideoPlayer? {
+    return players.keys.find { player ->
+      players[player]?.contains(nitroId) == true
+    }
+  }
+
+  fun updateVideoViewNitroId(oldNitroId: Int, newNitroId: Int, view: VideoView) {
+    // Remove old mapping
+    if (oldNitroId != -1) {
+      views.remove(oldNitroId)
+
+      // Update player mappings
+      players.keys.forEach { player ->
+        players[player]?.let { nitroIds ->
+          if (nitroIds.remove(oldNitroId)) {
+            nitroIds.add(newNitroId)
+    }
+        }
+      }
+    }
+
+    // Add new mapping
+    views[newNitroId] = WeakReference(view)
+  }
+
+  fun getVideoViewWeakReferenceByNitroId(nitroId: Int): WeakReference<VideoView>? {
+    return views[nitroId]
+  }
+
+  // ------------ Lifecycle Handler ------------
+  private fun onAppEnterForeground() {
+    players.keys.forEach { player ->
+      if (player.wasAutoPaused) {
+        player.play()
+      }
+    }
+  }
+
+  private fun onAppEnterBackground() {
+    players.keys.forEach { player ->
+      if (!player.playInBackground && player.isPlaying) {
+        player.wasAutoPaused = player.isPlaying
+        player.pause()
+      }
+    }
+  }
+
+  override fun onHostResume() {
+    onAppEnterForeground()
+  }
+
+  override fun onHostPause() {
+    onAppEnterBackground()
+  }
+
+  override fun onHostDestroy() {
+    forceExitAllPictureInPicture()
+  }
+
+  fun pauseOtherPlayers(pipVideoView: VideoView) {
+    val pipPlayer = pipVideoView.hybridPlayer
+    playersPausedForPip.clear()
+
+    players.keys.forEach { player ->
+      // Skip the player that is used for the PiP view
+      if (player == pipPlayer) return@forEach
+
+      // Pause only if it is currently playing
+      if (player.isPlaying && player.mixAudioMode != MixAudioMode.MIXWITHOTHERS) {
+        player.pause()
+        playersPausedForPip.add(player)
+        Log.v(TAG, "Paused player for PiP (nitroIds: ${players[player]})")
+      }
+    }
+  }
+
+  private fun resumePlayersPausedForPip() {
+    playersPausedForPip.forEach { player ->
+      // Ensure the player is attached to the latest visible VideoView before resuming
+      maybePassPlayerToView(player)
+
+      if (!player.isPlaying) {
+        player.play()
+        Log.v(TAG, "Resumed player after PiP exit (nitroIds: ${players[player]})")
+      }
+    }
+    playersPausedForPip.clear()
+  }
+
+  fun getAnyPlayingVideoView(): VideoView? {
+    return views.values.firstOrNull { ref ->
+      ref.get()?.hybridPlayer?.isPlaying == true
+    }?.get()
+  }
+
+  fun setLastPlayedPlayer(player: HybridVideoPlayer) {
+    // Resolve to the latest view using this player (usually the last one in the list)
+    val nitroIds = players[player] ?: return
+    if (nitroIds.isNotEmpty()) {
+      lastPlayedNitroId = nitroIds.last()
+    }
+  }
+
+  fun getLastPlayedVideoView(): VideoView? {
+    return lastPlayedNitroId?.let { views[it]?.get() }
+  }
+}

package/android/src/main/java/com/twg/video/core/custom/MyRenderersFactory.java

@@ -0,0 +1,78 @@
+package com.twg.video.core.custom;
+
+import androidx.media3.exoplayer.DefaultRenderersFactory;
+import androidx.media3.exoplayer.Renderer;
+import androidx.media3.exoplayer.text.TextOutput;
+
+import android.content.Context;
+import android.os.Looper;
+
+import java.util.ArrayList;
+
+public class MyRenderersFactory extends DefaultRenderersFactory implements TextSynchronizer, TextFilter {
+
+ private MyTextRenderer textRenderer;
+ private long defaultOffsetUs;
+
+  public MyRenderersFactory(Context context, long defaultDelaySub) {
+    super(context);
+    textRenderer = null;
+    defaultOffsetUs = defaultDelaySub;
+  }
+
+   protected void buildTextRenderers(
+    Context context,
+    TextOutput output,
+    Looper outputLooper,
+    int extensionRendererMode,
+    ArrayList<Renderer> out
+  ) {
+    textRenderer = new MyTextRenderer(output, outputLooper);
+    textRenderer.setTextOffset(defaultOffsetUs);
+    textRenderer.experimentalSetLegacyDecodingEnabled(true);
+    out.add(textRenderer);
+  }
+
+// ---------------------------------------------------------------------------
+  // implement: TextSynchronizer
+  // ---------------------------------------------------------------------------
+
+  @Override
+  public long getTextOffset() {
+    // return (textRenderer != null)
+    //   ? textRenderer.getTextOffset()
+    //   : 0l;
+    return defaultOffsetUs;
+  }
+
+  @Override
+  public void setTextOffset(long value) {
+    defaultOffsetUs = value;
+    if (textRenderer != null)
+      textRenderer.setTextOffset(value);
+  }
+
+  @Override
+  public void addTextOffset(long value) {
+    defaultOffsetUs += value;
+    if (textRenderer != null)
+      textRenderer.addTextOffset(value);
+  }
+
+  // ---------------------------------------------------------------------------
+  // implement: TextFilter
+  // ---------------------------------------------------------------------------
+
+  @Override
+  public void setTextFilters(String[] textFilters) {
+    if (textRenderer != null)
+      textRenderer.setTextFilters(textFilters);
+  }
+
+  @Override
+  public void addTextFilters(String[] textFilters) {
+    if (textRenderer != null)
+      textRenderer.addTextFilters(textFilters);
+  }
+
+}