expo-video 1.2.2 → 1.2.4

package/CHANGELOG.md

@@ -10,6 +10,34 @@
 
 ### 💡 Others
 
+## 1.2.4 — 2024-07-30
+
+### 🐛 Bug fixes
+
+- [Android] Fix Audio Manager pausing player on the wrong thread and conflicts between players. ([#30453](https://github.com/expo/expo/pull/30453) by [@behenate](https://github.com/behenate))
+- [Android] Fix Audio Manager pausing player on the wrong thread and conflicts between players. ([#30453](https://github.com/expo/expo/pull/30453) by [@behenate](https://github.com/behenate))
+
+### 💡 Others
+
+- [Android] Refactor `VideoPlayer.kt`, organize files ([#30452](https://github.com/expo/expo/pull/30452) by [@behenate](https://github.com/behenate))
+
+## 1.2.3 — 2024-07-11
+
+### 🛠 Breaking changes
+
+- [Android][iOS] Now Picture in Picture has to be enabled via the config plugin to work. ([#30068](https://github.com/expo/expo/pull/30068) by [@behenate](https://github.com/behenate))
+
+### 🎉 New features
+
+- [Web] Add support for events. ([#29742](https://github.com/expo/expo/pull/29742) by [@behenate](https://github.com/behenate))
+- [iOS] Add ability to disable live text interaction. ([#30093](https://github.com/expo/expo/pull/30093) by [@fobos531](https://github.com/fobos531))
+
+### 🐛 Bug fixes
+
+- [Web] Fix `AudioContext` being created before user interaction causing playback issues. ([#29695](https://github.com/expo/expo/pull/29695) by [@behenate](https://github.com/behenate))
+- [iOS] Fix a race condition causing crashes when deallocating the player. ([#30022](https://github.com/expo/expo/pull/30022) by [@behenate](https://github.com/behenate))
+- Add missing `react` and `react-native` peer dependencies for isolated modules. ([#30489](https://github.com/expo/expo/pull/30489) by [@byCedric](https://github.com/byCedric))
+
 ## 1.2.2 — 2024-07-03
 
 ### 🐛 Bug fixes

package/android/build.gradle

@@ -1,7 +1,7 @@
 apply plugin: 'com.android.library'
 
 group = 'host.exp.exponent'
-version = '1.2.2'
+version = '1.2.4'
 
 def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
 apply from: expoModulesCorePlugin
@@ -14,7 +14,7 @@ android {
   namespace "expo.modules.video"
   defaultConfig {
     versionCode 1
-    versionName '1.2.2'
+    versionName '1.2.4'
   }
 }
 

package/android/src/main/AndroidManifest.xml

@@ -6,7 +6,7 @@
   <application>
     <activity android:name=".FullscreenPlayerActivity" />
     <service
-      android:name=".ExpoVideoPlaybackService"
+      android:name=".playbackService.ExpoVideoPlaybackService"
       android:exported="false"
       android:foregroundServiceType="mediaPlayback">
       <intent-filter>

package/android/src/main/java/expo/modules/video/AudioFocusManager.kt

@@ -0,0 +1,187 @@
+package expo.modules.video
+
+import android.content.Context
+import android.media.AudioAttributes
+import android.media.AudioFocusRequest
+import android.media.AudioManager
+import android.os.Build
+import androidx.media3.common.util.UnstableApi
+import expo.modules.kotlin.AppContext
+import expo.modules.video.records.VolumeEvent
+import kotlinx.coroutines.launch
+import java.lang.ref.WeakReference
+
+@UnstableApi
+class AudioFocusManager(private val appContext: AppContext) : AudioManager.OnAudioFocusChangeListener, VideoPlayerListener {
+  private val audioManager by lazy {
+    appContext.reactContext?.getSystemService(Context.AUDIO_SERVICE) as? AudioManager ?: run {
+      throw FailedToGetAudioFocusManagerException()
+    }
+  }
+
+  private var players: MutableList<WeakReference<VideoPlayer>> = mutableListOf()
+  private var currentFocusRequest: AudioFocusRequest? = null
+  private val anyPlayerRequiresFocus: Boolean
+    get() = players.any {
+      playerRequiresFocus(it)
+    }
+
+  private fun requestAudioFocus() {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      // We already have audio focus
+      if (currentFocusRequest != null) {
+        return
+      }
+
+      val newFocusRequest = AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN).run {
+        setAudioAttributes(
+          AudioAttributes.Builder().run {
+            setUsage(AudioAttributes.USAGE_MEDIA)
+            setContentType(AudioAttributes.CONTENT_TYPE_MOVIE)
+            setOnAudioFocusChangeListener(this@AudioFocusManager)
+            build()
+          }
+        ).build()
+      }
+      this.currentFocusRequest = newFocusRequest
+      audioManager.requestAudioFocus(newFocusRequest)
+    } else {
+      @Suppress("DEPRECATION")
+      audioManager.requestAudioFocus(
+        this,
+        AudioManager.STREAM_MUSIC,
+        AudioManager.AUDIOFOCUS_GAIN
+      )
+    }
+  }
+
+  private fun abandonAudioFocus() {
+    currentFocusRequest?.let {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        audioManager.abandonAudioFocusRequest(it)
+      } else {
+        @Suppress("DEPRECATION")
+        audioManager.abandonAudioFocus(this)
+      }
+    }
+    currentFocusRequest = null
+  }
+
+  fun registerPlayer(player: VideoPlayer) {
+    players.find { it.get() == player } ?: run {
+      players.add(WeakReference(player))
+    }
+    player.addListener(this)
+    updateAudioFocus()
+  }
+
+  fun unregisterPlayer(player: VideoPlayer) {
+    player.removeListener(this)
+    players.removeAll { it.get() == player }
+    updateAudioFocus()
+  }
+
+  // VideoPlayerListener
+
+  override fun onIsPlayingChanged(player: VideoPlayer, isPlaying: Boolean, oldIsPlaying: Boolean?) {
+    // we can't use `updateAudioFocus`, because when losing focus the videos are paused sequentially,
+    // which can lead to unexpected results.
+    if (!isPlaying && !anyPlayerRequiresFocus) {
+      abandonAudioFocus()
+    } else if (isPlaying && anyPlayerRequiresFocus) {
+      requestAudioFocus()
+    }
+  }
+
+  override fun onVolumeChanged(player: VideoPlayer, newValue: VolumeEvent, oldVolume: VolumeEvent?) {
+    updateAudioFocus()
+  }
+
+  // AudioManager.OnAudioFocusChangeListener
+
+  override fun onAudioFocusChange(focusChange: Int) {
+    when (focusChange) {
+      AudioManager.AUDIOFOCUS_LOSS -> {
+        appContext.mainQueue.launch {
+          players.forEach {
+            pausePlayerIfUnmuted(it)
+          }
+          currentFocusRequest = null
+        }
+      }
+
+      AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> {
+        appContext.mainQueue.launch {
+          players.forEach {
+            pausePlayerIfUnmuted(it)
+          }
+          currentFocusRequest = null
+        }
+      }
+
+      AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK -> {
+        appContext.mainQueue.launch {
+          players.forEach {
+            duckPlayer(it)
+          }
+        }
+      }
+
+      AudioManager.AUDIOFOCUS_GAIN -> {
+        //  TODO: For now this behaves like iOS and doesn't resume playback automatically
+        //  In future versions we can add a prop to control this behavior.
+        appContext.mainQueue.launch {
+          players.forEach {
+            unduckPlayer(it)
+          }
+        }
+      }
+    }
+  }
+
+  // Utils
+
+  private fun playerRequiresFocus(weakPlayer: WeakReference<VideoPlayer>): Boolean {
+    return weakPlayer.get()?.let {
+      !it.muted && it.playing && it.volume > 0
+    } ?: run {
+      false
+    }
+  }
+
+  private fun pausePlayerIfUnmuted(weakPlayer: WeakReference<VideoPlayer>) {
+    weakPlayer.get()?.let { videoPlayer ->
+      if (!videoPlayer.muted) {
+        appContext.mainQueue.launch {
+          videoPlayer.player.pause()
+        }
+      }
+    }
+  }
+
+  private fun duckPlayer(weakPlayer: WeakReference<VideoPlayer>) {
+    weakPlayer.get()?.let { player ->
+      appContext.mainQueue.launch {
+        player.volume /= 2f
+      }
+    }
+  }
+
+  private fun unduckPlayer(weakPlayer: WeakReference<VideoPlayer>) {
+    weakPlayer.get()?.let { player ->
+      if (!player.muted) {
+        appContext.mainQueue.launch {
+          player.volume = player.userVolume
+        }
+      }
+    }
+  }
+
+  private fun updateAudioFocus() {
+    if (anyPlayerRequiresFocus) {
+      requestAudioFocus()
+    } else {
+      abandonAudioFocus()
+    }
+  }
+}

package/android/src/main/java/expo/modules/video/PlayerEvent.kt

@@ -0,0 +1,54 @@
+package expo.modules.video
+
+import androidx.annotation.OptIn
+import androidx.media3.common.util.UnstableApi
+import expo.modules.video.enums.PlayerStatus
+import expo.modules.video.records.PlaybackError
+import expo.modules.video.records.VideoSource
+import expo.modules.video.records.VolumeEvent
+
+@OptIn(UnstableApi::class)
+sealed class PlayerEvent {
+  open val name: String = ""
+  open val arguments: Array<out Any?> = arrayOf()
+
+  data class StatusChanged(val status: PlayerStatus, val oldStatus: PlayerStatus?, val error: PlaybackError?) : PlayerEvent() {
+    override val name = "statusChange"
+    override val arguments = arrayOf(status, oldStatus, error)
+  }
+
+  data class IsPlayingChanged(val isPlaying: Boolean, val oldIsPlaying: Boolean?) : PlayerEvent() {
+    override val name = "playingChange"
+    override val arguments = arrayOf(isPlaying, oldIsPlaying)
+  }
+
+  data class VolumeChanged(val newValue: VolumeEvent, val oldValue: VolumeEvent?) : PlayerEvent() {
+    override val name = "playingChange"
+    override val arguments = arrayOf(newValue, oldValue)
+  }
+
+  data class SourceChanged(val source: VideoSource?, val oldSource: VideoSource?) : PlayerEvent() {
+    override val name = "sourceChange"
+    override val arguments = arrayOf(source, oldSource)
+  }
+
+  data class PlaybackRateChanged(val rate: Float, val oldRate: Float?) : PlayerEvent() {
+    override val name = "playbackRateChange"
+    override val arguments = arrayOf(rate, oldRate)
+  }
+
+  class PlayedToEnd : PlayerEvent() {
+    override val name = "playToEnd"
+  }
+
+  fun emit(player: VideoPlayer, listeners: List<VideoPlayerListener>) {
+    when (this) {
+      is StatusChanged -> listeners.forEach { it.onStatusChanged(player, status, oldStatus, error) }
+      is IsPlayingChanged -> listeners.forEach { it.onIsPlayingChanged(player, isPlaying, oldIsPlaying) }
+      is VolumeChanged -> listeners.forEach { it.onVolumeChanged(player, newValue, oldValue) }
+      is SourceChanged -> listeners.forEach { it.onSourceChanged(player, source, oldSource) }
+      is PlaybackRateChanged -> listeners.forEach { it.onPlaybackRateChanged(player, rate, oldRate) }
+      is PlayedToEnd -> listeners.forEach { it.onPlayedToEnd(player) }
+    }
+  }
+}

package/android/src/main/java/expo/modules/video/VideoExceptions.kt

@@ -15,6 +15,9 @@ internal class MethodUnsupportedException(methodName: String) :
 internal class PictureInPictureEnterException(message: String?) :
   CodedException("Failed to enter Picture in Picture mode${message?.let { ". $message" } ?: ""}")
 
+internal class PictureInPictureConfigurationException :
+  CodedException("Current activity does not support picture-in-picture. Make sure you have configured the `expo-video` config plugin correctly.")
+
 internal class PictureInPictureUnsupportedException :
   CodedException("Picture in Picture mode is not supported on this device")
 

package/android/src/main/java/expo/modules/video/VideoManager.kt

@@ -2,6 +2,7 @@ package expo.modules.video
 
 import androidx.annotation.OptIn
 import androidx.media3.common.util.UnstableApi
+import expo.modules.kotlin.AppContext
 
 // Helper class used to keep track of all existing VideoViews and VideoPlayers
 @OptIn(UnstableApi::class)
@@ -14,6 +15,12 @@ object VideoManager {
   // Keeps track of all existing VideoPlayers, and whether they are attached to a VideoView
   private var videoPlayersToVideoViews = mutableMapOf<VideoPlayer, MutableList<VideoView>>()
 
+  private lateinit var audioFocusManager: AudioFocusManager
+
+  fun onModuleCreated(appContext: AppContext) {
+    audioFocusManager = AudioFocusManager(appContext)
+  }
+
   fun registerVideoView(videoView: VideoView) {
     videoViews[videoView.id] = videoView
   }
@@ -28,10 +35,12 @@ object VideoManager {
 
   fun registerVideoPlayer(videoPlayer: VideoPlayer) {
     videoPlayersToVideoViews[videoPlayer] = videoPlayersToVideoViews[videoPlayer] ?: mutableListOf()
+    audioFocusManager.registerPlayer(videoPlayer)
   }
 
   fun unregisterVideoPlayer(videoPlayer: VideoPlayer) {
     videoPlayersToVideoViews.remove(videoPlayer)
+    audioFocusManager.unregisterPlayer(videoPlayer)
   }
 
   fun onVideoPlayerAttachedToView(videoPlayer: VideoPlayer, videoView: VideoView) {
@@ -43,7 +52,7 @@ object VideoManager {
     }
 
     if (videoPlayersToVideoViews[videoPlayer]?.size == 1) {
-      videoPlayer.playbackServiceBinder?.service?.registerPlayer(videoPlayer.player)
+      videoPlayer.serviceConnection.playbackServiceBinder?.service?.registerPlayer(videoPlayer.player)
     }
   }
 
@@ -52,7 +61,7 @@ object VideoManager {
 
     // Unregister disconnected VideoPlayers from the playback service
     if (videoPlayersToVideoViews[videoPlayer] == null || videoPlayersToVideoViews[videoPlayer]?.size == 0) {
-      videoPlayer.playbackServiceBinder?.service?.unregisterPlayer(videoPlayer.player)
+      videoPlayer.serviceConnection.playbackServiceBinder?.service?.unregisterPlayer(videoPlayer.player)
     }
   }
 

package/android/src/main/java/expo/modules/video/VideoModule.kt

@@ -3,7 +3,7 @@
 package expo.modules.video
 
 import android.app.Activity
-import android.content.Context
+import android.net.Uri
 import androidx.media3.common.PlaybackParameters
 import androidx.media3.common.Player.REPEAT_MODE_OFF
 import androidx.media3.common.Player.REPEAT_MODE_ONE
@@ -16,7 +16,10 @@ import expo.modules.kotlin.exception.Exceptions
 import expo.modules.kotlin.modules.Module
 import expo.modules.kotlin.modules.ModuleDefinition
 import expo.modules.kotlin.types.Either
+import expo.modules.video.enums.ContentFit
 import expo.modules.video.records.VideoSource
+import expo.modules.video.utils.ifYogaDefinedUse
+import expo.modules.video.utils.makeYogaUndefinedIfNegative
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
 
@@ -25,12 +28,14 @@ import kotlinx.coroutines.runBlocking
 class VideoModule : Module() {
   private val activity: Activity
     get() = appContext.activityProvider?.currentActivity ?: throw Exceptions.MissingActivity()
-  private val reactContext: Context
-    get() = appContext.reactContext ?: throw Exceptions.ReactContextLost()
 
   override fun definition() = ModuleDefinition {
     Name("ExpoVideo")
 
+    OnCreate {
+      VideoManager.onModuleCreated(appContext)
+    }
+
     Function("isPictureInPictureSupported") {
       return@Function VideoView.isPictureInPictureSupported(activity)
     }
@@ -128,7 +133,9 @@ class VideoModule : Module() {
       }
 
       AsyncFunction("startPictureInPicture") { view: VideoView ->
-        view.enterPictureInPicture()
+        view.runWithPiPMisconfigurationSoftHandling(true) {
+          view.enterPictureInPicture()
+        }
       }
 
       AsyncFunction("stopPictureInPicture") {
@@ -266,12 +273,12 @@ class VideoModule : Module() {
         }
       }
 
-      Function("replace") { ref: VideoPlayer, source: Either<String, VideoSource>? ->
+      Function("replace") { ref: VideoPlayer, source: Either<Uri, VideoSource>? ->
         val videoSource = source?.let {
           if (it.`is`(VideoSource::class)) {
             it.get(VideoSource::class)
           } else {
-            VideoSource(it.get(String::class))
+            VideoSource(it.get(Uri::class))
           }
         }