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

package/ios/core/VideoPlayerObserver.swift

@@ -0,0 +1,294 @@
+//
+//  VideoPlayerObserver.swift
+//  ReactNativeVideo
+//
+//  Created by Krzysztof Moch on 15/04/2025.
+//
+
+import Foundation
+import AVFoundation
+
+protocol VideoPlayerObserverDelegate: AnyObject {
+  func onPlayedToEnd(player: AVPlayer)
+  func onPlayerItemChange(player: AVPlayer, playerItem: AVPlayerItem?)
+  func onPlayerItemWillChange(hasNewPlayerItem: Bool)
+  func onTextTrackDataChanged(texts: [NSAttributedString])
+  func onTimedMetadataChanged(timedMetadata: [AVMetadataItem])
+  func onRateChanged(rate: Float)
+  func onPlaybackBufferEmpty()
+  func onPlaybackLikelyToKeepUp()
+  func onVolumeChanged(volume: Float)
+  func onExternalPlaybackActiveChanged(isActive: Bool)
+  func onTimeControlStatusChanged(status: AVPlayer.TimeControlStatus)
+  func onPlayerStatusChanged(status: AVPlayer.Status)
+  func onPlayerItemStatusChanged(status: AVPlayerItem.Status)
+  func onBandwidthUpdate(bitrate: Double)
+  func onProgressUpdate(currentTime: Double, bufferDuration: Double)
+}
+
+extension VideoPlayerObserverDelegate {
+  func onPlayedToEnd(player: AVPlayer) {}
+  func onPlayerItemChange(player: AVPlayer, playerItem: AVPlayerItem?) {}
+  func onPlayerItemWillChange(hasNewPlayerItem: Bool) {}
+  func onTextTrackDataChanged(texts: [NSAttributedString]) {}
+  func onTimedMetadataChanged(timedMetadata: [AVMetadataItem]) {}
+  func onRateChanged(rate: Float) {}
+  func onPlaybackBufferEmpty() {}
+  func onPlaybackLikelyToKeepUp() {}
+  func onVolumeChanged(volume: Float) {}
+  func onExternalPlaybackActiveChanged(isActive: Bool) {}
+  func onTimeControlStatusChanged(status: AVPlayer.TimeControlStatus) {}
+  func onPlayerStatusChanged(status: AVPlayer.Status) {}
+  func onPlayerItemStatusChanged(status: AVPlayerItem.Status) {}
+  func onBandwidthUpdate(bitrate: Double) {}
+  func onProgressUpdate(currentTime: Double, bufferDuration: Double) {}
+}
+
+class VideoPlayerObserver: NSObject, AVPlayerItemMetadataOutputPushDelegate, AVPlayerItemLegibleOutputPushDelegate {
+  private weak var delegate: HybridVideoPlayer?
+  var player: AVPlayer? {
+    delegate?.player
+  }
+  
+  // Player observers
+  var playerCurrentItemObserver: NSKeyValueObservation?
+  var playerRateObserver: NSKeyValueObservation?
+  var playerTimeControlStatusObserver: NSKeyValueObservation?
+  var playerExternalPlaybackActiveObserver: NSKeyValueObservation?
+  var playerVolumeObserver: NSKeyValueObservation?
+  var playerTimedMetadataObserver: NSKeyValueObservation?
+  var playerStatusObserver: NSKeyValueObservation?
+  var playerProgressPeriodicObserver: Any?
+  
+  // Player item observers
+  var playbackEndedObserver: NSObjectProtocol?
+  var playbackBufferEmptyObserver: NSKeyValueObservation?
+  var playbackLikelyToKeepUpObserver: NSKeyValueObservation?
+  var playbackBufferFullObserver: NSKeyValueObservation?
+  var playerItemStatusObserver: NSKeyValueObservation?
+  var playerItemAccessLogObserver: NSObjectProtocol?
+  
+  var metadataOutput: AVPlayerItemMetadataOutput?
+  var legibleOutput: AVPlayerItemLegibleOutput?
+  
+  init(delegate: HybridVideoPlayer) {
+    self.delegate = delegate
+  }
+  
+  deinit {
+    invalidatePlayerObservers()
+    invalidatePlayerItemObservers()
+  }
+  
+  public func updatePlayerObservers() {
+    invalidatePlayerItemObservers()
+    invalidatePlayerObservers()
+    
+    initializePlayerObservers()
+  }
+  
+  func initializePlayerObservers() {
+    guard let player else {
+      return
+    }
+    
+    playerCurrentItemObserver = player.observe(\.currentItem, options: [.new, .old]) { [weak self] _, change in
+      self?.onPlayerCurrentItemChanged(player: player, change: change)
+    }
+    
+    playerRateObserver = player.observe(\.rate, options: [.new]) { [weak self] _, change in
+      guard let rate = change.newValue else { return }
+      self?.delegate?.onRateChanged(rate: rate)
+    }
+    
+    playerTimeControlStatusObserver = player.observe(\.timeControlStatus, options: [.new]) { [weak self] _, change in
+      guard let status = change.newValue else { return }
+      self?.delegate?.onTimeControlStatusChanged(status: status)
+    }
+    
+    playerExternalPlaybackActiveObserver = player.observe(\.isExternalPlaybackActive, options: [.new]) { [weak self] _, change in
+      guard let isActive = change.newValue else { return }
+      self?.delegate?.onExternalPlaybackActiveChanged(isActive: isActive)
+    }
+    
+    playerVolumeObserver = player.observe(\.volume, options: [.new]) { [weak self] _, change in
+      guard let volume = change.newValue else { return }
+      self?.delegate?.onVolumeChanged(volume: volume)
+    }
+    
+    playerStatusObserver = player.observe(\.status, options: [.new]) { [weak self] _, change in
+      guard let status = change.newValue else { return }
+      self?.delegate?.onPlayerStatusChanged(status: status)
+    }
+    
+    // 500ms interval TODO: Make this configurable
+    let interval = CMTime(seconds: 0.5, preferredTimescale: 600)
+    playerProgressPeriodicObserver = player.addPeriodicTimeObserver(forInterval: interval, queue: .main) { [weak self] _ in
+      guard let self, let player = self.player, let delegate = self.delegate else { return }
+      
+      delegate.onProgressUpdate(currentTime: player.currentTime().seconds, bufferDuration: player.currentItem?.getbufferDuration() ?? 0)
+    }
+  }
+  
+  private func initializePlayerItemObservers(player: AVPlayer, playerItem: AVPlayerItem) {
+    playbackEndedObserver = NotificationCenter.default.addObserver(
+      forName: .AVPlayerItemDidPlayToEndTime,
+      object: playerItem,
+      queue: nil
+    ) { [weak self] notification in
+      self?.delegate?.onPlayedToEnd(player: player)
+    }
+    
+    playerItemAccessLogObserver = NotificationCenter.default.addObserver(
+      forName: .AVPlayerItemNewAccessLogEntry,
+      object: playerItem,
+      queue: nil
+    ) { [weak self] notification in
+      self?.onPlayerAccessLog(playerItem: playerItem)
+    }
+    
+    setupBufferObservers(for: playerItem)
+    
+    playerItemStatusObserver = playerItem.observe(\.status, options: [.new]) { [weak self] _, change in
+      self?.delegate?.onPlayerItemStatusChanged(status: playerItem.status)
+    }
+    
+    let metadataOutput = AVPlayerItemMetadataOutput()
+    playerItem.add(metadataOutput)
+    metadataOutput.setDelegate(self, queue: .global(qos: .userInteractive))
+    
+    let legibleOutput = AVPlayerItemLegibleOutput()
+    playerItem.add(legibleOutput)
+    metadataOutput.setDelegate(self, queue: .global(qos: .userInteractive))
+  }
+  
+  private func invalidatePlayerItemObservers() {
+    // Remove NotificationCenter observers
+    if let playbackEndedObserver = playbackEndedObserver {
+      NotificationCenter.default.removeObserver(playbackEndedObserver)
+      self.playbackEndedObserver = nil
+    }
+    if let playerItemAccessLogObserver = playerItemAccessLogObserver {
+      NotificationCenter.default.removeObserver(playerItemAccessLogObserver)
+      self.playerItemAccessLogObserver = nil
+    }
+    // Invalidate KVO observers
+    clearBufferObservers()
+    playerItemStatusObserver?.invalidate()
+    playerItemStatusObserver = nil
+    // Remove outputs if needed
+    // (Assumes outputs are not shared between items)
+    if let playerItem = player?.currentItem {
+      if let metadataOutput = metadataOutput {
+        playerItem.remove(metadataOutput)
+      }
+      if let legibleOutput = legibleOutput {
+        playerItem.remove(legibleOutput)
+      }
+    }
+    metadataOutput = nil
+    legibleOutput = nil
+  }
+  
+  func invalidatePlayerObservers() {
+    // Invalidate KVO observers
+    playerCurrentItemObserver?.invalidate()
+    playerCurrentItemObserver = nil
+    playerRateObserver?.invalidate()
+    playerRateObserver = nil
+    playerTimeControlStatusObserver?.invalidate()
+    playerTimeControlStatusObserver = nil
+    playerExternalPlaybackActiveObserver?.invalidate()
+    playerExternalPlaybackActiveObserver = nil
+    playerVolumeObserver?.invalidate()
+    playerVolumeObserver = nil
+    playerStatusObserver?.invalidate()
+    playerStatusObserver = nil
+    // Remove periodic time observer from player
+    if let player = player, let periodicObserver = playerProgressPeriodicObserver {
+      player.removeTimeObserver(periodicObserver)
+      playerProgressPeriodicObserver = nil
+    }
+  }
+  
+  // MARK: - AVPlayerItemLegibleOutputPushDelegate
+  public func legibleOutput(_: AVPlayerItemLegibleOutput,
+                     didOutputAttributedStrings strings: [NSAttributedString],
+                     nativeSampleBuffers _: [Any],
+                     forItemTime _: CMTime) {
+    delegate?.onTextTrackDataChanged(texts: strings)
+  }
+  
+  // MARK: - AVPlayerItemMetadataOutputPushDelegate
+  public func metadataOutput(_: AVPlayerItemMetadataOutput, didOutputTimedMetadataGroups groups: [AVTimedMetadataGroup], from _: AVPlayerItemTrack?) {
+    for metadataGroup in groups {
+      delegate?.onTimedMetadataChanged(timedMetadata: metadataGroup.items)
+    }
+  }
+  
+  // MARK: - AVPlayer Observers
+  func onPlayerCurrentItemChanged(player: AVPlayer, change: NSKeyValueObservedChange<AVPlayerItem?>) {
+    let newPlayerItem = change.newValue?.flatMap { $0 }
+    
+    // Remove observers for old player item
+    invalidatePlayerItemObservers()
+    
+    // Notify delegate about player item state change
+    delegate?.onPlayerItemWillChange(hasNewPlayerItem: newPlayerItem != nil)
+    
+    if let playerItem = newPlayerItem {
+      // Initialize observers for new player item
+      initializePlayerItemObservers(player: player, playerItem: playerItem)
+      
+      delegate?.onPlayerItemChange(player: player, playerItem: playerItem)
+    }
+  }
+  
+  // MARK: - AVPlayerItem Observers
+  func onPlayerAccessLog(playerItem: AVPlayerItem) {
+    guard let accessLog = playerItem.accessLog() else { return }
+    guard let lastEvent = accessLog.events.last else { return }
+    
+    delegate?.onBandwidthUpdate(bitrate: lastEvent.indicatedBitrate)
+  }
+  
+  // MARK: - Buffer State Management
+  
+  func setupBufferObservers(for playerItem: AVPlayerItem) {
+    clearBufferObservers()
+    
+    // Observe buffer empty - this indicates definite buffering
+    playbackBufferEmptyObserver = playerItem.observe(\.isPlaybackBufferEmpty, options: [.new, .initial]) { [weak self] playerItem, change in
+      let isEmpty = change.newValue ?? playerItem.isPlaybackBufferEmpty
+      if isEmpty {
+        self?.delegate?.onPlaybackBufferEmpty()
+      }
+    }
+    
+    // Observe likely to keep up - this indicates that buffering has finished
+    playbackLikelyToKeepUpObserver = playerItem.observe(\.isPlaybackLikelyToKeepUp, options: [.new, .initial]) { [weak self] playerItem, change in
+      let isLikelyToKeepUp = change.newValue ?? playerItem.isPlaybackLikelyToKeepUp
+      if isLikelyToKeepUp {
+        self?.delegate?.onPlaybackLikelyToKeepUp()
+      }
+    }
+    
+    // Observe buffer full as an additional signal
+    playbackBufferFullObserver = playerItem.observe(\.isPlaybackBufferFull, options: [.new, .initial]) { [weak self] playerItem, change in
+      let isFull = change.newValue ?? playerItem.isPlaybackBufferFull
+      if isFull {
+        self?.delegate?.onPlaybackLikelyToKeepUp()
+      }
+    }
+  }
+  
+  func clearBufferObservers() {
+    playbackBufferEmptyObserver?.invalidate()
+    playbackBufferFullObserver?.invalidate()
+    playbackLikelyToKeepUpObserver?.invalidate()
+    
+    playbackBufferEmptyObserver = nil
+    playbackBufferFullObserver = nil
+    playbackLikelyToKeepUpObserver = nil
+  }
+}

package/ios/hybrids/VideoPlayer/HybridVideoPlayer+Events.swift

@@ -0,0 +1,198 @@
+//
+//  HybridVideoPlayer+Events.swift
+//  ReactNativeVideo
+//
+//  Created by Krzysztof Moch on 02/05/2025.
+//
+
+import AVFoundation
+import Foundation
+
+extension HybridVideoPlayer: VideoPlayerObserverDelegate {
+  // MARK: - VideoPlayerObserverDelegate
+
+  func onPlayedToEnd(player: AVPlayer) {
+    _eventEmitter?.onEnd()
+
+    if loop {
+      currentTime = 0
+      try? play()
+    }
+  }
+
+  func onRateChanged(rate: Float) {
+    _eventEmitter?.onPlaybackRateChange(Double(rate))
+    NowPlayingInfoCenterManager.shared.updateNowPlayingInfo()
+    updateAndEmitPlaybackState()
+  }
+
+  func onVolumeChanged(volume: Float) {
+    _eventEmitter?.onVolumeChange(
+      onVolumeChangeData(
+        volume: Double(volume),
+        muted: muted
+      )
+    )
+  }
+
+  func onPlaybackBufferEmpty() {
+    isCurrentlyBuffering = true
+    status = .loading
+    updateAndEmitPlaybackState()
+  }
+
+  func onProgressUpdate(currentTime: Double, bufferDuration: Double) {
+    _eventEmitter?.onProgress(
+      .init(currentTime: currentTime, bufferDuration: bufferDuration)
+    )
+  }
+
+  func onPlaybackLikelyToKeepUp() {
+    isCurrentlyBuffering = false
+    if player.timeControlStatus == .playing {
+      status = .readytoplay
+    }
+    updateAndEmitPlaybackState()
+  }
+
+  func onExternalPlaybackActiveChanged(isActive: Bool) {
+    _eventEmitter?.onExternalPlaybackChange(isActive)
+  }
+
+  func onTimeControlStatusChanged(status: AVPlayer.TimeControlStatus) {
+    if player.status == .failed || playerItem?.status == .failed {
+      self.status = .error
+      isCurrentlyBuffering = false
+      _eventEmitter?.onPlaybackStateChange(
+        .init(isPlaying: false, isBuffering: false)
+      )
+      return
+    }
+
+    switch status {
+    case .waitingToPlayAtSpecifiedRate:
+      isCurrentlyBuffering = true
+      self.status = .loading
+      break
+
+    case .playing:
+      isCurrentlyBuffering = false
+      self.status = .readytoplay
+      break
+
+    case .paused:
+      isCurrentlyBuffering = false
+      self.status = .readytoplay
+      break
+
+    @unknown default:
+      break
+    }
+
+    updateAndEmitPlaybackState()
+  }
+
+  func onPlayerStatusChanged(status: AVPlayer.Status) {
+    if status == .failed || playerItem?.status == .failed {
+      self.status = .error
+      isCurrentlyBuffering = false
+      updateAndEmitPlaybackState()
+    }
+  }
+
+  func onPlayerItemStatusChanged(status: AVPlayerItem.Status) {
+    if status == .failed {
+      self.status = .error
+      isCurrentlyBuffering = false
+      updateAndEmitPlaybackState()
+      return
+    }
+
+    switch status {
+    case .unknown:
+      isCurrentlyBuffering = true
+      self.status = .loading
+
+      // Set initial buffering state when we have a playerItem
+      if let playerItem = self.playerItem {
+        if playerItem.isPlaybackBufferEmpty {
+          isCurrentlyBuffering = true
+        }
+      }
+
+    case .readyToPlay:
+      guard let playerItem else { return }
+
+      let height = playerItem.presentationSize.height
+      let width = playerItem.presentationSize.width
+      let orientation: VideoOrientation =
+        playerItem.asset.tracks.first(where: { $0.mediaType == .video })?
+        .orientation ?? .unknown
+
+      _eventEmitter?.onLoad(
+        .init(currentTime, duration, height, width, orientation)
+      )
+
+      if playerItem.isPlaybackLikelyToKeepUp
+        && !playerItem.isPlaybackBufferEmpty
+      {
+        isCurrentlyBuffering = false
+        self.status = .readytoplay
+      }
+
+    case .failed:
+      self.status = .error
+      isCurrentlyBuffering = false
+
+    @unknown default:
+      break
+    }
+
+    updateAndEmitPlaybackState()
+  }
+
+  func onTextTrackDataChanged(texts: [NSAttributedString]) {
+    _eventEmitter?.onTextTrackDataChanged(texts.map { $0.string })
+  }
+
+  func onTimedMetadataChanged(timedMetadata: [AVMetadataItem]) {
+    var metadata: [TimedMetadataObject] = []
+    for item in timedMetadata {
+      let value = item.value as? String
+      let identifier = item.identifier?.rawValue
+
+      if let value, let identifier {
+        metadata.append(.init(value: value, identifier: identifier))
+      }
+    }
+
+    _eventEmitter?.onTimedMetadata(.init(metadata: metadata))
+  }
+
+  func onBandwidthUpdate(bitrate: Double) {
+    _eventEmitter?.onBandwidthUpdate(
+      .init(bitrate: bitrate, width: nil, height: nil)
+    )
+  }
+
+  func onPlayerItemWillChange(hasNewPlayerItem: Bool) {
+    if hasNewPlayerItem {
+      // Set initial buffering state when playerItem is assigned
+      isCurrentlyBuffering = true
+      status = .loading
+      updateAndEmitPlaybackState()
+    } else {
+      // Clean up state when playerItem is cleared
+      isCurrentlyBuffering = false
+    }
+  }
+
+  func updateAndEmitPlaybackState() {
+    let isPlaying = player.rate > 0 && !isCurrentlyBuffering
+
+    _eventEmitter?.onPlaybackStateChange(
+      .init(isPlaying: isPlaying, isBuffering: isCurrentlyBuffering)
+    )
+    _eventEmitter?.onBuffer(isCurrentlyBuffering)
+  }
+}