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

package/ios/core/Plugins/PluginsRegistry.swift

@@ -0,0 +1,102 @@
+//
+//  PluginRegistry.swift
+//  ReactNativeVideo
+//
+//  Created by Krzysztof Moch on 22/07/2025.
+//
+
+import AVFoundation
+import Foundation
+
+public final class PluginsRegistry {
+  public static let shared = PluginsRegistry()
+
+  // Plugin ID -> ReactNativeVideoPluginSpec
+  private var plugins: [String: ReactNativeVideoPluginSpec] = [:]
+
+  // MARK: - Public API
+
+  public func register(plugin: ReactNativeVideoPluginSpec) {
+    #if DEBUG
+      if hasPlugin(plugin: plugin) {
+        print(
+          "[ReactNativeVideo] Plugin \(plugin.name) (ID: \(plugin.id)) is already registered - overwriting."
+        )
+      } else {
+        print(
+          "[ReactNativeVideo] Registering plugin \(plugin.name) (ID: \(plugin.id))."
+        )
+      }
+    #endif
+
+    plugins.updateValue(plugin, forKey: plugin.id)
+  }
+
+  public func unregister(plugin: ReactNativeVideoPluginSpec) {
+    #if DEBUG
+      if !hasPlugin(plugin: plugin) {
+        print(
+          "[ReactNativeVideo] Plugin \(plugin.name) (ID: \(plugin.id)) is not registered - skipping."
+        )
+      } else {
+        print("[ReactNativeVideo] Unregistering plugin \(plugin.name) (ID: \(plugin.id)).")
+      }
+    #endif
+
+    plugins.removeValue(forKey: plugin.id)
+  }
+
+  // MARK: - Internal API
+
+  private func hasPlugin(plugin: ReactNativeVideoPluginSpec) -> Bool {
+    return plugins.contains { $0.value.id == plugin.id }
+  }
+
+  internal func getDrmManager(source: NativeVideoPlayerSource) throws -> DRMManagerSpec? {
+    for plugin in plugins.values {
+      if let drmManager = plugin.getDRMManager(source: source) {
+        return drmManager
+      }
+    }
+
+    throw LibraryError.DRMPluginNotFound.error()
+  }
+
+  internal func overrideSource(source: NativeVideoPlayerSource) async
+    -> NativeVideoPlayerSource
+  {
+    var overriddenSource = source
+
+    for plugin in plugins.values {
+      overriddenSource = await plugin.overrideSource(source: overriddenSource)
+    }
+
+    return overriddenSource
+  }
+
+  // MARK: - Notifications
+
+  internal func notifyPlayerCreated(player: NativeVideoPlayer) {
+    for plugin in plugins.values {
+      plugin.onPlayerCreated(player: Weak(value: player))
+    }
+  }
+
+  internal func notifyPlayerDestroyed(player: NativeVideoPlayer) {
+    for plugin in plugins.values {
+      plugin.onPlayerDestroyed(player: Weak(value: player))
+    }
+  }
+
+  internal func notifyVideoViewCreated(view: VideoComponentView) {
+    for plugin in plugins.values {
+      plugin.onVideoViewCreated(view: Weak(value: view))
+    }
+  }
+
+  internal func notifyVideoViewDestroyed(view: VideoComponentView) {
+    for plugin in plugins.values {
+      plugin.onVideoViewDestroyed(view: Weak(value: view))
+    }
+  }
+}

package/ios/core/Plugins/ReactNativeVideoPlugin.swift

@@ -0,0 +1,91 @@
+//
+//  ReactNativeVideoPlugin.swift
+//  ReactNativeVideo
+//
+//  Created by Krzysztof Moch on 22/07/2025.
+//
+
+import AVFoundation
+import Foundation
+
+public protocol ReactNativeVideoPluginSpec {
+  /**
+   * The ID of the plugin.
+   */
+  var id: String { get }
+
+  /**
+   * The name of the plugin.
+   */
+  var name: String { get }
+
+  /**
+   * Called when a player is created.
+   *
+   * @param player The weak reference to the player instance.
+   */
+  func onPlayerCreated(player: Weak<NativeVideoPlayer>)
+
+  /**
+   * Called when a player is destroyed.
+   *
+   * @param player The weak reference to the player instance.
+   */
+  func onPlayerDestroyed(player: Weak<NativeVideoPlayer>)
+
+  /**
+   * Called when a video view is created.
+   *
+   * @param view The weak reference to the video view instance.
+   */
+  func onVideoViewCreated(view: Weak<VideoComponentView>)
+
+  /**
+   * Called when a video view is destroyed.
+   *
+   * @param view The weak reference to the video view instance.
+   */
+  func onVideoViewDestroyed(view: Weak<VideoComponentView>)
+
+  /**
+   * Called when a source is overridden.
+   *
+   * @param source The source instance.
+   * @return The overridden source instance.
+   */
+  func overrideSource(source: NativeVideoPlayerSource) async -> NativeVideoPlayerSource
+
+  /**
+   * Called when a DRM manager is requested.
+   *
+   * @param source The source instance.
+   * @return The DRM manager instance.
+   */
+  func getDRMManager(source: NativeVideoPlayerSource) -> DRMManagerSpec?
+}
+
+open class ReactNativeVideoPlugin: ReactNativeVideoPluginSpec {
+  public let id: String
+  public let name: String
+
+  public init(name: String) {
+    self.name = name
+    self.id = "RNV_Plugin_\(name)"
+
+    PluginsRegistry.shared.register(plugin: self)
+  }
+
+  open func onPlayerCreated(player: Weak<NativeVideoPlayer>) { /* no-op */  }
+  open func onPlayerDestroyed(player: Weak<NativeVideoPlayer>) { /* no-op */  }
+
+  open func onVideoViewCreated(view: Weak<VideoComponentView>) { /* no-op */  }
+  open func onVideoViewDestroyed(view: Weak<VideoComponentView>) { /* no-op */  }
+
+  open func overrideSource(source: NativeVideoPlayerSource) async -> NativeVideoPlayerSource {
+    return source
+  }
+
+  open func getDRMManager(source: NativeVideoPlayerSource) -> DRMManagerSpec? {
+    return nil
+  }
+}

package/ios/core/Spec/DRMManagerSpec.swift

@@ -0,0 +1,14 @@
+//
+//  DRMManagerSpec.swift
+//  ReactNativeVideo
+//
+//  Created by Krzysztof Moch on 05/08/2025.
+//
+
+import Foundation
+import AVFoundation
+
+public protocol DRMManagerSpec: AVContentKeySessionDelegate {
+  /// Creates a content key request for the given asset and DRM parameters.
+  func createContentKeyRequest(for asset: AVURLAsset, drmParams: NativeDrmParams) throws
+}

package/ios/core/Spec/NativeVideoPlayerSourceSpec.swift

@@ -0,0 +1,36 @@
+//
+//  NativeVideoPlayerSourceSpec.swift
+//  react-native-video
+//
+// Created by Krzysztof Moch on 23/07/2025.
+//
+
+import Foundation
+import AVFoundation
+
+// Helper alias that allow to represet player source outside of module
+public typealias NativeVideoPlayerSource = NativeVideoPlayerSourceSpec & HybridVideoPlayerSourceSpec
+
+public protocol NativeVideoPlayerSourceSpec {
+  // MARK: - Properties
+  
+  /// The underlying AVURLAsset instance
+  var asset: AVURLAsset? { get set }
+  
+  /// The URL of the video source
+  var url: URL { get }
+  
+  /// The memory size used by the source
+  var memorySize: Int { get }
+  
+  // MARK: - Methods
+  
+  /// Initialize the asset asynchronously
+  func initializeAsset() async throws
+  
+  /// Get non-null AVURLAsset instance (self.asset)
+  func getAsset() async throws -> AVURLAsset
+  
+  /// Release the asset resources
+  func releaseAsset()
+} 

package/ios/core/Spec/NativeVideoPlayerSpec.swift

@@ -0,0 +1,42 @@
+//
+//  NativeVideoPlayerSpec.swift
+//  react-native-video
+//
+// Created by Krzysztof Moch on 09/10/2024.
+//
+
+import Foundation
+import AVFoundation
+
+// Helper alias that allow to represet player outside of module
+public typealias NativeVideoPlayer = NativeVideoPlayerSpec & HybridVideoPlayerSpec
+
+public protocol NativeVideoPlayerSpec {
+  // MARK: - Properties
+  
+  /// The underlying AVPlayer instance (should not be used directly)
+  var player: AVPlayer { get set }
+  
+  /// The current player item
+  var playerItem: AVPlayerItem? { get set }
+  
+  /// The player observer for monitoring state changes
+  // var playerObserver: VideoPlayerObserver? { get set }
+  
+  /// Whether the player was auto-paused
+  var wasAutoPaused: Bool { get set }
+  
+  /// Whether the player is currently buffering
+  var isCurrentlyBuffering: Bool { get set }
+  
+  /// The memory size used by the player
+  var memorySize: Int { get }
+  
+  // MARK: - Methods
+  
+  /// Release the player resources
+  func release()
+  
+  /// Initialize the player item asynchronously
+  func initializePlayerItem() async throws -> AVPlayerItem
+}

package/ios/core/Utils/ExternalSubtitlesUtils.swift

@@ -0,0 +1,119 @@
+import AVFoundation
+import ObjectiveC
+
+private var HLSSubtitleInjectorAssociatedKey: UInt8 = 0
+
+enum ExternalSubtitlesUtils {
+  static func isSubtitleTypeSupported(subtitle: NativeExternalSubtitle) -> Bool {
+    if subtitle.type == .vtt {
+      return true
+    }
+
+    if let url = URL(string: subtitle.uri), url.pathExtension == "vtt" {
+      return true
+    }
+
+    return false
+  }
+
+  static func createCompositionWithExternalSubtitles(
+    for asset: AVURLAsset,
+    config: NativeVideoConfig
+  ) async throws -> AVPlayerItem {
+    let subtitlesAssets = try config.externalSubtitles?.map { subtitle in
+      guard let url = URL(string: subtitle.uri) else {
+        throw PlayerError.invalidTrackUrl(url: subtitle.uri).error()
+      }
+
+      return AVURLAsset(url: url)
+    }
+
+    do {
+      let mainVideoTracks = asset.tracks(withMediaType: .video)
+      let mainAudioTracks = asset.tracks(withMediaType: .audio)
+      let textTracks =
+        subtitlesAssets?.flatMap { $0.tracks(withMediaType: .text) } ?? []
+
+      let composition = AVMutableComposition()
+
+      if let videoTrack = mainVideoTracks.first(where: { $0.mediaType == .video }){
+        if let compositionVideoTrack = composition.addMutableTrack(
+          withMediaType: .video,
+          preferredTrackID: kCMPersistentTrackID_Invalid
+        ) {
+          try compositionVideoTrack.insertTimeRange(
+            CMTimeRange(start: .zero, duration: videoTrack.timeRange.duration),
+            of: videoTrack,
+            at: .zero
+          )
+        }
+      }
+
+      if let audioTrack = mainAudioTracks.first(where: { $0.mediaType == .audio }) {
+        if let compositionAudioTrack = composition.addMutableTrack(
+          withMediaType: .audio,
+          preferredTrackID: kCMPersistentTrackID_Invalid
+        ) {
+          try compositionAudioTrack.insertTimeRange(
+            CMTimeRange(start: .zero, duration: audioTrack.timeRange.duration),
+            of: audioTrack,
+            at: .zero
+          )
+        }
+      }
+
+      for textTrack in textTracks {
+        if let compositionTextTrack = composition.addMutableTrack(
+          withMediaType: .text,
+          preferredTrackID: kCMPersistentTrackID_Invalid
+        ) {
+          try compositionTextTrack.insertTimeRange(
+            CMTimeRange(start: .zero, duration: textTrack.timeRange.duration),
+            of: textTrack,
+            at: .zero
+          )
+
+          compositionTextTrack.languageCode = textTrack.languageCode
+          compositionTextTrack.isEnabled = true
+        }
+      }
+
+      return await AVPlayerItem(asset: composition)
+    }
+  }
+
+  static func modifyStreamManifestWithExternalSubtitles(
+    for asset: AVURLAsset,
+    config: NativeVideoConfig
+  ) async throws -> AVPlayerItem {
+    guard let externalSubtitles = config.externalSubtitles,
+      !externalSubtitles.isEmpty
+    else {
+      return AVPlayerItem(asset: asset)
+    }
+
+    let supportedSubtitles = externalSubtitles.filter { subtitle in
+      isSubtitleTypeSupported(subtitle: subtitle)
+    }
+
+    guard !supportedSubtitles.isEmpty else {
+      return AVPlayerItem(asset: asset)
+    }
+
+    let subtitleInjector = HLSSubtitleInjector(
+      manifestUrl: asset.url,
+      externalSubtitles: supportedSubtitles
+    )
+    let modifiedAsset = subtitleInjector.createModifiedAsset()
+    let playerItem = AVPlayerItem(asset: modifiedAsset)
+
+    objc_setAssociatedObject(
+      playerItem,
+      &HLSSubtitleInjectorAssociatedKey,
+      subtitleInjector,
+      .OBJC_ASSOCIATION_RETAIN_NONATOMIC
+    )
+
+    return playerItem
+  }
+}

package/ios/core/Utils/HLSManifestParser.swift

@@ -0,0 +1,170 @@
+import AVFoundation
+import Foundation
+import NitroModules
+
+class HLSManifestParser {
+
+  /// Downloads manifest content from the given URL
+  static func downloadManifest(from url: URL) async throws -> String {
+    let (data, response) = try await URLSession.shared.data(from: url)
+
+    guard let httpResponse = response as? HTTPURLResponse,
+      200...299 ~= httpResponse.statusCode
+    else {
+      throw SourceError.invalidUri(uri: url.absoluteString).error()
+    }
+
+    guard let manifestContent = String(data: data, encoding: .utf8) else {
+      throw SourceError.invalidUri(uri: url.absoluteString).error()
+    }
+
+    return manifestContent
+  }
+
+  /// Converts relative URLs in a manifest line to absolute URLs
+  static func convertRelativeURLsToAbsolute(line: String, baseURL: URL) -> String {
+    let trimmedLine = line.trimmingCharacters(in: .whitespaces)
+
+    if trimmedLine.isEmpty {
+      return line
+    }
+
+    if trimmedLine.hasPrefix("#") {
+      if trimmedLine.contains("URI=") {
+        return convertURIParametersToAbsolute(line: line, baseURL: baseURL)
+      }
+      return line
+    }
+
+    if !trimmedLine.hasPrefix("http://") && !trimmedLine.hasPrefix("https://") {
+      let absoluteURL = baseURL.appendingPathComponent(trimmedLine)
+      return absoluteURL.absoluteString
+    }
+
+    return line
+  }
+
+  /// Converts URI parameters in manifest lines to absolute URLs
+  static func convertURIParametersToAbsolute(line: String, baseURL: URL) -> String {
+    var modifiedLine = line
+    let uriPattern = #"URI="([^"]+)""#
+
+    guard let regex = try? NSRegularExpression(pattern: uriPattern, options: [])
+    else {
+      return line
+    }
+
+    let nsLine = line as NSString
+    let matches = regex.matches(
+      in: line,
+      options: [],
+      range: NSRange(location: 0, length: nsLine.length)
+    )
+
+    for match in matches.reversed() {
+      if match.numberOfRanges >= 2 {
+        let uriRange = match.range(at: 1)
+        let uri = nsLine.substring(with: uriRange)
+
+        if !uri.hasPrefix("http://") && !uri.hasPrefix("https://") {
+          let absoluteURL = baseURL.appendingPathComponent(uri)
+          let fullRange = match.range(at: 0)
+          let replacement = "URI=\"\(absoluteURL.absoluteString)\""
+          modifiedLine = (modifiedLine as NSString).replacingCharacters(
+            in: fullRange,
+            with: replacement
+          )
+        }
+      }
+    }
+
+    return modifiedLine
+  }
+
+  /// Parses M3U8 manifest content and returns parsed information
+  static func parseM3U8Manifest(_ content: String) throws -> HLSManifestInfo {
+    let lines = content.components(separatedBy: .newlines)
+    var info = HLSManifestInfo()
+
+    for line in lines {
+      let trimmedLine = line.trimmingCharacters(in: .whitespaces)
+
+      if trimmedLine.hasPrefix("#EXTM3U") {
+        info.isValid = true
+      }
+
+      // Parse version
+      if trimmedLine.hasPrefix("#EXT-X-VERSION:") {
+        let versionString = String(trimmedLine.dropFirst("#EXT-X-VERSION:".count))
+        info.version = Int(versionString)
+      }
+
+      // Parse stream info for resolution
+      if trimmedLine.hasPrefix("#EXT-X-STREAM-INF:") {
+        let streamInfo = parseStreamInf(trimmedLine)
+        info.streams.append(streamInfo)
+      }
+    }
+
+    if !info.isValid {
+      throw SourceError.invalidUri(uri: "Invalid M3U8 format").error()
+    }
+
+    return info
+  }
+
+  /// Parses EXT-X-STREAM-INF line to extract stream information
+  private static func parseStreamInf(_ line: String) -> HLSStreamInfo {
+    var streamInfo = HLSStreamInfo()
+
+    // Parse RESOLUTION
+    if let resolutionRange = line.range(of: "RESOLUTION=") {
+      let afterResolution = line[resolutionRange.upperBound...]
+      if let commaRange = afterResolution.range(of: ",") {
+        let resolutionValue = String(afterResolution[..<commaRange.lowerBound])
+        let components = resolutionValue.components(separatedBy: "x")
+        if components.count == 2 {
+          streamInfo.width = Int(components[0])
+          streamInfo.height = Int(components[1])
+        }
+      } else {
+        // Resolution is at the end of the line
+        let resolutionValue = String(afterResolution)
+        let components = resolutionValue.components(separatedBy: "x")
+        if components.count == 2 {
+          streamInfo.width = Int(components[0])
+          streamInfo.height = Int(components[1])
+        }
+      }
+    }
+
+    // Parse BANDWIDTH
+    if let bandwidthRange = line.range(of: "BANDWIDTH=") {
+      let afterBandwidth = line[bandwidthRange.upperBound...]
+      if let commaRange = afterBandwidth.range(of: ",") {
+        let bandwidthValue = String(afterBandwidth[..<commaRange.lowerBound])
+        streamInfo.bandwidth = Int(bandwidthValue)
+      } else {
+        // Bandwidth is at the end of the line
+        let bandwidthValue = String(afterBandwidth)
+        streamInfo.bandwidth = Int(bandwidthValue)
+      }
+    }
+
+    return streamInfo
+  }
+}
+
+// MARK: - Data Structures
+
+struct HLSManifestInfo {
+  var isValid: Bool = false
+  var version: Int?
+  var streams: [HLSStreamInfo] = []
+}
+
+struct HLSStreamInfo {
+  var width: Int?
+  var height: Int?
+  var bandwidth: Int?
+}

package/ios/core/Utils/Weak.swift

@@ -0,0 +1,26 @@
+//
+//  Weak.swift
+//  ReactNativeVideo
+//
+//  Created by Krzysztof Moch on 31/07/2025.
+//
+
+import Foundation
+
+/// A generic class for managing weak references to objects.
+///
+/// The `Weak<T>` class is designed to hold a weak reference to an object of type `T`.
+/// This is particularly useful in scenarios where strong references could lead to retain cycles
+/// or memory leaks, such as in plugin systems or delegate patterns.
+///
+/// - Note: The `value` property provides access to the referenced object, or `nil` if the object has been deallocated.
+public class Weak<T> {
+  private weak var _value: AnyObject?
+  public var value: T? {
+    return _value as? T
+  }
+
+  public init(value: T) {
+    _value = value as AnyObject
+  }
+}