react-native-audio-browser 0.2.0-next.28 → 0.2.0-next.29

package/ios/Observer/PlayerStateObserver.swift

@@ -1,50 +0,0 @@
-import AVFoundation
-import Foundation
-
-/**
- Observes player state changes and invokes callbacks passed at initialization.
- Uses modern block-based KVO for type-safe observation with automatic cleanup.
- */
-@MainActor final class PlayerStateObserver {
-  private var observations: [NSKeyValueObservation] = []
-
-  weak var avPlayer: AVPlayer? {
-    willSet {
-      stopObserving()
-    }
-  }
-
-  private let onStatusChange: @MainActor (AVPlayer.Status) -> Void
-  private let onTimeControlStatusChange: @MainActor (AVPlayer.TimeControlStatus) -> Void
-
-  init(
-    onStatusChange: @escaping @MainActor (AVPlayer.Status) -> Void,
-    onTimeControlStatusChange: @escaping @MainActor (AVPlayer.TimeControlStatus) -> Void,
-  ) {
-    self.onStatusChange = onStatusChange
-    self.onTimeControlStatusChange = onTimeControlStatusChange
-  }
-
-  /**
-   Start receiving events from this observer.
-   */
-  func startObserving() {
-    guard let avPlayer else { return }
-    stopObserving()
-
-    observations = [
-      avPlayer.observe(\.status, options: [.new, .initial]) { [weak self] player, _ in
-        let status = player.status
-        Task { @MainActor in self?.onStatusChange(status) }
-      },
-      avPlayer.observe(\.timeControlStatus, options: [.new]) { [weak self] player, _ in
-        let status = player.timeControlStatus
-        Task { @MainActor in self?.onTimeControlStatusChange(status) }
-      },
-    ]
-  }
-
-  func stopObserving() {
-    observations.removeAll()
-  }
-}

package/ios/Observer/PlayerTimeObserver.swift

@@ -1,55 +0,0 @@
-import AVFoundation
-import Foundation
-
-/**
- Observes the player's audio-start boundary and invokes the callback passed at initialization.
- */
-@MainActor class PlayerTimeObserver {
-  /// The time to use as start boundary time. Cannot be zero.
-  private static let startBoundaryTime: CMTime = .init(value: 1, timescale: 1000)
-
-  var boundaryTimeStartObserverToken: Any?
-
-  weak var avPlayer: AVPlayer? {
-    willSet {
-      unregisterForBoundaryTimeEvents()
-    }
-  }
-
-  private let onAudioDidStart: @MainActor () -> Void
-
-  init(onAudioDidStart: @escaping @MainActor () -> Void) {
-    self.onAudioDidStart = onAudioDidStart
-  }
-
-  /**
-   Will register for the AVPlayer BoundaryTimeEvents, to trigger the audio-start event.
-   */
-  func registerForBoundaryTimeEvents() {
-    guard let avPlayer else {
-      return
-    }
-    unregisterForBoundaryTimeEvents()
-    boundaryTimeStartObserverToken = avPlayer.addBoundaryTimeObserver(
-      forTimes: [PlayerTimeObserver.startBoundaryTime].map {
-        NSValue(time: $0)
-      },
-      queue: nil,
-      using: { [weak self] in
-        Task { @MainActor in self?.onAudioDidStart() }
-      },
-    )
-  }
-
-  /**
-   Unregister from the boundary events of the player.
-   */
-  func unregisterForBoundaryTimeEvents() {
-    guard
-      let avPlayer,
-      let boundaryTimeStartObserverToken
-    else { return }
-    avPlayer.removeTimeObserver(boundaryTimeStartObserverToken)
-    self.boundaryTimeStartObserverToken = nil
-  }
-}

package/ios/Option/PitchAlgorithms.swift

@@ -1,17 +0,0 @@
-import AVFoundation
-import Foundation
-
-public enum PitchAlgorithm: String {
-  case linear
-  case music
-  case voice
-
-  /// The corresponding AVAudioTimePitchAlgorithm for use with AVPlayer
-  public var avAlgorithm: AVAudioTimePitchAlgorithm {
-    switch self {
-    case .linear: .varispeed
-    case .music: .spectral
-    case .voice: .timeDomain
-    }
-  }
-}

package/ios/Option/TimeEventFrequency.swift

@@ -1,18 +0,0 @@
-import AVFoundation
-import Foundation
-
-enum TimeEventFrequency {
-  case everySecond
-  case everyHalfSecond
-  case everyQuarterSecond
-  case custom(time: CMTime)
-
-  func getTime() -> CMTime {
-    switch self {
-    case .everySecond: CMTime(value: 1, timescale: 1)
-    case .everyHalfSecond: CMTime(value: 1, timescale: 2)
-    case .everyQuarterSecond: CMTime(value: 1, timescale: 4)
-    case let .custom(time): time
-    }
-  }
-}

package/ios/Player/LoadSeekCoordinator.swift

@@ -1,99 +0,0 @@
-import AVFoundation
-import os.log
-
-/// AVPlayer's `seek(to:)` is a no-op when there's no loaded `currentItem`,
-/// so we must manually defer seeks that arrive during loading and execute them
-/// once the AVPlayerItem is ready. This coordinator encapsulates the three
-/// sub-problems (capture, execute, coordinate) that were previously spread
-/// across `pendingSeek`, `loadSeekInFlight`, and guards in multiple callbacks.
-@MainActor
-final class LoadSeekCoordinator {
-  enum State {
-    case idle
-    case pendingSeek(time: TimeInterval)
-    case seekInFlight(time: TimeInterval)
-  }
-
-  private let logger = Logger(subsystem: "com.audiobrowser", category: "LoadSeekCoordinator")
-  private(set) var state: State = .idle
-
-  /// Identifies the item epoch a seek was issued against. `reset()` (called on
-  /// track/queue changes) bumps it, so the completion of a seek issued against
-  /// the previous item can recognize itself as stale and be dropped — a
-  /// cancelled cross-item completion arriving after the new track's start
-  /// position was captured would otherwise consume or prematurely resolve it.
-  private(set) var generation = 0
-
-  func isCurrentGeneration(_ generation: Int) -> Bool {
-    generation == self.generation
-  }
-
-  /// Used by `seekBy()` to offset from the deferred position.
-  var pendingTime: TimeInterval? {
-    switch state {
-    case let .pendingSeek(time): time
-    case let .seekInFlight(time): time
-    case .idle: nil
-    }
-  }
-
-  var shouldDeferReadyTransition: Bool {
-    switch state {
-    case .idle: false
-    case .pendingSeek, .seekInFlight: true
-    }
-  }
-
-  func capture(position: Double) {
-    if case .seekInFlight = state {
-      logger.debug("overriding in-flight seek with new target \(position)s")
-    }
-    state = .pendingSeek(time: position)
-    logger.debug("captured pending seek to \(position)s")
-  }
-
-  /// Returns `true` if a seek was initiated -- caller should NOT transition to `.ready` yet.
-  func executeIfPending(on player: AVPlayer, delegate: (any SeekCompletionHandler)?) -> Bool {
-    guard case let .pendingSeek(time) = state else { return false }
-
-    logger.debug("executing deferred seek to \(time)s")
-    state = .seekInFlight(time: time)
-
-    let cmTime = CMTime(seconds: time, preferredTimescale: 1000)
-    let generation = generation
-    player
-      .seek(to: cmTime, toleranceBefore: CMTime.zero, toleranceAfter: CMTime.zero) {
-        [weak self] finished in
-        Task { @MainActor in
-          guard let self, self.isCurrentGeneration(generation) else { return }
-          delegate?.handleSeekCompleted(to: time, didFinish: finished)
-        }
-      }
-
-    return true
-  }
-
-  /// Returns `true` if done (caller should transition `.loading` -> `.ready`).
-  /// Returns `false` if a new seek was queued while in-flight (re-executes automatically).
-  func seekDidComplete(on player: AVPlayer, delegate: (any SeekCompletionHandler)?) -> Bool {
-    switch state {
-    case .seekInFlight:
-      logger.debug("seek landed, clearing coordinator")
-      state = .idle
-      return true
-    case .pendingSeek:
-      // A new seek arrived while the previous one was in-flight.
-      // Execute it now -- don't transition to .ready yet.
-      logger.debug("seek landed, but a new seek is pending -- re-executing")
-      _ = executeIfPending(on: player, delegate: delegate)
-      return false
-    case .idle:
-      return false
-    }
-  }
-
-  func reset() {
-    state = .idle
-    generation += 1
-  }
-}

package/ios/Player/MediaLoaderDelegate.swift

@@ -1,11 +0,0 @@
-import AVFoundation
-
-@MainActor protocol MediaLoaderDelegate: AnyObject {
-  func mediaLoaderDidPrepareItem(_ item: AVPlayerItem)
-  func mediaLoaderDidFailWithUnplayableTrack()
-  func mediaLoaderDidFailWithRetryableError(_ error: Error)
-  func mediaLoaderDidFailWithError(_ error: TrackPlayerError.PlaybackError)
-  func mediaLoaderDidReceiveCommonMetadata(_ items: [AVMetadataItem])
-  func mediaLoaderDidReceiveChapterMetadata(_ groups: [AVTimedMetadataGroup])
-  func mediaLoaderDidReceiveTimedMetadata(_ groups: [AVTimedMetadataGroup])
-}