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

package/ios/core/HLSSubtitleInjector.swift

@@ -0,0 +1,381 @@
+import AVFoundation
+import Foundation
+import NitroModules
+
+class HLSSubtitleInjector: NSObject {
+  private let originalManifestUrl: URL
+  private let externalSubtitles: [NativeExternalSubtitle]
+  private var modifiedManifestContent: String?
+  private static let customScheme = "rnv-hls"
+  private static let subtitleScheme = "rnv-hls-subtitles"
+  private static let subtitleGroupID = "rnv-subs"
+  private static let resourceLoaderQueue = DispatchQueue(
+    label: "com.nitro.HLSSubtitleInjector.resourceLoaderQueue",
+    qos: .userInitiated
+  )
+
+  init(manifestUrl: URL, externalSubtitles: [NativeExternalSubtitle]) {
+    self.originalManifestUrl = manifestUrl
+    self.externalSubtitles = externalSubtitles
+    super.init()
+  }
+
+  func createModifiedAsset() -> AVURLAsset {
+    let customURL = createCustomURL(from: originalManifestUrl)
+    let asset = AVURLAsset(url: customURL)
+    asset.resourceLoader.setDelegate(
+      self,
+      queue: Self.resourceLoaderQueue
+    )
+    return asset
+  }
+
+  private func createCustomURL(from originalURL: URL) -> URL {
+    var components = URLComponents(
+      url: originalURL,
+      resolvingAgainstBaseURL: false
+    )!
+    components.scheme = Self.customScheme
+    return components.url!
+  }
+
+  private func getModifiedManifestContent() async throws -> String {
+    if let cached = modifiedManifestContent {
+      return cached
+    }
+
+    let originalContent = try await HLSManifestParser.downloadManifest(from: originalManifestUrl)
+    let modifiedContent = try modifyM3U8Content(
+      originalContent,
+      with: externalSubtitles
+    )
+    modifiedManifestContent = modifiedContent
+    return modifiedContent
+  }
+
+  private func modifyM3U8Content(
+    _ originalContent: String,
+    with externalSubtitles: [NativeExternalSubtitle]
+  ) throws -> String {
+    let lines = originalContent.components(separatedBy: .newlines)
+    var modifiedLines: [String] = []
+    var foundExtM3U = false
+    var isAfterVersionOrM3U = false
+    var hasSubtitleGroup = false
+    let baseURL = originalManifestUrl.deletingLastPathComponent()
+
+    for line in lines {
+      let trimmedLine = line.trimmingCharacters(in: .whitespaces)
+
+      if trimmedLine.hasPrefix("#EXTM3U") {
+        foundExtM3U = true
+        modifiedLines.append(line)
+        isAfterVersionOrM3U = true
+        continue
+      }
+
+      if isAfterVersionOrM3U && !hasSubtitleGroup
+        && shouldInsertSubtitlesHere(line: trimmedLine)
+      {
+        for (index, subtitle) in externalSubtitles.enumerated() {
+          let subtitleTrack = createSubtitleTrackEntry(for: subtitle, index: index)
+          modifiedLines.append(subtitleTrack)
+        }
+        hasSubtitleGroup = true
+        isAfterVersionOrM3U = false
+      }
+
+      let processedLine = HLSManifestParser.convertRelativeURLsToAbsolute(
+        line: line,
+        baseURL: baseURL
+      )
+
+      // Handle existing subtitle groups and stream info lines
+      if trimmedLine.hasPrefix("#EXT-X-MEDIA:") && trimmedLine.contains("TYPE=SUBTITLES") {
+        let modifiedMediaLine = replaceSubtitleGroupInMediaLine(processedLine)
+        modifiedLines.append(modifiedMediaLine)
+      } else if trimmedLine.hasPrefix("#EXT-X-STREAM-INF:") {
+        let modifiedStreamLine = replaceSubtitleGroupInStreamInf(
+          processedLine, hasSubtitleGroup: hasSubtitleGroup)
+        modifiedLines.append(modifiedStreamLine)
+      } else {
+        modifiedLines.append(processedLine)
+      }
+    }
+
+    if foundExtM3U && !hasSubtitleGroup {
+      var finalLines: [String] = []
+      var insertedSubtitles = false
+
+      for line in modifiedLines {
+        finalLines.append(line)
+
+        if !insertedSubtitles
+          && (line.hasPrefix("#EXTM3U") || line.hasPrefix("#EXT-X-VERSION"))
+        {
+          for (index, subtitle) in externalSubtitles.enumerated() {
+            let subtitleTrack = createSubtitleTrackEntry(for: subtitle, index: index)
+            finalLines.append(subtitleTrack)
+          }
+          insertedSubtitles = true
+        }
+      }
+
+      modifiedLines = finalLines
+    }
+
+    if !foundExtM3U {
+      throw SourceError.invalidUri(uri: originalManifestUrl.absoluteString)
+        .error()
+    }
+
+    // Post-process: ensure every variant stream references our subtitle group if we injected it
+    if hasSubtitleGroup {
+      modifiedLines = modifiedLines.map { line in
+        if line.hasPrefix("#EXT-X-STREAM-INF:") && !line.contains("SUBTITLES=") {
+          if line.hasSuffix(",") {
+            return line + "SUBTITLES=\"\(Self.subtitleGroupID)\""
+          } else {
+            return line + ",SUBTITLES=\"\(Self.subtitleGroupID)\""
+          }
+        }
+        return line
+      }
+    }
+
+    return modifiedLines.joined(separator: "\n")
+  }
+
+  private func shouldInsertSubtitlesHere(line: String) -> Bool {
+    return line.hasPrefix("#EXT-X-STREAM-INF:")
+      || line.hasPrefix("#EXT-X-I-FRAME-STREAM-INF:")
+      || line.hasPrefix("#EXT-X-MEDIA:")
+      || line.hasPrefix("#EXTINF:")
+      || line.hasPrefix("#EXT-X-BYTERANGE:")
+      || (!line.hasPrefix("#") && !line.isEmpty
+        && !line.hasPrefix("#EXT-X-VERSION"))
+  }
+
+  private func replaceSubtitleGroupInMediaLine(_ line: String) -> String {
+    // Find and replace GROUP-ID in subtitle media lines
+    let groupIdPattern = #"GROUP-ID="[^"]*""#
+
+    if let regex = try? NSRegularExpression(pattern: groupIdPattern, options: []) {
+      let range = NSRange(location: 0, length: line.utf16.count)
+      let replacement = "GROUP-ID=\"\(Self.subtitleGroupID)\""
+      return regex.stringByReplacingMatches(
+        in: line, options: [], range: range, withTemplate: replacement)
+    }
+
+    return line
+  }
+
+  private func replaceSubtitleGroupInStreamInf(_ line: String, hasSubtitleGroup: Bool) -> String {
+    // First, handle existing SUBTITLES= references
+    let subtitlesPattern = #"SUBTITLES="[^"]*""#
+
+    var modifiedLine = line
+    if let regex = try? NSRegularExpression(pattern: subtitlesPattern, options: []) {
+      let range = NSRange(location: 0, length: line.utf16.count)
+      let replacement = "SUBTITLES=\"\(Self.subtitleGroupID)\""
+      modifiedLine = regex.stringByReplacingMatches(
+        in: line, options: [], range: range, withTemplate: replacement)
+    } else if hasSubtitleGroup && !line.contains("SUBTITLES=") {
+      // Add subtitle group reference if we have subtitles but no existing reference
+      if line.hasSuffix(",") {
+        modifiedLine = line + "SUBTITLES=\"\(Self.subtitleGroupID)\""
+      } else {
+        modifiedLine = line + ",SUBTITLES=\"\(Self.subtitleGroupID)\""
+      }
+    }
+
+    return modifiedLine
+  }
+
+  private func createSubtitleTrackEntry(for subtitle: NativeExternalSubtitle, index: Int)
+    -> String
+  {
+    let subtitleM3U8URI = "\(Self.subtitleScheme)://\(index)/subtitle.m3u8"
+
+    return
+      "#EXT-X-MEDIA:TYPE=SUBTITLES,GROUP-ID=\"\(Self.subtitleGroupID)\",NAME=\"\(subtitle.label)\",DEFAULT=NO,AUTOSELECT=NO,FORCED=NO,LANGUAGE=\"\(subtitle.language)\",URI=\"\(subtitleM3U8URI)\""
+  }
+}
+
+// MARK: - AVAssetResourceLoaderDelegate
+
+extension HLSSubtitleInjector: AVAssetResourceLoaderDelegate {
+  func resourceLoader(
+    _ resourceLoader: AVAssetResourceLoader,
+    shouldWaitForLoadingOfRequestedResource loadingRequest:
+      AVAssetResourceLoadingRequest
+  ) -> Bool {
+
+    guard let url = loadingRequest.request.url else {
+      return false
+    }
+
+    switch url.scheme {
+    case Self.customScheme:
+      return handleMainManifest(url: url, loadingRequest: loadingRequest)
+    case Self.subtitleScheme:
+      return handleSubtitleM3U8(url: url, loadingRequest: loadingRequest)
+    default:
+      return false
+    }
+  }
+
+  private func handleMainManifest(url: URL, loadingRequest: AVAssetResourceLoadingRequest) -> Bool {
+    guard url.path.hasSuffix(".m3u8") else {
+      return false
+    }
+
+    Task {
+      do {
+        let modifiedContent = try await getModifiedManifestContent()
+
+        guard let data = modifiedContent.data(using: .utf8) else {
+          throw SourceError.invalidUri(uri: "Failed to encode manifest content")
+            .error()
+        }
+
+        if let contentRequest = loadingRequest.contentInformationRequest {
+          contentRequest.contentType = "application/x-mpegURL"
+          contentRequest.contentLength = Int64(data.count)
+          contentRequest.isByteRangeAccessSupported = true
+        }
+
+        if let dataRequest = loadingRequest.dataRequest {
+          let requestedData: Data
+
+          if dataRequest.requestedOffset > 0 || dataRequest.requestedLength > 0 {
+            let offset = Int(dataRequest.requestedOffset)
+            let length =
+              dataRequest.requestedLength > 0
+              ? min(Int(dataRequest.requestedLength), data.count - offset)
+              : data.count - offset
+
+            if offset < data.count && length > 0 {
+              requestedData = data.subdata(in: offset..<(offset + length))
+            } else {
+              requestedData = Data()
+            }
+          } else {
+            requestedData = data
+          }
+
+          dataRequest.respond(with: requestedData)
+        }
+
+        loadingRequest.finishLoading()
+      } catch {
+        loadingRequest.finishLoading(with: error)
+      }
+    }
+
+    return true
+  }
+
+  private func handleSubtitleM3U8(url: URL, loadingRequest: AVAssetResourceLoadingRequest) -> Bool {
+    guard let indexString = url.host, let index = Int(indexString) else {
+      return false
+    }
+
+    guard index < externalSubtitles.count else {
+      return false
+    }
+
+    let subtitle = externalSubtitles[index]
+
+    Task {
+      do {
+        guard let subtitleURL = URL(string: subtitle.uri) else {
+          throw SourceError.invalidUri(uri: "Invalid subtitle URI: \(subtitle.uri)").error()
+        }
+
+        let (vttData, response) = try await URLSession.shared.data(from: subtitleURL)
+
+        guard let httpResponse = response as? HTTPURLResponse,
+          200...299 ~= httpResponse.statusCode
+        else {
+          throw SourceError.invalidUri(uri: "Subtitle request failed with status: \(response)")
+            .error()
+        }
+
+        guard let vttString = String(data: vttData, encoding: .utf8) else {
+          throw SourceError.invalidUri(uri: "Failed to decode VTT content").error()
+        }
+
+        let duration = extractDurationFromVTT(vttString)
+
+        let m3u8Wrapper = """
+          #EXTM3U
+          #EXT-X-VERSION:3
+          #EXT-X-MEDIA-SEQUENCE:1
+          #EXT-X-PLAYLIST-TYPE:VOD
+          #EXT-X-ALLOW-CACHE:NO
+          #EXT-X-TARGETDURATION:\(Int(duration))
+          #EXTINF:\(String(format: "%.3f", duration)), no desc
+          \(subtitle.uri)
+          #EXT-X-ENDLIST
+          """
+
+        guard let m3u8Data = m3u8Wrapper.data(using: .utf8) else {
+          throw SourceError.invalidUri(uri: "Failed to create M3U8 wrapper").error()
+        }
+
+        if let contentRequest = loadingRequest.contentInformationRequest {
+          contentRequest.contentType = "application/x-mpegURL"
+          contentRequest.contentLength = Int64(m3u8Data.count)
+          contentRequest.isByteRangeAccessSupported = true
+        }
+
+        if let dataRequest = loadingRequest.dataRequest {
+          dataRequest.respond(with: m3u8Data)
+        }
+
+        loadingRequest.finishLoading()
+      } catch {
+        loadingRequest.finishLoading(with: error)
+      }
+    }
+
+    return true
+  }
+
+  private func extractDurationFromVTT(_ vttString: String) -> Double {
+    // Extract duration from VTT timestamps (similar to the PR approach)
+    let timestampPattern = #"(?:(\d+):)?(\d+):([\d\.]+)"#
+
+    guard let regex = try? NSRegularExpression(pattern: timestampPattern, options: []) else {
+      return 60.0  // Default fallback
+    }
+
+    let matches = regex.matches(
+      in: vttString,
+      options: [],
+      range: NSRange(location: 0, length: vttString.utf16.count)
+    )
+
+    guard let lastMatch = matches.last,
+      let range = Range(lastMatch.range, in: vttString)
+    else {
+      return 60.0  // Default fallback
+    }
+
+    let lastTimestampString = String(vttString[range])
+    let components = lastTimestampString.components(separatedBy: ":").reversed()
+      .compactMap { Double($0) }
+      .enumerated()
+      .map { pow(60.0, Double($0.offset)) * $0.element }
+      .reduce(0, +)
+
+    return max(components, 1.0)  // Ensure at least 1 second
+  }
+
+  func resourceLoader(
+    _ resourceLoader: AVAssetResourceLoader,
+    didCancel loadingRequest: AVAssetResourceLoadingRequest
+  ) {
+  }
+}

package/ios/core/NowPlayingInfoCenterManager.swift

@@ -0,0 +1,323 @@
+import Foundation
+import MediaPlayer
+
+class NowPlayingInfoCenterManager {
+  static let shared = NowPlayingInfoCenterManager()
+
+  private let SEEK_INTERVAL_SECONDS: Double = 10
+
+  private weak var currentPlayer: AVPlayer?
+  private var players = NSHashTable<AVPlayer>.weakObjects()
+
+  private var observers: [Int: NSKeyValueObservation] = [:]
+  private var playbackObserver: Any?
+
+  private var playTarget: Any?
+  private var pauseTarget: Any?
+  private var skipForwardTarget: Any?
+  private var skipBackwardTarget: Any?
+  private var playbackPositionTarget: Any?
+  private var seekTarget: Any?
+  private var togglePlayPauseTarget: Any?
+
+  private let remoteCommandCenter = MPRemoteCommandCenter.shared()
+
+  var receivingRemoteControlEvents = false {
+    didSet {
+      if receivingRemoteControlEvents {
+        DispatchQueue.main.async {
+          VideoManager.shared.setRemoteControlEventsActive(true)
+          UIApplication.shared.beginReceivingRemoteControlEvents()
+        }
+      } else {
+        DispatchQueue.main.async {
+          UIApplication.shared.endReceivingRemoteControlEvents()
+          VideoManager.shared.setRemoteControlEventsActive(false)
+        }
+      }
+    }
+  }
+
+  deinit {
+    cleanup()
+  }
+
+  func registerPlayer(player: AVPlayer) {
+    if players.contains(player) {
+      return
+    }
+
+    if receivingRemoteControlEvents == false {
+      receivingRemoteControlEvents = true
+    }
+
+    if let oldObserver = observers[player.hashValue] {
+      oldObserver.invalidate()
+    }
+
+    observers[player.hashValue] = observePlayers(player: player)
+    players.add(player)
+
+    if currentPlayer == nil {
+      setCurrentPlayer(player: player)
+    }
+  }
+
+  func removePlayer(player: AVPlayer) {
+    if !players.contains(player) {
+      return
+    }
+
+    if let observer = observers[player.hashValue] {
+      observer.invalidate()
+    }
+
+    observers.removeValue(forKey: player.hashValue)
+    players.remove(player)
+
+    if currentPlayer == player {
+      currentPlayer = nil
+      updateNowPlayingInfo()
+    }
+
+    if players.allObjects.isEmpty {
+      cleanup()
+    }
+  }
+
+  public func cleanup() {
+    observers.removeAll()
+    players.removeAllObjects()
+
+    if let playbackObserver {
+      currentPlayer?.removeTimeObserver(playbackObserver)
+    }
+
+    invalidateCommandTargets()
+
+    MPNowPlayingInfoCenter.default().nowPlayingInfo = [:]
+    receivingRemoteControlEvents = false
+  }
+
+  private func setCurrentPlayer(player: AVPlayer) {
+    if player == currentPlayer {
+      return
+    }
+
+    if let playbackObserver {
+      currentPlayer?.removeTimeObserver(playbackObserver)
+    }
+
+    currentPlayer = player
+    registerCommandTargets()
+
+    updateNowPlayingInfo()
+    playbackObserver = player.addPeriodicTimeObserver(
+      forInterval: CMTime(value: 1, timescale: 4),
+      queue: .global(),
+      using: { [weak self] _ in
+        self?.updateNowPlayingInfo()
+      }
+    )
+  }
+
+  private func registerCommandTargets() {
+    invalidateCommandTargets()
+
+    playTarget = remoteCommandCenter.playCommand.addTarget { [weak self] _ in
+      guard let self, let player = self.currentPlayer else {
+        return .commandFailed
+      }
+
+      if player.rate == 0 {
+        player.play()
+      }
+
+      return .success
+    }
+
+    pauseTarget = remoteCommandCenter.pauseCommand.addTarget { [weak self] _ in
+      guard let self, let player = self.currentPlayer else {
+        return .commandFailed
+      }
+
+      if player.rate != 0 {
+        player.pause()
+      }
+
+      return .success
+    }
+
+    skipBackwardTarget = remoteCommandCenter.skipBackwardCommand.addTarget {
+      [weak self] _ in
+      guard let self, let player = self.currentPlayer else {
+        return .commandFailed
+      }
+      let newTime =
+        player.currentTime()
+        - CMTime(seconds: self.SEEK_INTERVAL_SECONDS, preferredTimescale: .max)
+      player.seek(to: newTime)
+      return .success
+    }
+
+    skipForwardTarget = remoteCommandCenter.skipForwardCommand.addTarget {
+      [weak self] _ in
+      guard let self, let player = self.currentPlayer else {
+        return .commandFailed
+      }
+
+      let newTime =
+        player.currentTime()
+        + CMTime(seconds: self.SEEK_INTERVAL_SECONDS, preferredTimescale: .max)
+      player.seek(to: newTime)
+      return .success
+    }
+
+    playbackPositionTarget = remoteCommandCenter.changePlaybackPositionCommand
+      .addTarget { [weak self] event in
+        guard let self, let player = self.currentPlayer else {
+          return .commandFailed
+        }
+        if let event = event as? MPChangePlaybackPositionCommandEvent {
+          player.seek(
+            to: CMTime(seconds: event.positionTime, preferredTimescale: .max)
+          )
+          return .success
+        }
+        return .commandFailed
+      }
+
+    // Handler for togglePlayPauseCommand, sent by Apple's Earpods wired headphones
+    togglePlayPauseTarget = remoteCommandCenter.togglePlayPauseCommand.addTarget
+    { [weak self] _ in
+      guard let self, let player = self.currentPlayer else {
+        return .commandFailed
+      }
+
+      if player.rate == 0 {
+        player.play()
+      } else {
+        player.pause()
+      }
+
+      return .success
+    }
+  }
+
+  private func invalidateCommandTargets() {
+    remoteCommandCenter.playCommand.removeTarget(playTarget)
+    remoteCommandCenter.pauseCommand.removeTarget(pauseTarget)
+    remoteCommandCenter.skipForwardCommand.removeTarget(skipForwardTarget)
+    remoteCommandCenter.skipBackwardCommand.removeTarget(skipBackwardTarget)
+    remoteCommandCenter.changePlaybackPositionCommand.removeTarget(
+      playbackPositionTarget
+    )
+    remoteCommandCenter.togglePlayPauseCommand.removeTarget(
+      togglePlayPauseTarget
+    )
+  }
+
+  public func updateNowPlayingInfo() {
+    guard let player = currentPlayer, let currentItem = player.currentItem
+    else {
+      invalidateCommandTargets()
+      MPNowPlayingInfoCenter.default().nowPlayingInfo = [:]
+      return
+    }
+
+    // commonMetadata is metadata from asset, externalMetadata is custom metadata set by user
+    // externalMetadata should override commonMetadata to allow override metadata from source
+    // When the metadata has the tag "iTunSMPB" or "iTunNORM" then the metadata is not converted correctly and comes [nil, nil, ...]
+    // This leads to a crash of the app
+    let metadata: [AVMetadataItem] = {
+
+      let common = processMetadataItems(currentItem.asset.commonMetadata)
+      let external = processMetadataItems(currentItem.externalMetadata)
+
+      return Array(common.merging(external) { _, new in new }.values)
+    }()
+
+    let titleItem =
+      AVMetadataItem.metadataItems(
+        from: metadata,
+        filteredByIdentifier: .commonIdentifierTitle
+      ).first?.stringValue ?? ""
+
+    let artistItem =
+      AVMetadataItem.metadataItems(
+        from: metadata,
+        filteredByIdentifier: .commonIdentifierArtist
+      ).first?.stringValue ?? ""
+
+    // I have some issue with this - setting artworkItem when it not set dont return nil but also is crashing application
+    // this is very hacky workaround for it
+    let imgData = AVMetadataItem.metadataItems(
+      from: metadata,
+      filteredByIdentifier: .commonIdentifierArtwork
+    ).first?.dataValue
+    let image = imgData.flatMap { UIImage(data: $0) } ?? UIImage()
+    let artworkItem = MPMediaItemArtwork(boundsSize: image.size) { _ in image }
+
+    let newNowPlayingInfo: [String: Any] = [
+      MPMediaItemPropertyTitle: titleItem,
+      MPMediaItemPropertyArtist: artistItem,
+      MPMediaItemPropertyArtwork: artworkItem,
+      MPMediaItemPropertyPlaybackDuration: currentItem.duration.seconds,
+      MPNowPlayingInfoPropertyElapsedPlaybackTime: currentItem.currentTime()
+        .seconds.rounded(),
+      MPNowPlayingInfoPropertyPlaybackRate: player.rate,
+      MPNowPlayingInfoPropertyIsLiveStream: CMTIME_IS_INDEFINITE(
+        currentItem.asset.duration
+      ),
+    ]
+    let currentNowPlayingInfo =
+      MPNowPlayingInfoCenter.default().nowPlayingInfo ?? [:]
+
+    MPNowPlayingInfoCenter.default().nowPlayingInfo =
+      currentNowPlayingInfo.merging(newNowPlayingInfo) { _, new in new }
+  }
+
+  private func findNewCurrentPlayer() {
+    if let newPlayer = players.allObjects.first(where: {
+      $0.rate != 0
+    }) {
+      setCurrentPlayer(player: newPlayer)
+    }
+  }
+
+  // We will observe players rate to find last active player that info will be displayed
+  private func observePlayers(player: AVPlayer) -> NSKeyValueObservation {
+    return player.observe(\.rate) { [weak self] player, change in
+      guard let self else { return }
+
+      let rate = change.newValue
+
+      // case where there is new player that is not paused
+      // In this case event is triggered by non currentPlayer
+      if rate != 0 && self.currentPlayer != player {
+        self.setCurrentPlayer(player: player)
+        return
+      }
+
+      // case where currentPlayer was paused
+      // In this case event is triggered by currentPlayer
+      if rate == 0 && self.currentPlayer == player {
+        self.findNewCurrentPlayer()
+      }
+    }
+  }
+
+  private func processMetadataItems(_ items: [AVMetadataItem]) -> [String:
+    AVMetadataItem]
+  {
+    var result = [String: AVMetadataItem]()
+
+    for item in items {
+      if let id = item.identifier?.rawValue, !id.isEmpty, result[id] == nil {
+        result[id] = item
+      }
+    }
+
+    return result
+  }
+}