expo-video 1.2.3 → 1.2.5

package/CHANGELOG.md

@@ -10,6 +10,23 @@
 
 ### 💡 Others
 
+## 1.2.5 — 2024-08-20
+
+### 🐛 Bug fixes
+
+- [Android] Fixed `resolvedLayoutDirection` building issues when using react-native 0.75.X. ([#31064](https://github.com/expo/expo/pull/31064) by [@gabrieldonadel](https://github.com/gabrieldonadel))
+
+## 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
@@ -25,6 +42,7 @@
 
 - [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
 

package/android/build.gradle

@@ -1,7 +1,7 @@
 apply plugin: 'com.android.library'
 
 group = 'host.exp.exponent'
-version = '1.2.3'
+version = '1.2.5'
 
 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.3'
+    versionName '1.2.5'
   }
 }
 

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/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)
     }
@@ -268,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))
           }
         }
 

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

@@ -1,28 +1,22 @@
 package expo.modules.video
 
-import android.content.ComponentName
 import android.content.Context
-import android.content.Context.BIND_AUTO_CREATE
-import android.content.Intent
-import android.content.ServiceConnection
-import android.os.Build
-import android.os.IBinder
-import android.util.Log
 import android.view.SurfaceView
 import androidx.media3.common.MediaItem
 import androidx.media3.common.PlaybackException
 import androidx.media3.common.PlaybackParameters
 import androidx.media3.common.Player
-import androidx.media3.common.Timeline
 import androidx.media3.common.util.UnstableApi
 import androidx.media3.exoplayer.DefaultRenderersFactory
 import androidx.media3.exoplayer.ExoPlayer
-import androidx.media3.session.MediaSessionService
 import androidx.media3.ui.PlayerView
 import expo.modules.kotlin.AppContext
 import expo.modules.kotlin.sharedobjects.SharedObject
+import expo.modules.video.delegates.IgnoreSameSet
 import expo.modules.video.enums.PlayerStatus
 import expo.modules.video.enums.PlayerStatus.*
+import expo.modules.video.playbackService.ExpoVideoPlaybackService
+import expo.modules.video.playbackService.PlaybackServiceConnection
 import expo.modules.video.records.PlaybackError
 import expo.modules.video.records.VideoSource
 import expo.modules.video.records.VolumeEvent
@@ -35,29 +29,23 @@ class VideoPlayer(val context: Context, appContext: AppContext, source: VideoSou
   // This improves the performance of playing DRM-protected content
   private var renderersFactory = DefaultRenderersFactory(context)
     .forceEnableMediaCodecAsynchronousQueueing()
-  val audioFocusManager = VideoPlayerAudioFocusManager(context, WeakReference(this))
+  private var listeners: MutableList<WeakReference<VideoPlayerListener>> = mutableListOf()
+
   val player = ExoPlayer
     .Builder(context, renderersFactory)
     .setLooper(context.mainLooper)
     .build()
 
-  // We duplicate some properties of the player, because we don't want to always use the mainQueue to access them.
-  var playing = false
-    set(value) {
-      if (field != value) {
-        sendEventOnJSThread("playingChange", value, field)
-      }
-      field = value
-    }
+  val serviceConnection = PlaybackServiceConnection(WeakReference(player))
+
+  var playing by IgnoreSameSet(false) { new, old ->
+    sendEvent(PlayerEvent.IsPlayingChanged(new, old))
+  }
 
   var uncommittedSource: VideoSource? = source
-  private var lastLoadedSource: VideoSource? = null
-    set(value) {
-      if (field != value && value != null) {
-        sendEventOnJSThread("sourceChange", value, field)
-      }
-      field = value
-    }
+  private var lastLoadedSource by IgnoreSameSet<VideoSource?>(null) { new, old ->
+    sendEvent(PlayerEvent.SourceChanged(new, old))
+  }
 
   // Volume of the player if there was no mute applied.
   var userVolume = 1f
@@ -66,66 +54,48 @@ class VideoPlayer(val context: Context, appContext: AppContext, source: VideoSou
   var staysActiveInBackground = false
   var preservesPitch = false
     set(preservesPitch) {
-      playbackParameters = applyPitchCorrection(playbackParameters)
       field = preservesPitch
+      playbackParameters = applyPitchCorrection(playbackParameters)
     }
   var showNowPlayingNotification = true
     set(value) {
       field = value
-      playbackServiceBinder?.service?.setShowNotification(value, this.player)
+      serviceConnection.playbackServiceBinder?.service?.setShowNotification(value, this.player)
     }
   var duration = 0f
   var isLive = false
 
-  private var serviceConnection: ServiceConnection
-  internal var playbackServiceBinder: PlaybackServiceBinder? = null
-  lateinit var timeline: Timeline
-
-  var volume = 1f
-    set(volume) {
-      if (player.volume == volume) return
-      player.volume = if (muted) 0f else volume
-      sendEventOnJSThread("volumeChange", VolumeEvent(volume, muted), VolumeEvent(field, muted))
-      field = volume
-    }
+  var volume: Float by IgnoreSameSet(1f) { new: Float, old: Float ->
+    player.volume = if (muted) 0f else new
+    sendEvent(PlayerEvent.VolumeChanged(VolumeEvent(new, muted), VolumeEvent(old, muted)))
+  }
 
-  var muted = false
-    set(muted) {
-      if (field == muted) return
-      sendEventOnJSThread("volumeChange", VolumeEvent(volume, muted), VolumeEvent(volume, field))
-      player.volume = if (muted) 0f else userVolume
-      field = muted
-      audioFocusManager.onPlayerChangedAudioFocusProperty(this@VideoPlayer)
-    }
+  var muted: Boolean by IgnoreSameSet(false) { new: Boolean, old: Boolean ->
+    volume = if (new) 0f else userVolume
+    sendEvent(PlayerEvent.VolumeChanged(VolumeEvent(volume, new), VolumeEvent(volume, old)))
+  }
 
-  var playbackParameters: PlaybackParameters = PlaybackParameters.DEFAULT
-    set(newPlaybackParameters) {
-      if (playbackParameters.speed != newPlaybackParameters.speed) {
-        sendEventOnJSThread("playbackRateChange", newPlaybackParameters.speed, playbackParameters.speed)
-      }
-      val pitchCorrectedPlaybackParameters = applyPitchCorrection(newPlaybackParameters)
-      field = pitchCorrectedPlaybackParameters
+  var playbackParameters by IgnoreSameSet(
+    PlaybackParameters.DEFAULT,
+    propertyMapper = { applyPitchCorrection(it) }
+  ) { new: PlaybackParameters, old: PlaybackParameters ->
+    player.playbackParameters = new
 
-      if (player.playbackParameters != pitchCorrectedPlaybackParameters) {
-        player.playbackParameters = pitchCorrectedPlaybackParameters
-      }
+    if (old.speed != new.speed) {
+      sendEvent(PlayerEvent.PlaybackRateChanged(new.speed, old.speed))
     }
+  }
 
   private val playerListener = object : Player.Listener {
     override fun onIsPlayingChanged(isPlaying: Boolean) {
       this@VideoPlayer.playing = isPlaying
-      audioFocusManager.onPlayerChangedAudioFocusProperty(this@VideoPlayer)
-    }
-
-    override fun onTimelineChanged(timeline: Timeline, reason: Int) {
-      this@VideoPlayer.timeline = timeline
     }
 
     override fun onMediaItemTransition(mediaItem: MediaItem?, reason: Int) {
       this@VideoPlayer.duration = 0f
       this@VideoPlayer.isLive = false
       if (reason == Player.MEDIA_ITEM_TRANSITION_REASON_REPEAT) {
-        sendEventOnJSThread("playToEnd")
+        sendEvent(PlayerEvent.PlayedToEnd())
       }
       super.onMediaItemTransition(mediaItem, reason)
     }
@@ -144,7 +114,6 @@ class VideoPlayer(val context: Context, appContext: AppContext, source: VideoSou
 
     override fun onVolumeChanged(volume: Float) {
       this@VideoPlayer.volume = volume
-      audioFocusManager.onPlayerChangedAudioFocusProperty(this@VideoPlayer)
     }
 
     override fun onPlaybackParametersChanged(playbackParameters: PlaybackParameters) {
@@ -154,9 +123,9 @@ class VideoPlayer(val context: Context, appContext: AppContext, source: VideoSou
 
     override fun onPlayerErrorChanged(error: PlaybackException?) {
       error?.let {
-        setStatus(ERROR, error)
         this@VideoPlayer.duration = 0f
         this@VideoPlayer.isLive = false
+        setStatus(ERROR, error)
       } ?: run {
         setStatus(playerStateToPlayerStatus(player.playbackState), null)
       }
@@ -166,53 +135,14 @@ class VideoPlayer(val context: Context, appContext: AppContext, source: VideoSou
   }
 
   init {
-    serviceConnection = object : ServiceConnection {
-      override fun onServiceConnected(componentName: ComponentName, binder: IBinder) {
-        playbackServiceBinder = binder as? PlaybackServiceBinder
-        playbackServiceBinder?.service?.registerPlayer(player) ?: run {
-          Log.w(
-            "ExpoVideo",
-            "Expo Video could not bind to the playback service. " +
-              "This will cause issues with playback notifications and sustaining background playback."
-          )
-        }
-      }
-
-      override fun onServiceDisconnected(componentName: ComponentName) {
-        playbackServiceBinder = null
-      }
-
-      override fun onNullBinding(componentName: ComponentName) {
-        Log.w(
-          "ExpoVideo",
-          "Expo Video could not bind to the playback service. " +
-            "This will cause issues with playback notifications and sustaining background playback."
-        )
-      }
-    }
-
-    appContext.reactContext?.apply {
-      val intent = Intent(context, ExpoVideoPlaybackService::class.java)
-      intent.action = MediaSessionService.SERVICE_INTERFACE
-
-      startService(intent)
-
-      val flags = if (Build.VERSION.SDK_INT >= 29) {
-        BIND_AUTO_CREATE or Context.BIND_INCLUDE_CAPABILITIES
-      } else {
-        BIND_AUTO_CREATE
-      }
-
-      bindService(intent, serviceConnection, flags)
-    }
+    ExpoVideoPlaybackService.startService(appContext, context, serviceConnection)
     player.addListener(playerListener)
     VideoManager.registerVideoPlayer(this)
   }
 
   override fun close() {
-    audioFocusManager.onPlayerDestroyed()
     appContext?.reactContext?.unbindService(serviceConnection)
-    playbackServiceBinder?.service?.unregisterPlayer(player)
+    serviceConnection.playbackServiceBinder?.service?.unregisterPlayer(player)
     VideoManager.unregisterVideoPlayer(this@VideoPlayer)
 
     appContext?.mainQueue?.launch {
@@ -270,19 +200,39 @@ class VideoPlayer(val context: Context, appContext: AppContext, source: VideoSou
       else -> IDLE
     }
   }
+
   private fun setStatus(status: PlayerStatus, error: PlaybackException?) {
+    val oldStatus = this.status
+    this.status = status
+
     val playbackError = error?.let {
       PlaybackError(it)
     }
 
     if (playbackError == null && player.playbackState == Player.STATE_ENDED) {
-      sendEventOnJSThread("playToEnd")
+      sendEvent(PlayerEvent.PlayedToEnd())
     }
 
-    if (this.status != status) {
-      sendEventOnJSThread("statusChange", status.value, this.status.value, playbackError)
+    if (this.status != oldStatus) {
+      sendEvent(PlayerEvent.StatusChanged(status, oldStatus, playbackError))
     }
-    this.status = status
+  }
+
+  fun addListener(videoPlayerListener: VideoPlayerListener) {
+    if (listeners.all { it.get() != videoPlayerListener }) {
+      listeners.add(WeakReference(videoPlayerListener))
+    }
+  }
+
+  fun removeListener(videoPlayerListener: VideoPlayerListener) {
+    listeners.removeAll { it.get() == videoPlayerListener }
+  }
+
+  private fun sendEvent(event: PlayerEvent) {
+    // Emits to the native listeners
+    event.emit(this, listeners.mapNotNull { it.get() })
+    // Emits to the JS side
+    sendEventOnJSThread(event.name, *event.arguments)
   }
 
   private fun sendEventOnJSThread(eventName: String, vararg args: Any?) {

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

@@ -0,0 +1,18 @@
+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)
+interface VideoPlayerListener {
+  fun onStatusChanged(player: VideoPlayer, status: PlayerStatus, oldStatus: PlayerStatus?, error: PlaybackError?) {}
+  fun onIsPlayingChanged(player: VideoPlayer, isPlaying: Boolean, oldIsPlaying: Boolean?) {}
+  fun onVolumeChanged(player: VideoPlayer, newValue: VolumeEvent, oldVolume: VolumeEvent?) {}
+  fun onSourceChanged(player: VideoPlayer, source: VideoSource?, oldSource: VideoSource?) {}
+  fun onPlaybackRateChanged(player: VideoPlayer, rate: Float, oldRate: Float?) {}
+  fun onPlayedToEnd(player: VideoPlayer) {}
+}

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

@@ -25,6 +25,8 @@ import expo.modules.kotlin.exception.Exceptions
 import expo.modules.kotlin.viewevent.EventDispatcher
 import expo.modules.kotlin.views.ExpoView
 import expo.modules.video.drawing.OutlineProvider
+import expo.modules.video.enums.ContentFit
+import expo.modules.video.utils.ifYogaDefinedUse
 import java.util.UUID
 
 // https://developer.android.com/guide/topics/media/media3/getting-started/migration-guide#improvements_in_media3
@@ -290,14 +292,21 @@ class VideoView(context: Context, appContext: AppContext) : ExpoView(context, ap
 
     // Draw borders on top of the video
     if (borderDrawableLazyHolder.isInitialized()) {
-      val layoutDirection = if (I18nUtil.getInstance().isRTL(context)) {
+      val newLayoutDirection = if (I18nUtil.getInstance().isRTL(context)) {
         LAYOUT_DIRECTION_RTL
       } else {
         LAYOUT_DIRECTION_LTR
       }
 
       borderDrawable.apply {
-        resolvedLayoutDirection = layoutDirection
+        val setLayoutDirectionMethod = try {
+          // React Native 0.74.0 and below
+          ReactViewBackgroundDrawable::class.java.getDeclaredMethod("setResolvedLayoutDirection", Int::class.java)
+        } catch (e: NoSuchMethodException) {
+          // React Native 0.75.0 and above
+          ReactViewBackgroundDrawable::class.java.getMethod("setLayoutDirectionOverride", Int::class.java)
+        }
+        setLayoutDirectionMethod.invoke(this, newLayoutDirection)
         setBounds(0, 0, width, height)
         draw(canvas)
       }

package/android/src/main/java/expo/modules/video/delegates/IgnoreSameSet.kt

@@ -0,0 +1,24 @@
+package expo.modules.video.delegates
+
+import kotlin.reflect.KProperty
+
+/**
+ * Property delegate, where the set is ignored unless the value has changed.
+ * @param T The type of the property.
+ * @param value The initial value of the property.
+ * @param propertyMapper A function that maps the new value to the property value.
+ * @param didSet A function that is called when the property value has changed.
+*/
+
+class IgnoreSameSet<T : Any?>(private var value: T, val propertyMapper: ((T) -> T) = { v -> v }, val didSet: ((new: T, old: T) -> Unit)? = null) {
+  operator fun getValue(thisRef: Any?, property: KProperty<*>): T {
+    return value
+  }
+
+  operator fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
+    if (this.value == propertyMapper(value)) return
+    val oldValue = this.value
+    this.value = propertyMapper(value)
+    didSet?.invoke(this.value, oldValue)
+  }
+}

package/android/src/main/java/expo/modules/video/drawing/OutlineProvider.kt

@@ -12,7 +12,7 @@ import com.facebook.react.modules.i18nmanager.I18nUtil
 import com.facebook.react.uimanager.FloatUtil
 import com.facebook.react.uimanager.PixelUtil
 import com.facebook.yoga.YogaConstants
-import expo.modules.video.ifYogaUndefinedUse
+import expo.modules.video.utils.ifYogaUndefinedUse
 
 class OutlineProvider(private val mContext: Context) : ViewOutlineProvider() {
   enum class BorderRadiusConfig {

package/android/src/main/java/expo/modules/video/{ContentFit.kt → enums/ContentFit.kt}

@@ -1,4 +1,4 @@
-package expo.modules.video
+package expo.modules.video.enums
 
 import androidx.media3.ui.AspectRatioFrameLayout
 import expo.modules.kotlin.types.Enumerable

package/android/src/main/java/expo/modules/video/{ExpoVideoPlaybackService.kt → playbackService/ExpoVideoPlaybackService.kt}

@@ -1,4 +1,4 @@
-package expo.modules.video
+package expo.modules.video.playbackService
 
 import android.app.NotificationChannel
 import android.app.NotificationManager
@@ -18,6 +18,8 @@ import androidx.media3.session.MediaSessionService
 import androidx.media3.session.MediaStyleNotificationHelper
 import androidx.media3.session.SessionCommand
 import com.google.common.collect.ImmutableList
+import expo.modules.kotlin.AppContext
+import expo.modules.video.R
 
 class PlaybackServiceBinder(val service: ExpoVideoPlaybackService) : Binder()
 
@@ -152,5 +154,22 @@ class ExpoVideoPlaybackService : MediaSessionService() {
     const val CHANNEL_ID = "PlaybackService"
     const val SESSION_SHOW_NOTIFICATION = "showNotification"
     const val SEEK_INTERVAL_MS = 10000L
+
+    fun startService(appContext: AppContext, context: Context, serviceConnection: PlaybackServiceConnection) {
+      appContext.reactContext?.apply {
+        val intent = Intent(context, ExpoVideoPlaybackService::class.java)
+        intent.action = SERVICE_INTERFACE
+
+        startService(intent)
+
+        val flags = if (Build.VERSION.SDK_INT >= 29) {
+          BIND_AUTO_CREATE or Context.BIND_INCLUDE_CAPABILITIES
+        } else {
+          BIND_AUTO_CREATE
+        }
+
+        bindService(intent, serviceConnection, flags)
+      }
+    }
   }
 }

package/android/src/main/java/expo/modules/video/playbackService/PlaybackServiceConnection.kt

@@ -0,0 +1,36 @@
+package expo.modules.video.playbackService
+
+import android.content.ComponentName
+import android.content.ServiceConnection
+import android.os.IBinder
+import android.util.Log
+import androidx.media3.exoplayer.ExoPlayer
+import java.lang.ref.WeakReference
+
+class PlaybackServiceConnection(val player: WeakReference<ExoPlayer>) : ServiceConnection {
+  var playbackServiceBinder: PlaybackServiceBinder? = null
+
+  override fun onServiceConnected(componentName: ComponentName, binder: IBinder) {
+    val player: ExoPlayer = player.get() ?: return
+    playbackServiceBinder = binder as? PlaybackServiceBinder
+    playbackServiceBinder?.service?.registerPlayer(player) ?: run {
+      Log.w(
+        "ExpoVideo",
+        "Expo Video could not bind to the playback service. " +
+          "This will cause issues with playback notifications and sustaining background playback."
+      )
+    }
+  }
+
+  override fun onServiceDisconnected(componentName: ComponentName) {
+    playbackServiceBinder = null
+  }
+
+  override fun onNullBinding(componentName: ComponentName) {
+    Log.w(
+      "ExpoVideo",
+      "Expo Video could not bind to the playback service. " +
+        "This will cause issues with playback notifications and sustaining background playback."
+    )
+  }
+}

package/android/src/main/java/expo/modules/video/{VideoMediaSessionCallback.kt → playbackService/VideoMediaSessionCallback.kt}

@@ -1,4 +1,4 @@
-package expo.modules.video
+package expo.modules.video.playbackService
 
 import android.os.Bundle
 import androidx.media3.common.Player

package/android/src/main/java/expo/modules/video/records/VideoSource.kt

@@ -1,5 +1,6 @@
 package expo.modules.video.records
 import android.content.Context
+import android.net.Uri
 import androidx.annotation.OptIn
 import androidx.media3.common.MediaItem
 import androidx.media3.common.MediaMetadata
@@ -13,7 +14,7 @@ import java.io.Serializable
 
 @OptIn(UnstableApi::class)
 class VideoSource(
-  @Field var uri: String? = null,
+  @Field var uri: Uri? = null,
   @Field var drm: DRMOptions? = null,
   @Field var metadata: VideoMetadata? = null,
   @Field var headers: Map<String, String>? = null
@@ -37,7 +38,7 @@ class VideoSource(
   fun toMediaItem() = MediaItem
     .Builder()
     .apply {
-      setUri(uri ?: "")
+      setUri(uri)
       setMediaId(toMediaId())
       drm?.let {
         if (it.type.isSupported()) {

package/android/src/main/java/expo/modules/video/records/VolumeEvent.kt

@@ -4,7 +4,7 @@ import expo.modules.kotlin.records.Field
 import expo.modules.kotlin.records.Record
 import java.io.Serializable
 
-internal class VolumeEvent(
+class VolumeEvent(
   @Field var volume: Float? = null,
   @Field var isMuted: Boolean? = null
 ) : Record, Serializable

package/android/src/main/java/expo/modules/video/{DataSourceUtils.kt → utils/DataSourceUtils.kt}

@@ -5,6 +5,8 @@ import android.content.pm.ApplicationInfo
 import androidx.annotation.OptIn
 import androidx.media3.common.util.UnstableApi
 import androidx.media3.common.util.Util
+import androidx.media3.datasource.DataSource
+import androidx.media3.datasource.DefaultDataSource
 import androidx.media3.datasource.okhttp.OkHttpDataSource
 import androidx.media3.exoplayer.source.DefaultMediaSourceFactory
 import androidx.media3.exoplayer.source.MediaSource
@@ -12,7 +14,16 @@ import expo.modules.video.records.VideoSource
 import okhttp3.OkHttpClient
 
 @OptIn(UnstableApi::class)
-fun buildDataSourceFactory(context: Context, videoSource: VideoSource): OkHttpDataSource.Factory {
+fun buildDataSourceFactory(context: Context, videoSource: VideoSource): DataSource.Factory {
+  return if (videoSource.uri?.scheme?.startsWith("http") == true) {
+    buildOkHttpDataSourceFactory(context, videoSource)
+  } else {
+    DefaultDataSource.Factory(context)
+  }
+}
+
+@OptIn(UnstableApi::class)
+fun buildOkHttpDataSourceFactory(context: Context, videoSource: VideoSource): OkHttpDataSource.Factory {
   val client = OkHttpClient.Builder().build()
   val userAgent = Util.getUserAgent(context, getApplicationName(context))
   return OkHttpDataSource.Factory(client).apply {
@@ -25,7 +36,7 @@ fun buildDataSourceFactory(context: Context, videoSource: VideoSource): OkHttpDa
   }
 }
 
-fun buildMediaSourceFactory(context: Context, dataSourceFactory: OkHttpDataSource.Factory): MediaSource.Factory {
+fun buildMediaSourceFactory(context: Context, dataSourceFactory: DataSource.Factory): MediaSource.Factory {
   return DefaultMediaSourceFactory(context).setDataSourceFactory(dataSourceFactory)
 }
 

package/android/src/main/java/expo/modules/video/{YogaUtils.kt → utils/YogaUtils.kt}

@@ -1,4 +1,4 @@
-package expo.modules.video
+package expo.modules.video.utils
 
 import com.facebook.yoga.YogaConstants
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "expo-video",
   "title": "Expo Video",
-  "version": "1.2.3",
+  "version": "1.2.5",
   "description": "A cross-platform, performant video component for React Native and Expo with Web support",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -36,5 +36,5 @@
   "peerDependencies": {
     "expo": "*"
   },
-  "gitHead": "48f1ec9d91c5c38c7684cb98a314e443cbeb2185"
+  "gitHead": "80d038d11d216793d00fa5b4607a2c6169cee814"
 }

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

@@ -1,105 +0,0 @@
-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 java.lang.ref.WeakReference
-
-@UnstableApi
-class VideoPlayerAudioFocusManager(val context: Context, private val player: WeakReference<VideoPlayer>) : AudioManager.OnAudioFocusChangeListener {
-  private val audioManager by lazy {
-    context.getSystemService(Context.AUDIO_SERVICE) as? AudioManager ?: run {
-      throw FailedToGetAudioFocusManagerException()
-    }
-  }
-  private var currentFocusRequest: AudioFocusRequest? = null
-  private var volumeBeforeDuck: Float = -1f
-
-  // TODO: @behenate (SDK52) Instead of calling this explicitly in the player we should add functionality
-  //  To register as a player delegate and react to player events.
-  fun onPlayerChangedAudioFocusProperty(player: VideoPlayer) {
-    if (player.playing && !player.muted && player.volume > 0) {
-      requestAudioFocus()
-    } else {
-      abandonAudioFocus()
-    }
-  }
-
-  fun onPlayerDestroyed() {
-    abandonAudioFocus()
-  }
-
-  private fun requestAudioFocus() {
-    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-      if (currentFocusRequest != null) {
-        abandonAudioFocus()
-      }
-
-      val newFocusRequest = AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN).run {
-        setAudioAttributes(
-          AudioAttributes.Builder().run {
-            setUsage(AudioAttributes.USAGE_MEDIA)
-            setContentType(AudioAttributes.CONTENT_TYPE_MOVIE)
-            setOnAudioFocusChangeListener(this@VideoPlayerAudioFocusManager)
-            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
-  }
-
-  override fun onAudioFocusChange(focusChange: Int) {
-    when (focusChange) {
-      AudioManager.AUDIOFOCUS_LOSS -> {
-        player.get()?.player?.pause()
-      }
-
-      AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> {
-        player.get()?.player?.pause()
-      }
-
-      AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK -> {
-        player.get()?.let { player ->
-          volumeBeforeDuck = player.player.volume
-          player.volume = player.volume / 2f
-          player.userVolume = player.volume
-        }
-      }
-
-      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.
-        player.get()?.let { player ->
-          if (player.playing && !player.muted && player.volume > 0) {
-            player.volume = volumeBeforeDuck
-            player.userVolume = player.volume
-          }
-        }
-      }
-    }
-  }
-}