@stepincto/expo-video 1.0.0

package/android/src/main/java/expo/modules/video/enums/PlayerStatus.kt

@@ -0,0 +1,10 @@
+package expo.modules.video.enums
+
+import expo.modules.kotlin.types.Enumerable
+
+enum class PlayerStatus(val value: String) : Enumerable {
+  IDLE("idle"),
+  LOADING("loading"),
+  READY_TO_PLAY("readyToPlay"),
+  ERROR("error")
+}

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

@@ -0,0 +1,184 @@
+package expo.modules.video.playbackService
+
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.content.Context
+import android.content.Intent
+import android.os.Binder
+import android.os.Build
+import android.os.Bundle
+import android.os.IBinder
+import androidx.annotation.OptIn
+import androidx.core.app.NotificationCompat
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.ExoPlayer
+import androidx.media3.session.CommandButton
+import androidx.media3.session.MediaSession
+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
+import expo.modules.video.player.VideoPlayer
+
+class PlaybackServiceBinder(val service: ExpoVideoPlaybackService) : Binder()
+
+@OptIn(UnstableApi::class)
+class ExpoVideoPlaybackService : MediaSessionService() {
+  private val mediaSessions = mutableMapOf<ExoPlayer, MediaSession>()
+  private val binder = PlaybackServiceBinder(this)
+
+  private val commandSeekForward = SessionCommand(SEEK_FORWARD_COMMAND, Bundle.EMPTY)
+  private val commandSeekBackward = SessionCommand(SEEK_BACKWARD_COMMAND, Bundle.EMPTY)
+  private val seekForwardButton = CommandButton.Builder()
+    .setDisplayName("rewind")
+    .setSessionCommand(commandSeekForward)
+    .setIconResId(R.drawable.seek_forwards_10s)
+    .build()
+
+  private val seekBackwardButton = CommandButton.Builder()
+    .setDisplayName("forward")
+    .setSessionCommand(commandSeekBackward)
+    .setIconResId(R.drawable.seek_backwards_10s)
+    .build()
+
+  fun setShowNotification(showNotification: Boolean, player: ExoPlayer) {
+    val sessionExtras = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      mediaSessions[player]?.sessionExtras?.deepCopy() ?: Bundle()
+    } else {
+      Bundle()
+    }
+    sessionExtras.putBoolean(SESSION_SHOW_NOTIFICATION, showNotification)
+    mediaSessions[player]?.let {
+      it.sessionExtras = sessionExtras
+      onUpdateNotification(it, showNotification)
+    }
+  }
+
+  fun registerPlayer(videoPlayer: VideoPlayer) {
+    val player = videoPlayer.player
+    if (mediaSessions[player] != null) {
+      return
+    }
+
+    val mediaSession = MediaSession.Builder(this, player)
+      .setId("ExpoVideoPlaybackService_${player.hashCode()}")
+      .setCallback(VideoMediaSessionCallback())
+      .setCustomLayout(ImmutableList.of(seekBackwardButton, seekForwardButton))
+      .build()
+
+    mediaSessions[player] = mediaSession
+    addSession(mediaSession)
+    setShowNotification(videoPlayer.showNowPlayingNotification, player)
+  }
+
+  fun unregisterPlayer(player: ExoPlayer) {
+    hidePlayerNotification(player)
+    val session = mediaSessions.remove(player)
+    session?.release()
+    if (mediaSessions.isEmpty()) {
+      cleanup()
+      stopSelf()
+    }
+  }
+
+  override fun onBind(intent: Intent?): IBinder {
+    super.onBind(intent)
+    return binder
+  }
+
+  override fun onUpdateNotification(session: MediaSession, startInForegroundRequired: Boolean) {
+    if (session.sessionExtras.getBoolean(SESSION_SHOW_NOTIFICATION, false)) {
+      createNotification(session)
+    } else {
+      (session.player as? ExoPlayer)?.let {
+        hidePlayerNotification(it)
+      }
+    }
+  }
+
+  override fun onTaskRemoved(rootIntent: Intent?) {
+    cleanup()
+    stopSelf()
+  }
+
+  override fun onGetSession(controllerInfo: MediaSession.ControllerInfo): MediaSession? {
+    return null
+  }
+
+  override fun onDestroy() {
+    cleanup()
+    super.onDestroy()
+  }
+
+  private fun createNotification(session: MediaSession) {
+    if (session.player.currentMediaItem == null) {
+      return
+    }
+
+    val notificationManager: NotificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      notificationManager.createNotificationChannel(NotificationChannel(CHANNEL_ID, CHANNEL_ID, NotificationManager.IMPORTANCE_LOW))
+    }
+
+    // If the title is null android sets the notification to "<AppName> is running..." we want to keep the notification empty.
+    val contentTitle = session.player.currentMediaItem?.mediaMetadata?.title ?: "\u200E"
+    val notificationCompat = NotificationCompat.Builder(this, CHANNEL_ID)
+      .setSmallIcon(androidx.media3.session.R.drawable.media3_icon_circular_play)
+      .setContentTitle(contentTitle)
+      .setStyle(MediaStyleNotificationHelper.MediaStyle(session))
+      .build()
+
+    // Each of the players has it's own notification when playing.
+    notificationManager.notify(session.player.hashCode(), notificationCompat)
+  }
+
+  private fun cleanup() {
+    hideAllNotifications()
+
+    val sessionsToRelease = mediaSessions.values.toList()
+    mediaSessions.clear()
+    for (session in sessionsToRelease) {
+      session.release()
+    }
+  }
+
+  private fun hidePlayerNotification(player: ExoPlayer) {
+    val notificationManager: NotificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+    notificationManager.cancel(player.hashCode())
+  }
+
+  private fun hideAllNotifications() {
+    val notificationManager: NotificationManager = getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+    notificationManager.cancelAll()
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+      notificationManager.deleteNotificationChannel(CHANNEL_ID)
+    }
+  }
+
+  companion object {
+    const val SEEK_FORWARD_COMMAND = "SEEK_FORWARD"
+    const val SEEK_BACKWARD_COMMAND = "SEEK_REWIND"
+    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,39 @@
+package expo.modules.video.playbackService
+
+import android.content.ComponentName
+import android.content.ServiceConnection
+import android.os.IBinder
+import android.util.Log
+import androidx.annotation.OptIn
+import androidx.media3.common.util.UnstableApi
+import expo.modules.video.player.VideoPlayer
+import java.lang.ref.WeakReference
+
+@OptIn(UnstableApi::class)
+class PlaybackServiceConnection(val player: WeakReference<VideoPlayer>) : ServiceConnection {
+  var playbackServiceBinder: PlaybackServiceBinder? = null
+
+  override fun onServiceConnected(componentName: ComponentName, binder: IBinder) {
+    val player = 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/playbackService/VideoMediaSessionCallback.kt

@@ -0,0 +1,47 @@
+package expo.modules.video.playbackService
+
+import android.os.Bundle
+import androidx.media3.common.Player
+import androidx.media3.session.MediaSession
+import androidx.media3.session.SessionCommand
+import androidx.media3.session.SessionResult
+import com.google.common.util.concurrent.ListenableFuture
+import androidx.annotation.OptIn
+import androidx.media3.common.util.UnstableApi
+
+@OptIn(UnstableApi::class)
+class VideoMediaSessionCallback : MediaSession.Callback {
+  override fun onConnect(
+    session: MediaSession,
+    controller: MediaSession.ControllerInfo
+  ): MediaSession.ConnectionResult {
+    try {
+      // TODO @behenate: For now we're only allowing seek forward and back by 10 seconds and going to the
+      //  beginning of the video. In the future we should add more customization options for the users.
+      return MediaSession.ConnectionResult.AcceptedResultBuilder(session)
+        .setAvailablePlayerCommands(
+          MediaSession.ConnectionResult.DEFAULT_PLAYER_COMMANDS.buildUpon()
+            .add(Player.COMMAND_SEEK_FORWARD)
+            .add(Player.COMMAND_SEEK_BACK)
+            .build()
+        )
+        .setAvailableSessionCommands(
+          MediaSession.ConnectionResult.DEFAULT_SESSION_COMMANDS.buildUpon()
+            .add(SessionCommand(ExpoVideoPlaybackService.SEEK_BACKWARD_COMMAND, Bundle.EMPTY))
+            .add(SessionCommand(ExpoVideoPlaybackService.SEEK_FORWARD_COMMAND, Bundle.EMPTY))
+            .build()
+        )
+        .build()
+    } catch (e: Exception) {
+      return MediaSession.ConnectionResult.reject()
+    }
+  }
+
+  override fun onCustomCommand(session: MediaSession, controller: MediaSession.ControllerInfo, customCommand: SessionCommand, args: Bundle): ListenableFuture<SessionResult> {
+    when (customCommand.customAction) {
+      ExpoVideoPlaybackService.SEEK_FORWARD_COMMAND -> session.player.seekTo(session.player.currentPosition + ExpoVideoPlaybackService.SEEK_INTERVAL_MS)
+      ExpoVideoPlaybackService.SEEK_BACKWARD_COMMAND -> session.player.seekTo(session.player.currentPosition - ExpoVideoPlaybackService.SEEK_INTERVAL_MS)
+    }
+    return super.onCustomCommand(session, controller, customCommand, args)
+  }
+}

package/android/src/main/java/expo/modules/video/player/FirstFrameEventGenerator.kt

@@ -0,0 +1,93 @@
+package expo.modules.video.player
+
+import androidx.annotation.OptIn
+import androidx.media3.common.MediaItem
+import androidx.media3.common.Player
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.ExoPlayer
+import androidx.media3.ui.PlayerView
+import expo.modules.video.enums.ContentFit
+import expo.modules.video.utils.MutableWeakReference
+import java.lang.ref.WeakReference
+import kotlin.math.abs
+
+/**
+ * Workaround around the `onRenderedFirstFrame` and `SurfaceView` layout race condition bug.
+ * Ensures that the `onFirstFrame` event is sent after the `SurfaceView` is fully laid out.
+ * ExoPlayer sometimes emits `onRenderedFirstFrame` before the `SurfaceView` is laid out.
+ * If the frame is rendered before layout it becomes stretched to the size of the parent view.
+ * We want our event to be emitted only after we are sure that the frame is being displayed correctly.
+ * https://github.com/google/ExoPlayer/issues/5222
+ */
+@OptIn(UnstableApi::class)
+internal class FirstFrameEventGenerator(
+  player: ExoPlayer,
+  private val currentViewReference: MutableWeakReference<PlayerView?>,
+  private val onFirstFrameRendered: () -> Unit
+) : Player.Listener {
+  val playerReference = WeakReference(player)
+  private var hasPendingOnFirstFrame = false
+  private var hasSentFirstFrameForCurrentMediaItem = false
+
+  init {
+    player.addListener(this)
+  }
+
+  override fun onRenderedFirstFrame() {
+    if (isPlayerSurfaceLayoutValid()) {
+      maybeCallOnFirstFrameRendered()
+    } else {
+      hasPendingOnFirstFrame = true
+    }
+  }
+
+  override fun onMediaItemTransition(mediaItem: MediaItem?, reason: Int) {
+    hasSentFirstFrameForCurrentMediaItem = false
+    super.onMediaItemTransition(mediaItem, reason)
+  }
+
+  override fun onSurfaceSizeChanged(width: Int, height: Int) {
+    if (isPlayerSurfaceLayoutValid() && hasPendingOnFirstFrame) {
+      maybeCallOnFirstFrameRendered()
+    }
+  }
+
+  // Unlike iOS, android calls `onRenderedFirstFrame` multiple times for the same media item (after seeking).
+  // We want to match the behavior across platforms, so we limit the number of event emissions.
+  private fun maybeCallOnFirstFrameRendered() {
+    if (!hasSentFirstFrameForCurrentMediaItem) {
+      onFirstFrameRendered()
+    }
+    hasPendingOnFirstFrame = false
+    hasSentFirstFrameForCurrentMediaItem = true
+  }
+
+  private fun isPlayerSurfaceLayoutValid(): Boolean {
+    // Sometimes the video size announced by the track will is 1px off the render size.
+    val epsilon = 0.05
+    val player = playerReference.get() ?: run {
+      return false
+    }
+    val currentPlayerView = currentViewReference.get() ?: run {
+      return false
+    }
+    val surfaceWidth = player.surfaceSize.width
+    val surfaceHeight = player.surfaceSize.height
+    val sourceWidth = player.videoSize.width
+    val sourceHeight = player.videoSize.height
+    val sourcePixelWidthHeightRatio = player.videoSize.pixelWidthHeightRatio
+
+    if (surfaceWidth == 0 || surfaceHeight == 0) {
+      return false
+    }
+
+    val surfaceAspectRatio = surfaceWidth.toFloat() / surfaceHeight
+    val trackAspectRatio = sourceWidth.toFloat() / sourceHeight * sourcePixelWidthHeightRatio
+
+    val videoSizeIsUnknown = sourceWidth == 0 || sourceHeight == 0
+    val hasFillContentFit = currentPlayerView.resizeMode == ContentFit.FILL.toResizeMode()
+    val hasCorrectRatio = abs(trackAspectRatio - surfaceAspectRatio) < epsilon
+
+    return (hasCorrectRatio || hasFillContentFit || videoSizeIsUnknown)
+  }
+}

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

@@ -0,0 +1,164 @@
+package expo.modules.video.player
+
+import androidx.annotation.OptIn
+import androidx.media3.common.TrackSelectionParameters
+import androidx.media3.common.Tracks
+import androidx.media3.common.util.UnstableApi
+import expo.modules.video.enums.AudioMixingMode
+import expo.modules.video.enums.PlayerStatus
+import expo.modules.video.records.AudioTrack
+import expo.modules.video.records.AvailableSubtitleTracksChangedEventPayload
+import expo.modules.video.records.AvailableAudioTracksChangedEventPayload
+import expo.modules.video.records.IsPlayingEventPayload
+import expo.modules.video.records.MutedChangedEventPayload
+import expo.modules.video.records.PlaybackError
+import expo.modules.video.records.PlaybackRateChangedEventPayload
+import expo.modules.video.records.SourceChangedEventPayload
+import expo.modules.video.records.StatusChangedEventPayload
+import expo.modules.video.records.SubtitleTrack
+import expo.modules.video.records.SubtitleTrackChangedEventPayload
+import expo.modules.video.records.AudioTrackChangedEventPayload
+import expo.modules.video.records.TimeUpdate
+import expo.modules.video.records.VideoEventPayload
+import expo.modules.video.records.VideoSource
+import expo.modules.video.records.VideoSourceLoadedEventPayload
+import expo.modules.video.records.VideoTrack
+import expo.modules.video.records.VideoTrackChangedEventPayload
+import expo.modules.video.records.VolumeChangedEventPayload
+
+@OptIn(UnstableApi::class)
+sealed class PlayerEvent {
+  open val name: String = ""
+  open val jsEventPayload: VideoEventPayload? = null
+  open val emitToJS: Boolean = true
+
+  data class StatusChanged(val status: PlayerStatus, val oldStatus: PlayerStatus?, val error: PlaybackError?) : PlayerEvent() {
+    override val name = "statusChange"
+    override val jsEventPayload = StatusChangedEventPayload(status, oldStatus, error)
+  }
+
+  data class IsPlayingChanged(val isPlaying: Boolean, val oldIsPlaying: Boolean?) : PlayerEvent() {
+    override val name = "playingChange"
+    override val jsEventPayload = IsPlayingEventPayload(isPlaying, oldIsPlaying)
+  }
+
+  data class VolumeChanged(val volume: Float, val oldVolume: Float?) : PlayerEvent() {
+    override val name = "volumeChange"
+    override val jsEventPayload = VolumeChangedEventPayload(volume, oldVolume)
+  }
+
+  data class MutedChanged(val muted: Boolean, val oldMuted: Boolean?) : PlayerEvent() {
+    override val name = "mutedChange"
+    override val jsEventPayload = MutedChangedEventPayload(muted, oldMuted)
+  }
+
+  data class SourceChanged(val source: VideoSource?, val oldSource: VideoSource?) : PlayerEvent() {
+    override val name = "sourceChange"
+    override val jsEventPayload = SourceChangedEventPayload(source, oldSource)
+  }
+
+  data class PlaybackRateChanged(val rate: Float, val oldRate: Float?) : PlayerEvent() {
+    override val name = "playbackRateChange"
+    override val jsEventPayload = PlaybackRateChangedEventPayload(rate, oldRate)
+  }
+
+  data class TracksChanged(val tracks: Tracks) : PlayerEvent() {
+    override val name = "tracksChange"
+    override val emitToJS = false
+  }
+
+  data class TrackSelectionParametersChanged(val trackSelectionParameters: TrackSelectionParameters) : PlayerEvent() {
+    override val name = "trackSelectionParametersChange"
+    override val emitToJS = false
+  }
+
+  data class SubtitleTrackChanged(val subtitleTrack: SubtitleTrack?, val oldSubtitleTrack: SubtitleTrack?) : PlayerEvent() {
+    override val name = "subtitleTrackChange"
+    override val jsEventPayload = SubtitleTrackChangedEventPayload(subtitleTrack, oldSubtitleTrack)
+  }
+
+  data class AudioTrackChanged(val audioTrack: AudioTrack?, val oldAudioTrack: AudioTrack?) : PlayerEvent() {
+    override val name = "audioTrackChange"
+    override val jsEventPayload = AudioTrackChangedEventPayload(audioTrack, oldAudioTrack)
+  }
+
+  data class VideoTrackChanged(val videoTrack: VideoTrack?, val oldVideoTrack: VideoTrack?) : PlayerEvent() {
+    override val name = "videoTrackChange"
+    override val jsEventPayload = VideoTrackChangedEventPayload(videoTrack, oldVideoTrack)
+  }
+
+  class RenderedFirstFrame : PlayerEvent() {
+    override val name = "renderFirstFrame"
+
+    // This Event is emitted through the view (we are matching the AVKit API behavior)
+    override val emitToJS = false
+  }
+
+  data class AvailableSubtitleTracksChanged(
+    val availableSubtitleTracks: List<SubtitleTrack>,
+    val oldAvailableSubtitleTracks: List<SubtitleTrack>
+  ) : PlayerEvent() {
+    override val name = "availableSubtitleTracksChange"
+    override val jsEventPayload = AvailableSubtitleTracksChangedEventPayload(availableSubtitleTracks, oldAvailableSubtitleTracks)
+  }
+
+  data class AvailableAudioTracksChanged(
+    val availableAudioTracks: List<AudioTrack>,
+    val oldAvailableAudioTracks: List<AudioTrack>
+  ) : PlayerEvent() {
+    override val name = "availableAudioTracksChange"
+    override val jsEventPayload = AvailableAudioTracksChangedEventPayload(availableAudioTracks, oldAvailableAudioTracks)
+  }
+
+  data class VideoSourceLoaded(
+    val videoSource: VideoSource?,
+    val duration: Double,
+    val availableVideoTracks: List<VideoTrack>,
+    val availableSubtitleTracks: List<SubtitleTrack>,
+    val availableAudioTracks: List<AudioTrack>
+  ) : PlayerEvent() {
+    override val name = "sourceLoad"
+    override val jsEventPayload = VideoSourceLoadedEventPayload(
+      videoSource,
+      duration,
+      availableVideoTracks,
+      availableSubtitleTracks,
+      availableAudioTracks
+    )
+  }
+
+  data class TimeUpdated(val timeUpdate: TimeUpdate) : PlayerEvent() {
+    override val name = "timeUpdate"
+    override val jsEventPayload = timeUpdate
+  }
+
+  data class AudioMixingModeChanged(val audioMixingMode: AudioMixingMode, val oldAudioMixingMode: AudioMixingMode?) : PlayerEvent() {
+    override val name = "audioMixingModeChange"
+    override val emitToJS = false
+  }
+
+  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, volume, oldVolume) }
+      is SourceChanged -> listeners.forEach { it.onSourceChanged(player, source, oldSource) }
+      is PlaybackRateChanged -> listeners.forEach { it.onPlaybackRateChanged(player, rate, oldRate) }
+      is TracksChanged -> listeners.forEach { it.onTracksChanged(player, tracks) }
+      is TrackSelectionParametersChanged -> listeners.forEach { it.onTrackSelectionParametersChanged(player, trackSelectionParameters) }
+      is TimeUpdated -> listeners.forEach { it.onTimeUpdate(player, timeUpdate) }
+      is PlayedToEnd -> listeners.forEach { it.onPlayedToEnd(player) }
+      is MutedChanged -> listeners.forEach { it.onMutedChanged(player, muted, oldMuted) }
+      is AudioMixingModeChanged -> listeners.forEach { it.onAudioMixingModeChanged(player, audioMixingMode, oldAudioMixingMode) }
+      is VideoTrackChanged -> listeners.forEach { it.onVideoTrackChanged(player, videoTrack, oldVideoTrack) }
+      is RenderedFirstFrame -> listeners.forEach { it.onRenderedFirstFrame(player) }
+      is VideoSourceLoaded -> listeners.forEach { it.onVideoSourceLoaded(player, videoSource, duration, availableVideoTracks, availableSubtitleTracks, availableAudioTracks) }
+      // JS-only events - SubtitleTrackChanged - In the native events the TracksChanged can be used instead
+      else -> Unit
+    }
+  }
+}