@capgo/capacitor-video-player 8.1.21 → 8.1.22

package/android/src/main/java/com/capgo/videoplayer/VideoPlayerPlugin.java

@@ -39,7 +39,7 @@ import java.util.Map;
 )
 public class VideoPlayerPlugin extends Plugin {
 
-    private final String pluginVersion = "8.1.21";
+    private final String pluginVersion = "8.1.22";
 
     // Permission alias constants
     private static final String PERMISSION_DENIED_ERROR = "Unable to access media videos, user denied permission request";

package/ios/Sources/VideoPlayerPlugin/FullscreenVideoPlayer.swift

@@ -31,6 +31,7 @@ class FullscreenVideoPlayer: NSObject {
     private weak var presentingViewController: UIViewController?
     private var subtitleUrl: String?
     private var subtitleLanguage: String?
+    private var hlsResourceLoader: HLSSubtitleResourceLoader?
 
     init(
         playerId: String,
@@ -73,18 +74,29 @@ class FullscreenVideoPlayer: NSObject {
             return
         }
 
-        let asset = makeVideoAsset(url: url)
-
         guard let subtitleUrlString = subtitleUrl,
               !subtitleUrlString.isEmpty,
               let subtitleURL = URL(string: subtitleUrlString) else {
+            let asset = makeVideoAsset(url: url, subtitleURL: nil)
+            configurePlayer(with: AVPlayerItem(asset: asset))
+            completion()
+            return
+        }
+
+        if HLSVideoAssetFactory.isHLSStream(url) {
+            let asset = makeVideoAsset(url: url, subtitleURL: subtitleURL)
             configurePlayer(with: AVPlayerItem(asset: asset))
             completion()
             return
         }
 
         Task {
-            let item = await createPlayerItem(videoAsset: asset, subtitleURL: subtitleURL)
+            let asset = makeVideoAsset(url: url, subtitleURL: nil)
+            let item = await ProgressiveVideoPlayerItemFactory.createPlayerItem(
+                videoAsset: asset,
+                subtitleURL: subtitleURL,
+                subtitleLanguage: subtitleLanguage
+            )
             await MainActor.run {
                 self.configurePlayer(with: item)
                 completion()
@@ -92,8 +104,14 @@ class FullscreenVideoPlayer: NSObject {
         }
     }
 
-    private func makeVideoAsset(url: URL) -> AVURLAsset {
-        let asset = AVURLAsset(url: url)
+    private func makeVideoAsset(url: URL, subtitleURL: URL?) -> AVURLAsset {
+        let result = HLSVideoAssetFactory.makeAsset(
+            videoURL: url,
+            subtitleURL: subtitleURL,
+            language: subtitleLanguage ?? "en"
+        )
+        hlsResourceLoader = result.resourceLoader
+        let asset = result.asset
 
         if let certUrl = fairplayCertificateUrl, !certUrl.isEmpty {
             let session = AVContentKeySession(keySystem: .fairPlayStreaming)
@@ -105,95 +123,6 @@ class FullscreenVideoPlayer: NSObject {
         return asset
     }
 
-    private func createPlayerItem(videoAsset: AVURLAsset, subtitleURL: URL) async -> AVPlayerItem {
-        let subtitleAsset = AVURLAsset(url: subtitleURL)
-
-        do {
-            let videoDuration = try await videoAsset.load(.duration)
-            let composition = AVMutableComposition()
-
-            try await insertTracks(
-                from: videoAsset,
-                mediaTypes: [.video, .audio],
-                duration: videoDuration,
-                into: composition
-            )
-
-            var subtitleAdded = false
-            let subtitleTracks = try await subtitleAsset.loadTracks(withMediaType: .text)
-            if let subtitleTrack = subtitleTracks.first {
-                let compositionTrack = composition.addMutableTrack(
-                    withMediaType: .text,
-                    preferredTrackID: kCMPersistentTrackID_Invalid
-                )
-                let subtitleDuration = try await subtitleAsset.load(.duration)
-                let duration = CMTimeCompare(subtitleDuration, videoDuration) < 0 ? subtitleDuration : videoDuration
-                try compositionTrack?.insertTimeRange(
-                    CMTimeRange(start: .zero, duration: duration),
-                    of: subtitleTrack,
-                    at: CMTime.zero
-                )
-                subtitleAdded = true
-            }
-
-            let playerItem = AVPlayerItem(asset: composition)
-
-            if subtitleAdded {
-                selectSubtitle(in: playerItem, language: subtitleLanguage)
-            }
-
-            return playerItem
-        } catch {
-            return AVPlayerItem(asset: videoAsset)
-        }
-    }
-
-    private func selectSubtitle(in playerItem: AVPlayerItem, language: String?) {
-        guard let group = playerItem.asset.mediaSelectionGroup(forMediaCharacteristic: .legible) else {
-            return
-        }
-
-        let selectedOption = selectSubtitleOption(in: group, language: language)
-            ?? group.defaultOption
-            ?? group.options.first
-
-        if let selectedOption {
-            playerItem.select(selectedOption, in: group)
-        }
-    }
-
-    private func insertTracks(
-        from asset: AVURLAsset,
-        mediaTypes: [AVMediaType],
-        duration: CMTime,
-        into composition: AVMutableComposition
-    ) async throws {
-        for mediaType in mediaTypes {
-            let tracks = try await asset.loadTracks(withMediaType: mediaType)
-            guard let sourceTrack = tracks.first else { continue }
-
-            let compositionTrack = composition.addMutableTrack(
-                withMediaType: mediaType,
-                preferredTrackID: kCMPersistentTrackID_Invalid
-            )
-            try compositionTrack?.insertTimeRange(
-                CMTimeRange(start: .zero, duration: duration),
-                of: sourceTrack,
-                at: .zero
-            )
-        }
-    }
-
-    private func selectSubtitleOption(in group: AVMediaSelectionGroup, language: String?) -> AVMediaSelectionOption? {
-        guard let language, !language.isEmpty else { return nil }
-
-        return group.options.first { option in
-            option.extendedLanguageTag == language
-                || option.locale?.identifier == language
-                || option.locale?.languageCode == language
-        }
-    }
-
     private func configurePlayer(with item: AVPlayerItem) {
         playerItem = item
         player = AVPlayer(playerItem: playerItem)
@@ -323,6 +252,7 @@ class FullscreenVideoPlayer: NSObject {
     private func cleanup() {
         castController?.detach(stopRemoteMedia: false)
         castController = nil
+        hlsResourceLoader = nil
         if let observer = timeObserver {
             player?.removeObserver(self, forKeyPath: "rate")
             player?.removeTimeObserver(observer)

package/ios/Sources/VideoPlayerPlugin/HLSSubtitleResourceLoader.swift

@@ -0,0 +1,185 @@
+import AVFoundation
+import Foundation
+
+enum HLSVideoAssetFactory {
+    static func isHLSStream(_ url: URL) -> Bool {
+        let urlString = url.absoluteString.lowercased()
+        let path = url.path.lowercased()
+
+        return path.hasSuffix(".m3u8")
+            || urlString.contains(".m3u8")
+            || urlString.contains("mpegurl")
+            || urlString.contains("hls_playlist")
+            || urlString.contains("hls_manifest")
+    }
+
+    static func makeAsset(
+        videoURL: URL,
+        subtitleURL: URL?,
+        language: String
+    ) -> (asset: AVURLAsset, resourceLoader: HLSSubtitleResourceLoader?) {
+        guard let subtitleURL, isHLSStream(videoURL) else {
+            return (AVURLAsset(url: videoURL), nil)
+        }
+
+        let resourceLoader = HLSSubtitleResourceLoader(
+            videoURL: videoURL,
+            subtitleURL: subtitleURL,
+            language: language
+        )
+        guard let assetURL = HLSSubtitleResourceLoader.assetURL(for: videoURL) else {
+            return (AVURLAsset(url: videoURL), nil)
+        }
+
+        let asset = AVURLAsset(url: assetURL)
+        asset.resourceLoader.setDelegate(resourceLoader, queue: DispatchQueue.global(qos: .userInitiated))
+        return (asset, resourceLoader)
+    }
+}
+
+/// Injects external WebVTT subtitles into HLS master playlists via AVAssetResourceLoaderDelegate.
+/// AVMutableComposition cannot demux HLS tracks, so sidecar subtitles must be wired through the manifest.
+final class HLSSubtitleResourceLoader: NSObject, AVAssetResourceLoaderDelegate {
+    static let videoScheme = "capgohls"
+    static let subtitlePlaylistScheme = "capgohls-sub"
+    private static let subtitleGroupID = "capgosubs"
+
+    private let originalVideoURL: URL
+    private let subtitleURL: URL
+    private let language: String
+
+    init(videoURL: URL, subtitleURL: URL, language: String) {
+        self.originalVideoURL = videoURL
+        self.subtitleURL = subtitleURL
+        self.language = language
+    }
+
+    static func assetURL(for videoURL: URL) -> URL? {
+        guard var components = URLComponents(url: videoURL, resolvingAgainstBaseURL: false) else {
+            return nil
+        }
+        components.scheme = videoScheme
+        return components.url
+    }
+
+    static func subtitlePlaylistURL(for videoURL: URL) -> URL? {
+        guard var components = URLComponents(url: videoURL, resolvingAgainstBaseURL: false) else {
+            return nil
+        }
+        components.scheme = subtitlePlaylistScheme
+        return components.url
+    }
+
+    func resourceLoader(
+        _ resourceLoader: AVAssetResourceLoader,
+        shouldWaitForLoadingOfRequestedResource loadingRequest: AVAssetResourceLoadingRequest
+    ) -> Bool {
+        guard let requestURL = loadingRequest.request.url else {
+            return false
+        }
+
+        Task {
+            do {
+                let data = try await loadData(for: requestURL)
+                fulfill(loadingRequest, with: data)
+            } catch {
+                loadingRequest.finishLoading(with: error)
+            }
+        }
+
+        return true
+    }
+
+    private func loadData(for requestURL: URL) async throws -> Data {
+        if requestURL.scheme == Self.subtitlePlaylistScheme {
+            return Data(subtitleMediaPlaylist().utf8)
+        }
+
+        let fetchURL = originalURL(for: requestURL)
+        let (data, _) = try await URLSession.shared.data(from: fetchURL)
+        let manifest = String(data: data, encoding: .utf8) ?? ""
+
+        guard hasStreamInfTags(manifest) else {
+            return data
+        }
+
+        guard let subtitlePlaylistURI = Self.subtitlePlaylistURL(for: originalVideoURL)?.absoluteString else {
+            return data
+        }
+
+        let modified = injectSubtitle(into: manifest, subtitlePlaylistURI: subtitlePlaylistURI)
+        return Data(modified.utf8)
+    }
+
+    private func originalURL(for requestURL: URL) -> URL {
+        guard var components = URLComponents(url: requestURL, resolvingAgainstBaseURL: false),
+              components.scheme == Self.videoScheme else {
+            return requestURL
+        }
+
+        components.scheme = originalVideoURL.scheme ?? "https"
+        return components.url ?? originalVideoURL
+    }
+
+    private func hasStreamInfTags(_ manifest: String) -> Bool {
+        manifest.contains("#EXT-X-STREAM-INF")
+    }
+
+    private func injectSubtitle(into manifest: String, subtitlePlaylistURI: String) -> String {
+        let mediaTag = """
+        #EXT-X-MEDIA:TYPE=SUBTITLES,GROUP-ID="\(Self.subtitleGroupID)",NAME="Subtitles",DEFAULT=YES,AUTOSELECT=YES,FORCED=NO,LANGUAGE="\(language)",URI="\(subtitlePlaylistURI)"
+        """
+
+        var lines = manifest.components(separatedBy: .newlines)
+        var result: [String] = []
+        var insertedMediaTag = false
+
+        for line in lines {
+            if line.hasPrefix("#EXT-X-STREAM-INF") {
+                if !insertedMediaTag {
+                    result.append(mediaTag)
+                    insertedMediaTag = true
+                }
+
+                if line.contains("SUBTITLES=") {
+                    result.append(line)
+                } else {
+                    result.append("\(line),SUBTITLES=\"\(Self.subtitleGroupID)\"")
+                }
+                continue
+            }
+
+            result.append(line)
+        }
+
+        if !insertedMediaTag, let extm3uIndex = result.firstIndex(where: { $0.hasPrefix("#EXTM3U") }) {
+            result.insert(mediaTag, at: extm3uIndex + 1)
+        }
+
+        return result.joined(separator: "\n")
+    }
+
+    private func subtitleMediaPlaylist() -> String {
+        """
+        #EXTM3U
+        #EXT-X-VERSION:3
+        #EXT-X-TARGETDURATION:600
+        #EXT-X-MEDIA-SEQUENCE:0
+        #EXT-X-PLAYLIST-TYPE:VOD
+        #EXTINF:600.0,
+        \(subtitleURL.absoluteString)
+        #EXT-X-ENDLIST
+        """
+    }
+
+    private func fulfill(_ loadingRequest: AVAssetResourceLoadingRequest, with data: Data) {
+        if let contentRequest = loadingRequest.contentInformationRequest {
+            contentRequest.contentType = "application/vnd.apple.mpegurl"
+            contentRequest.contentLength = Int64(data.count)
+            contentRequest.isByteRangeAccessSupported = false
+        }
+
+        loadingRequest.dataRequest?.respond(with: data)
+        loadingRequest.finishLoading()
+    }
+}

package/ios/Sources/VideoPlayerPlugin/ProgressiveVideoPlayerItemFactory.swift

@@ -0,0 +1,105 @@
+import AVFoundation
+import Foundation
+
+enum ProgressiveVideoPlayerItemFactory {
+    static func createPlayerItem(
+        videoAsset: AVURLAsset,
+        subtitleURL: URL,
+        subtitleLanguage: String?
+    ) async -> AVPlayerItem {
+        let subtitleAsset = AVURLAsset(url: subtitleURL)
+
+        do {
+            let videoDuration = try await videoAsset.load(.duration)
+            let composition = AVMutableComposition()
+
+            try await insertTracks(
+                from: videoAsset,
+                mediaTypes: [.video, .audio],
+                duration: videoDuration,
+                into: composition
+            )
+
+            let hasPlayableTracks = composition.tracks.contains {
+                $0.mediaType == .video || $0.mediaType == .audio
+            }
+            if !hasPlayableTracks {
+                return AVPlayerItem(asset: videoAsset)
+            }
+
+            var subtitleAdded = false
+            let subtitleTracks = try await subtitleAsset.loadTracks(withMediaType: .text)
+            if let subtitleTrack = subtitleTracks.first {
+                let compositionTrack = composition.addMutableTrack(
+                    withMediaType: .text,
+                    preferredTrackID: kCMPersistentTrackID_Invalid
+                )
+                let subtitleDuration = try await subtitleAsset.load(.duration)
+                let duration = CMTimeCompare(subtitleDuration, videoDuration) < 0 ? subtitleDuration : videoDuration
+                try compositionTrack?.insertTimeRange(
+                    CMTimeRange(start: .zero, duration: duration),
+                    of: subtitleTrack,
+                    at: CMTime.zero
+                )
+                subtitleAdded = true
+            }
+
+            let playerItem = AVPlayerItem(asset: composition)
+
+            if subtitleAdded {
+                selectSubtitle(in: playerItem, language: subtitleLanguage)
+            }
+
+            return playerItem
+        } catch {
+            return AVPlayerItem(asset: videoAsset)
+        }
+    }
+
+    private static func selectSubtitle(in playerItem: AVPlayerItem, language: String?) {
+        guard let group = playerItem.asset.mediaSelectionGroup(forMediaCharacteristic: .legible) else {
+            return
+        }
+
+        let selectedOption = selectSubtitleOption(in: group, language: language)
+            ?? group.defaultOption
+            ?? group.options.first
+
+        if let selectedOption {
+            playerItem.select(selectedOption, in: group)
+        }
+    }
+
+    private static func insertTracks(
+        from asset: AVURLAsset,
+        mediaTypes: [AVMediaType],
+        duration: CMTime,
+        into composition: AVMutableComposition
+    ) async throws {
+        for mediaType in mediaTypes {
+            let tracks = try await asset.loadTracks(withMediaType: mediaType)
+            guard let sourceTrack = tracks.first else { continue }
+
+            let compositionTrack = composition.addMutableTrack(
+                withMediaType: mediaType,
+                preferredTrackID: kCMPersistentTrackID_Invalid
+            )
+            try compositionTrack?.insertTimeRange(
+                CMTimeRange(start: .zero, duration: duration),
+                of: sourceTrack,
+                at: .zero
+            )
+        }
+    }
+
+    private static func selectSubtitleOption(in group: AVMediaSelectionGroup, language: String?) -> AVMediaSelectionOption? {
+        guard let language, !language.isEmpty else { return nil }
+
+        return group.options.first { option in
+            option.extendedLanguageTag == language
+                || option.locale?.identifier == language
+                || option.locale?.languageCode == language
+        }
+    }
+
+}

package/ios/Sources/VideoPlayerPlugin/VideoPlayerPlugin.swift

@@ -8,7 +8,7 @@ import AVKit
  */
 @objc(VideoPlayerPlugin)
 public class VideoPlayerPlugin: CAPPlugin, CAPBridgedPlugin {
-    private let pluginVersion: String = "8.1.21"
+    private let pluginVersion: String = "8.1.22"
     public let identifier = "VideoPlayerPlugin"
     public let jsName = "VideoPlayer"
     public let pluginMethods: [CAPPluginMethod] = [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capgo/capacitor-video-player",
-  "version": "8.1.21",
+  "version": "8.1.22",
   "description": "Capacitor plugin to play video in native player",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",