@stepincto/expo-video 1.0.0

package/ios/VideoPlayer.swift

@@ -0,0 +1,435 @@
+// Copyright 2023-present 650 Industries. All rights reserved.
+
+import AVFoundation
+import MediaPlayer
+import ExpoModulesCore
+
+internal final class VideoPlayer: SharedRef<AVPlayer>, Hashable, VideoPlayerObserverDelegate {
+  let videoSourceLoader = VideoSourceLoader()
+  lazy var contentKeyManager = ContentKeyManager()
+  var observer: VideoPlayerObserver?
+  lazy var subtitles: VideoPlayerSubtitles = VideoPlayerSubtitles(owner: self)
+  private var dangerousPropertiesStore = DangerousPropertiesStore()
+  lazy var audioTracks: VideoPlayerAudioTracks = VideoPlayerAudioTracks(owner: self)
+
+  var loop = false
+  var audioMixingMode: AudioMixingMode = .doNotMix {
+    didSet {
+      if oldValue != audioMixingMode {
+        VideoManager.shared.setAppropriateAudioSessionOrWarn()
+      }
+    }
+  }
+  private(set) var isPlaying = false
+  private(set) var status: PlayerStatus = .idle
+
+  var playbackRate: Float = 1.0 {
+    didSet {
+      if oldValue != playbackRate {
+        let payload = PlaybackRateChangedEventPayload(playbackRate: playbackRate, oldPlaybackRate: oldValue)
+        safeEmit(event: "playbackRateChange", payload: payload)
+      }
+      if #available(iOS 16.0, tvOS 16.0, *) {
+        ref.defaultRate = playbackRate
+      }
+      ref.rate = playbackRate
+    }
+  }
+
+  var currentTime: Double {
+    get {
+      let currentTime = ref.currentTime().seconds
+      return currentTime.isNaN ? 0 : currentTime
+    }
+    set {
+      // Only clamp the lower limit, AVPlayer automatically clamps the upper limit.
+      let clampedTime = max(0, newValue)
+      let timeToSeek = CMTimeMakeWithSeconds(clampedTime, preferredTimescale: .max)
+
+      // AVPlayer can't apply the currentTime while the resource is loading. We will re-apply it after loading
+      if dangerousPropertiesStore.ownerIsReplacing {
+        dangerousPropertiesStore.currentTime = clampedTime
+        return
+      }
+
+      ref.seek(to: timeToSeek)
+    }
+  }
+
+  var staysActiveInBackground = false {
+    didSet {
+      if staysActiveInBackground {
+        VideoManager.shared.setAppropriateAudioSessionOrWarn()
+      }
+    }
+  }
+
+  var preservesPitch = true {
+    didSet {
+      ref.currentItem?.audioTimePitchAlgorithm = preservesPitch ? .spectral : .varispeed
+    }
+  }
+
+  var volume: Float = 1.0 {
+    didSet {
+      if oldValue != volume {
+        let payload = VolumeChangedEventPayload(volume: volume, oldVolume: oldValue)
+        safeEmit(event: "volumeChange", payload: payload)
+      }
+      ref.volume = volume
+    }
+  }
+
+  var isMuted: Bool = false {
+    didSet {
+      if oldValue != isMuted {
+        let payload = MutedChangedEventPayload(muted: isMuted, oldMuted: oldValue)
+        safeEmit(event: "mutedChange", payload: payload)
+      }
+      ref.isMuted = isMuted
+      VideoManager.shared.setAppropriateAudioSessionOrWarn()
+    }
+  }
+
+  var showNowPlayingNotification = false {
+    didSet {
+      // The audio session needs to be appropriate before displaying the notfication
+      VideoManager.shared.setAppropriateAudioSessionOrWarn()
+
+      if showNowPlayingNotification {
+        NowPlayingManager.shared.registerPlayer(self)
+      } else {
+        NowPlayingManager.shared.unregisterPlayer(self)
+      }
+    }
+  }
+
+  // TODO: @behenate - Once the Player instance is available in OnStartObserving we can automatically start/stop the interval.
+  var timeUpdateEventInterval: Double = 0 {
+    didSet {
+      if timeUpdateEventInterval <= 0 {
+        observer?.stopTimeUpdates()
+        return
+      }
+      observer?.startOrUpdateTimeUpdates(forInterval: timeUpdateEventInterval)
+    }
+  }
+
+  var currentLiveTimestamp: Double? {
+    guard let currentDate = ref.currentItem?.currentDate() else {
+      return nil
+    }
+    let timeIntervalSince = currentDate.timeIntervalSince1970
+    return Double(timeIntervalSince * 1000)
+  }
+
+  var currentOffsetFromLive: Double? {
+    guard let currentDate = ref.currentItem?.currentDate() else {
+      return nil
+    }
+    let timeIntervalSince = currentDate.timeIntervalSince1970
+    let unixTime = Date().timeIntervalSince1970
+    return unixTime - timeIntervalSince
+  }
+
+  var bufferOptions = BufferOptions() {
+    didSet {
+      ref.currentItem?.preferredForwardBufferDuration = bufferOptions.preferredForwardBufferDuration
+      ref.automaticallyWaitsToMinimizeStalling = bufferOptions.waitsToMinimizeStalling
+    }
+  }
+
+  var bufferedPosition: Double {
+    return getBufferedPosition()
+  }
+
+  private(set) var availableVideoTracks: [VideoTrack] = []
+  private(set) var currentVideoTrack: VideoTrack? {
+    didSet {
+      let payload = VideoTrackChangedEventPayload(videoTrack: currentVideoTrack, oldVideoTrack: oldValue)
+      safeEmit(event: "videoTrackChange", payload: payload)
+    }
+  }
+
+  convenience init(_ ref: AVPlayer, initialSource: VideoSource?, useSynchronousReplace: Bool = false) throws {
+    self.init(ref)
+
+    // While the replace task below is being created, the properties from the JS constructor will start getting applied
+    // Therefore we have to set the state as `loading` before the task is created to ensure that we don't lose any dangerous properties
+    dangerousPropertiesStore.ownerIsReplacing = initialSource != nil
+
+    if useSynchronousReplace {
+      try replaceCurrentItem(with: initialSource)
+    } else {
+      Task {
+        try await replaceCurrentItem(with: initialSource)
+      }
+    }
+  }
+
+  private override init(_ ref: AVPlayer) {
+    super.init(ref)
+    observer = VideoPlayerObserver(owner: self, videoSourceLoader: videoSourceLoader)
+    observer?.registerDelegate(delegate: self)
+    VideoManager.shared.register(videoPlayer: self)
+
+    // Disable automatic subtitle selection
+    let selectionCriteria = AVPlayerMediaSelectionCriteria(preferredLanguages: [], preferredMediaCharacteristics: [.legible])
+    ref.setMediaSelectionCriteria(selectionCriteria, forMediaCharacteristic: .legible)
+  }
+
+  deinit {
+    observer?.cleanup()
+    NowPlayingManager.shared.unregisterPlayer(self)
+    VideoManager.shared.unregister(videoPlayer: self)
+
+    videoSourceLoader.cancelCurrentTask()
+
+    // We have to replace from the main thread because of KVOs (see comment in VideoSourceLoader).
+    // Moreover, in this case we have to keep a strong reference to AVPlayer and remove its item
+    // If we don't do this AVPlayer doesn't get deallocated
+    DispatchQueue.main.async { [ref] in
+      ref.replaceCurrentItem(with: nil)
+    }
+  }
+
+  func replaceCurrentItem(with videoSource: VideoSource?) throws {
+    dangerousPropertiesStore.ownerIsReplacing = true
+    videoSourceLoader.cancelCurrentTask()
+    guard
+      let videoSource = videoSource,
+      let playerItem = VideoPlayerItem(videoSource: videoSource)
+    else {
+      clearCurrentItem()
+      return
+    }
+
+    if let drm = videoSource.drm {
+      try drm.type.assertIsSupported()
+      contentKeyManager.addContentKeyRequest(videoSource: videoSource, asset: playerItem.urlAsset)
+    }
+
+    playerItem.audioTimePitchAlgorithm = preservesPitch ? .spectral : .varispeed
+    playerItem.preferredForwardBufferDuration = bufferOptions.preferredForwardBufferDuration
+
+    // The current item has to be replaced from the main thread. When replacing from other queues
+    // sometimes the KVOs will try to deliver updates after the item has been changed or player deallocated,
+    // which causes crashes.
+    DispatchQueue.main.async { [weak self] in
+      guard let self else {
+        return
+      }
+      self.ref.replaceCurrentItem(with: playerItem)
+      self.dangerousPropertiesStore.ownerIsReplacing = false
+      self.dangerousPropertiesStore.applyProperties(to: self)
+    }
+  }
+
+  /**
+   * Replaces the current item, while loading the AVAsset on a different thread. The synchronous version can lock the main thread for extended periods of time.
+   */
+  func replaceCurrentItem(with videoSource: VideoSource?) async throws {
+    guard let videoSource, videoSource.uri != nil else {
+      clearCurrentItem()
+      return
+    }
+
+    dangerousPropertiesStore.ownerIsReplacing = true
+    guard let playerItem = try await videoSourceLoader.load(videoSource: videoSource) else {
+      // Resolve the promise without applying the source. The loading task has been cancelled.
+      // The caller that cancelled this task should handle dangerousPropertiesStore
+      return
+    }
+
+    if let drm = videoSource.drm {
+      try drm.type.assertIsSupported()
+      self.contentKeyManager.addContentKeyRequest(videoSource: videoSource, asset: playerItem.urlAsset)
+    }
+
+    playerItem.audioTimePitchAlgorithm = self.preservesPitch ? .spectral : .varispeed
+    playerItem.preferredForwardBufferDuration = self.bufferOptions.preferredForwardBufferDuration
+
+    // The current item has to be replaced from the main thread. When replacing from other queues
+    // sometimes the KVOs will try to deliver updates after the item has been changed or player deallocated,
+    // which causes crashes.
+    DispatchQueue.main.async { [weak self] in
+      guard let self else {
+        return
+      }
+      self.ref.replaceCurrentItem(with: playerItem)
+      dangerousPropertiesStore.ownerIsReplacing = false
+      dangerousPropertiesStore.applyProperties(to: self)
+    }
+  }
+
+  private func clearCurrentItem() {
+    DispatchQueue.main.async { [ref, videoSourceLoader, dangerousPropertiesStore] in
+      ref.replaceCurrentItem(with: nil)
+      videoSourceLoader.cancelCurrentTask()
+      dangerousPropertiesStore.reset()
+      dangerousPropertiesStore.ownerIsReplacing = false
+    }
+    return
+  }
+
+  /**
+   * iOS automatically pauses videos when the app enters the background. Only way to avoid this is to detach the player from the playerLayer.
+   * Typical way of doing this for `AVPlayerViewController` is setting `playerViewController.player = nil`, but that makes the
+   * video invisible for around a second after foregrounding, disabling the tracks requires more code, but works a lot faster.
+   */
+  func setTracksEnabled(_ enabled: Bool) {
+    ref.currentItem?.tracks.forEach({ track in
+      guard let assetTrack = track.assetTrack else {
+        return
+      }
+
+      if assetTrack.hasMediaCharacteristic(AVMediaCharacteristic.visual) {
+        track.isEnabled = enabled
+      }
+    })
+  }
+
+  private func getBufferedPosition() -> Double {
+    guard let currentItem = ref.currentItem else {
+      return -1
+    }
+    let currentTime = ref.currentTime().seconds
+
+    for timeRange in currentItem.loadedTimeRanges {
+      let start = CMTimeGetSeconds(timeRange.timeRangeValue.start)
+      let end = CMTimeGetSeconds(timeRange.timeRangeValue.end)
+      if start <= currentTime && end >= currentTime {
+        return end
+      }
+    }
+    return 0
+  }
+
+  // MARK: - VideoPlayerObserverDelegate
+
+  func onStatusChanged(player: AVPlayer, oldStatus: PlayerStatus?, newStatus: PlayerStatus, error: Exception?) {
+    let errorRecord = error != nil ? PlaybackError(message: error?.description) : nil
+    let payload = StatusChangedEventPayload(status: newStatus, oldStatus: oldStatus, error: errorRecord)
+    safeEmit(event: "statusChange", payload: payload)
+    status = newStatus
+  }
+
+  func onIsPlayingChanged(player: AVPlayer, oldIsPlaying: Bool?, newIsPlaying: Bool) {
+    let payload = IsPlayingEventPayload(isPlaying: newIsPlaying, oldIsPlaying: oldIsPlaying)
+    safeEmit(event: "playingChange", payload: payload)
+    isPlaying = newIsPlaying
+
+    VideoManager.shared.setAppropriateAudioSessionOrWarn()
+  }
+
+  func onRateChanged(player: AVPlayer, oldRate: Float?, newRate: Float) {
+    if #available(iOS 16.0, tvOS 16.0, *) {
+      if player.defaultRate != playbackRate {
+        // User changed the playback speed in the native controls. Update the desiredRate variable
+        playbackRate = player.defaultRate
+      }
+    } else if newRate != 0 && newRate != playbackRate {
+      // On iOS < 16 play() method always returns the rate to 1.0, we have to keep resetting it back to desiredRate
+      // iOS < 16 uses an older player UI, so we don't have to worry about changes to the rate that come from the player UI
+      ref.rate = playbackRate
+    }
+  }
+
+  func onVolumeChanged(player: AVPlayer, oldVolume: Float?, newVolume: Float) {
+    volume = newVolume
+  }
+
+  func onIsMutedChanged(player: AVPlayer, oldIsMuted: Bool?, newIsMuted: Bool) {
+    isMuted = newIsMuted
+  }
+
+  func onPlayedToEnd(player: AVPlayer) {
+    safeEmit(event: "playToEnd")
+    if loop {
+      self.ref.seek(to: .zero)
+      self.ref.play()
+    }
+  }
+
+  func onItemChanged(player: AVPlayer, oldVideoPlayerItem: VideoPlayerItem?, newVideoPlayerItem: VideoPlayerItem?) {
+    let payload = SourceChangedEventPayload(
+      source: newVideoPlayerItem?.videoSource,
+      oldSource: oldVideoPlayerItem?.videoSource
+    )
+    safeEmit(event: "sourceChange", payload: payload)
+    newVideoPlayerItem?.preferredForwardBufferDuration = bufferOptions.preferredForwardBufferDuration
+  }
+
+  func onTimeUpdate(player: AVPlayer, timeUpdate: TimeUpdate) {
+    safeEmit(event: "timeUpdate", payload: timeUpdate)
+  }
+
+  func onLoadedPlayerItem(player: AVPlayer, playerItem: AVPlayerItem?) {
+    // This event means that a new player item has been loaded so the subtitle tracks should change
+    let oldTracks = subtitles.availableSubtitleTracks
+    self.subtitles.onNewPlayerItemLoaded(playerItem: playerItem)
+    let payload = SubtitleTracksChangedEventPayload(
+      availableSubtitleTracks: subtitles.availableSubtitleTracks,
+      oldAvailableSubtitleTracks: oldTracks
+    )
+    safeEmit(event: "availableSubtitleTracksChange", payload: payload)
+
+    // Handle audio tracks
+    let oldAudioTracks = audioTracks.availableAudioTracks
+    self.audioTracks.onNewPlayerItemLoaded(playerItem: playerItem)
+    let audioPayload = AudioTracksChangedEventPayload(
+      availableAudioTracks: audioTracks.availableAudioTracks,
+      oldAvailableAudioTracks: oldAudioTracks
+    )
+    safeEmit(event: "availableAudioTracksChange", payload: audioPayload)
+
+    Task {
+      let videoPlayerItem: VideoPlayerItem? = playerItem as? VideoPlayerItem
+      // Those properties will be already loaded 99.9% of time, so the event delay should be almost 0
+      availableVideoTracks = await videoPlayerItem?.videoTracks ?? []
+
+      let videoSourceLoadedPayload = VideoSourceLoadedEventPayload(
+        videoSource: videoPlayerItem?.videoSource,
+        duration: playerItem?.duration.seconds,
+        availableVideoTracks: availableVideoTracks,
+        availableSubtitleTracks: subtitles.availableSubtitleTracks,
+        availableAudioTracks: audioTracks.availableAudioTracks
+      )
+      safeEmit(event: "sourceLoad", payload: videoSourceLoadedPayload)
+    }
+  }
+
+  func onSubtitleSelectionChanged(player: AVPlayer, playerItem: AVPlayerItem?, subtitleTrack: SubtitleTrack?) {
+    let oldTrack = subtitles.currentSubtitleTrack
+    subtitles.onNewSubtitleTrackSelected(subtitleTrack: subtitleTrack)
+    let payload = SubtitleTrackChangedEventPayload(subtitleTrack: subtitles.currentSubtitleTrack, oldSubtitleTrack: oldTrack)
+    safeEmit(event: "subtitleTrackChange", payload: payload)
+  }
+
+  func onAudioTrackSelectionChanged(player: AVPlayer, playerItem: AVPlayerItem?, audioTrack: AudioTrack?) {
+    let oldTrack = audioTracks.currentAudioTrack
+    audioTracks.onNewAudioTrackSelected(audioTrack: audioTrack)
+    let payload = AudioTrackChangedEventPayload(audioTrack: audioTracks.currentAudioTrack, oldAudioTrack: oldTrack)
+    safeEmit(event: "audioTrackChange", payload: payload)
+  }
+
+  func onVideoTrackChanged(player: AVPlayer, oldVideoTrack: VideoTrack?, newVideoTrack: VideoTrack?) {
+    currentVideoTrack = newVideoTrack
+  }
+
+  func safeEmit(event: String, payload: Record? = nil) {
+    if self.appContext != nil {
+      self.emit(event: event, arguments: payload?.toDictionary(appContext: appContext))
+    }
+  }
+
+  // MARK: - Hashable
+
+  func hash(into hasher: inout Hasher) {
+    hasher.combine(ObjectIdentifier(self))
+  }
+
+  static func == (lhs: VideoPlayer, rhs: VideoPlayer) -> Bool {
+    return ObjectIdentifier(lhs) == ObjectIdentifier(rhs)
+  }
+}

package/ios/VideoPlayerAudioTracks.swift

@@ -0,0 +1,72 @@
+import Foundation
+import AVFoundation
+
+class VideoPlayerAudioTracks {
+  weak var owner: VideoPlayer?
+  private(set) var availableAudioTracks: [AudioTrack] = []
+  private(set) var currentAudioTrack: AudioTrack?
+
+  init (owner: VideoPlayer) {
+    self.owner = owner
+  }
+
+  func onNewAudioTrackSelected(audioTrack: AudioTrack?) {
+    currentAudioTrack = audioTrack
+  }
+
+  func onNewPlayerItemLoaded(playerItem: AVPlayerItem?) {
+    availableAudioTracks = Self.findAvailableAudioTracks(for: playerItem)
+  }
+
+  func selectAudioTrack(audioTrack: AudioTrack?) {
+    guard let currentItem = self.owner?.ref.currentItem else {
+      return
+    }
+
+    if let group = currentItem.asset.mediaSelectionGroup(forMediaCharacteristic: .audible) {
+      let option = group.options.first {
+        $0.displayName == audioTrack?.label && $0.locale?.identifier == audioTrack?.language
+      }
+      currentItem.select(option, in: group)
+    }
+  }
+
+  static func findAvailableAudioTracks(for playerItem: AVPlayerItem?) -> [AudioTrack] {
+    var availableAudioTracks: [AudioTrack] = []
+
+    guard let asset = playerItem?.asset else {
+      return availableAudioTracks
+    }
+
+    let mediaSelectionCharacteristics = asset.availableMediaCharacteristicsWithMediaSelectionOptions
+
+    for characteristic in mediaSelectionCharacteristics {
+      guard characteristic == .audible else {
+        continue
+      }
+
+      if let group = asset.mediaSelectionGroup(forMediaCharacteristic: characteristic) {
+        for option in group.options {
+          guard let audioTrack = AudioTrack.from(mediaSelectionOption: option) else {
+            continue
+          }
+
+          availableAudioTracks.append(audioTrack)
+        }
+      }
+    }
+    return availableAudioTracks
+  }
+
+  static func findCurrentAudioTrack(for playerItem: AVPlayerItem?) -> AudioTrack? {
+    guard
+      let currentItem = playerItem,
+      let mediaSelectionGroup = currentItem.asset.mediaSelectionGroup(forMediaCharacteristic: .audible),
+      let selectedMediaOption = currentItem.currentMediaSelection.selectedMediaOption(in: mediaSelectionGroup)
+    else {
+      return nil
+    }
+
+    return AudioTrack.from(mediaSelectionOption: selectedMediaOption)
+  }
+}

package/ios/VideoPlayerItem.swift

@@ -0,0 +1,97 @@
+// Copyright 2024-present 650 Industries. All rights reserved.
+
+import ExpoModulesCore
+import AVKit
+
+class VideoPlayerItem: AVPlayerItem {
+  let urlAsset: VideoAsset
+  let videoSource: VideoSource
+  let isHls: Bool
+  var videoTracks: [VideoTrack] {
+    get async {
+      return await tracksLoadingTask?.value ?? []
+    }
+  }
+
+  private var tracksLoadingTask: Task<[VideoTrack], Never>?
+
+  init?(videoSource: VideoSource) {
+    guard let url = videoSource.uri else {
+      return nil
+    }
+    self.videoSource = videoSource
+    self.isHls = videoSource.uri?.pathExtension == "m3u8" || videoSource.contentType == .hls
+
+    let asset = VideoAsset(url: url, videoSource: videoSource)
+    self.urlAsset = asset
+    super.init(asset: urlAsset, automaticallyLoadedAssetKeys: nil)
+    self.createTracksLoadingTask()
+  }
+
+  init?(videoSource: VideoSource) async throws {
+    guard let url = videoSource.uri else {
+      return nil
+    }
+    self.videoSource = videoSource
+    self.isHls = videoSource.uri?.pathExtension == "m3u8" || videoSource.contentType == .hls
+
+    let asset = VideoAsset(url: url, videoSource: videoSource)
+    self.urlAsset = asset
+    // We can ignore any exceptions thrown during the load. The asset will be assigned to the `VideoPlayer` anyways
+    // and cause it to go into .error state trigerring the `onStatusChange` event.
+    _ = try? await asset.load(.duration, .preferredTransform, .isPlayable)
+
+    super.init(asset: urlAsset, automaticallyLoadedAssetKeys: nil)
+    self.createTracksLoadingTask()
+  }
+
+  func createTracksLoadingTask() {
+    tracksLoadingTask = Task { [weak self] in
+      var tracks: [VideoTrack] = []
+      guard let self else {
+        return []
+      }
+
+      if isHls {
+        do {
+          tracks = try await self.fetchHlsVideoTracks()
+        } catch {
+          tracks = []
+          log.warn("Failed to fetch HLS video tracks, this is not required for playback, but `expo-video` will have no knowledge of the available tracks: \(error.localizedDescription)")
+        }
+      } else {
+        let avAssetTracks = asset.tracks(withMediaType: .video)
+        for avAssetTrack in avAssetTracks {
+          tracks.append(await VideoTrack.from(assetTrack: avAssetTrack))
+        }
+      }
+      return tracks
+    }
+  }
+
+  // AVKit API doesn't provide us with a list of available tracks for a HLS source. We can download the playlist file and parse it ourselves
+  // it's usually very small (1-2 kB), so we won't add too much overhead
+  private func fetchHlsVideoTracks() async throws -> [VideoTrack] {
+    guard let uri = videoSource.uri else {
+      throw URLError(.badURL)
+    }
+
+    var request = URLRequest(url: uri)
+    if let headers = videoSource.headers {
+      for (key, value) in headers {
+        request.addValue(value, forHTTPHeaderField: key)
+      }
+    }
+
+    let (data, _) = try await URLSession.shared.data(for: request)
+    let content = String(data: data, encoding: .utf8) ?? ""
+    return parseM3U8(content)
+  }
+
+  private func parseM3U8(_ content: String) -> [VideoTrack] {
+    let lines = content.components(separatedBy: "\n")
+    return zip(lines, lines.dropFirst()).compactMap { line, nextLine in
+      VideoTrack.from(hlsHeaderLine: line, idLine: nextLine)
+    }
+  }
+}