@capgo/capacitor-video-player 8.2.1 → 8.2.3

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

@@ -156,6 +156,7 @@ public class FullscreenExoPlayerFragment extends Fragment {
     private Uri uri = null;
     private Uri sturi = null;
     private List<Uri> subtitleUris = new ArrayList<>();
+    private List<String> subtitleLanguages = new ArrayList<>();
     private ProgressBar Pbar;
     private View view;
     private ImageButton closeBtn;
@@ -178,7 +179,7 @@ public class FullscreenExoPlayerFragment extends Fragment {
     private String stBackColor = "";
     private Integer stFontSize = 16;
     private boolean isInPictureInPictureMode = false;
-    private TrackSelector trackSelector;
+    private DefaultTrackSelector trackSelector;
     // Current playback position (in milliseconds).
     private int mCurrentPosition;
     private int mDuration;
@@ -400,10 +401,12 @@ public class FullscreenExoPlayerFragment extends Fragment {
         if (!isInternal) {
             uri = Uri.parse(videoPath);
             subtitleUris = new ArrayList<>();
+            subtitleLanguages = new ArrayList<>();
             if (subtitleTracks != null) {
                 for (VideoSubtitleTrack track : subtitleTracks) {
                     if (track != null && track.url != null && !track.url.isEmpty()) {
                         subtitleUris.add(Uri.parse(track.url));
+                        subtitleLanguages.add(track.language != null ? track.language : "");
                     }
                 }
             }
@@ -411,6 +414,7 @@ public class FullscreenExoPlayerFragment extends Fragment {
             if (sturi == null && subTitle != null && !subTitle.isEmpty()) {
                 sturi = Uri.parse(subTitle);
                 subtitleUris.add(sturi);
+                subtitleLanguages.add(language != null ? language : "en");
             }
 
             stForeColor = subTitleOptions != null && subTitleOptions.has("foregroundColor")
@@ -892,6 +896,12 @@ public class FullscreenExoPlayerFragment extends Fragment {
             DefaultBandwidthMeter bandwidthMeter = new DefaultBandwidthMeter.Builder(context).build();
             ExoTrackSelection.Factory videoTrackSelectionFactory = new AdaptiveTrackSelection.Factory();
             trackSelector = new DefaultTrackSelector(context, videoTrackSelectionFactory);
+            if (!subtitleUris.isEmpty()) {
+                String preferred = languageForTrack(0);
+                trackSelector.setParameters(
+                    trackSelector.buildUponParameters().setPreferredTextLanguage(preferred).setSelectUndeterminedTextLanguage(true)
+                );
+            }
             LoadControl loadControl = new DefaultLoadControl();
             player = new ExoPlayer.Builder(context)
                 .setSeekBackIncrementMs(10000)
@@ -946,11 +956,10 @@ public class FullscreenExoPlayerFragment extends Fragment {
 
     private void updateSubtitleButtonVisibility(Tracks tracks) {
         if (styledPlayerView == null) return;
-        if (sturi != null) {
-            styledPlayerView.setShowSubtitleButton(true);
-            return;
-        }
-        styledPlayerView.setShowSubtitleButton(hasSupportedTextTrack(tracks));
+        boolean hasSidecar = !subtitleUris.isEmpty() || sturi != null;
+        boolean hasText = hasSidecar || hasSupportedTextTrack(tracks);
+        // CC button opens ExoPlayer's text-track picker when multiple languages exist.
+        styledPlayerView.setShowSubtitleButton(hasText);
     }
 
     private boolean hasSupportedTextTrack(Tracks tracks) {
@@ -1622,8 +1631,9 @@ public class FullscreenExoPlayerFragment extends Fragment {
     }
 
     private String languageForTrack(int index) {
-        if (subtitleTracks != null && index >= 0 && index < subtitleTracks.size()) {
-            String trackLanguage = subtitleTracks.get(index).language;
+        // subtitleLanguages is built in lockstep with subtitleUris — never re-index raw subtitleTracks.
+        if (index >= 0 && index < subtitleLanguages.size()) {
+            String trackLanguage = subtitleLanguages.get(index);
             if (trackLanguage != null && !trackLanguage.isEmpty()) {
                 return trackLanguage;
             }

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

@@ -46,7 +46,7 @@ import org.json.JSONObject;
 )
 public class VideoPlayerPlugin extends Plugin {
 
-    private final String pluginVersion = "8.2.1";
+    private final String pluginVersion = "8.2.3";
 
     // 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

@@ -81,7 +81,7 @@ class FullscreenVideoPlayer: NSObject {
     }
 
     func setupPlayer(completion: @escaping () -> Void) {
-        guard let url = URL(string: videoUrl) else {
+        guard let url = Self.resolveMediaURL(videoUrl) else {
             completion()
             return
         }
@@ -100,8 +100,16 @@ class FullscreenVideoPlayer: NSObject {
             return
         }
 
-        if HLSVideoAssetFactory.isHLSStream(url) {
-            let asset = makeVideoAsset(url: url, subtitleTracks: subtitleTracks)
+        // Prefer the resource-loader path when makeAsset can safely wrap the stream
+        // (HLS / remote progressive). Local progressive file:// sources return a nil
+        // loader and must use composition so playback still starts (#78).
+        let assetResult = HLSVideoAssetFactory.makeAsset(
+            videoURL: url,
+            subtitleTracks: subtitleTracks
+        )
+        hlsResourceLoader = assetResult.resourceLoader
+        if assetResult.resourceLoader != nil {
+            let asset = applyFairPlayIfNeeded(to: assetResult.asset)
             configurePlayer(with: AVPlayerItem(asset: asset))
             completion()
             return
@@ -120,14 +128,27 @@ class FullscreenVideoPlayer: NSObject {
         }
     }
 
+    private static func resolveMediaURL(_ raw: String) -> URL? {
+        guard !raw.isEmpty else { return nil }
+        if let parsed = URL(string: raw), parsed.scheme != nil {
+            return parsed
+        }
+        if raw.hasPrefix("/") {
+            return URL(fileURLWithPath: raw)
+        }
+        return URL(string: raw)
+    }
+
     private func makeVideoAsset(url: URL, subtitleTracks: [VideoSubtitleTrack]) -> AVURLAsset {
         let result = HLSVideoAssetFactory.makeAsset(
             videoURL: url,
             subtitleTracks: subtitleTracks
         )
         hlsResourceLoader = result.resourceLoader
-        let asset = result.asset
+        return applyFairPlayIfNeeded(to: result.asset)
+    }
 
+    private func applyFairPlayIfNeeded(to asset: AVURLAsset) -> AVURLAsset {
         if let certUrl = fairplayCertificateUrl, !certUrl.isEmpty,
            let spcUrl = fairplayContentKeySpcUrl, !spcUrl.isEmpty {
             let session = AVContentKeySession(keySystem: .fairPlayStreaming)
@@ -135,7 +156,6 @@ class FullscreenVideoPlayer: NSObject {
             session.addContentKeyRecipient(asset)
             self.contentKeySession = session
         }
-
         return asset
     }
 

package/ios/Sources/VideoPlayerPlugin/HLSSubtitleResourceLoader.swift

@@ -24,13 +24,26 @@ enum HLSVideoAssetFactory {
             resolvedTracks.append((url: subtitleURL, language: track.language ?? "en"))
         }
 
-        guard !resolvedTracks.isEmpty, isHLSStream(videoURL) else {
+        // Use the resource loader whenever sidecar subtitles are present so
+        // AVPlayerViewController can expose a native multi-language picker.
+        // AVMutableComposition can play one track but does not reliably expose
+        // selectable legible media-selection options.
+        guard !resolvedTracks.isEmpty else {
+            return (AVURLAsset(url: videoURL), nil)
+        }
+
+        // Local progressive files cannot be wrapped in synthetic HLS playlists:
+        // AVPlayer will not fetch file:// media/subtitle segments from a custom-scheme
+        // master playlist, so playback never becomes ready (#78). Fall back to the
+        // composition path in FullscreenVideoPlayer instead.
+        if videoURL.isFileURL && !isHLSStream(videoURL) {
             return (AVURLAsset(url: videoURL), nil)
         }
 
         let resourceLoader = HLSSubtitleResourceLoader(
             videoURL: videoURL,
-            subtitleTracks: resolvedTracks.map { HLSSubtitleTrack(url: $0.url, language: $0.language) }
+            subtitleTracks: resolvedTracks.map { HLSSubtitleTrack(url: $0.url, language: $0.language) },
+            isProgressive: !isHLSStream(videoURL)
         )
         guard let assetURL = HLSSubtitleResourceLoader.assetURL(for: videoURL) else {
             return (AVURLAsset(url: videoURL), nil)
@@ -47,27 +60,37 @@ struct HLSSubtitleTrack {
     let language: String
 }
 
-/// Injects external WebVTT subtitles into HLS master playlists via AVAssetResourceLoaderDelegate.
-/// AVMutableComposition cannot demux HLS tracks, so sidecar subtitles must be wired through the manifest.
+/// Injects external WebVTT subtitles into playlists via AVAssetResourceLoaderDelegate.
+///
+/// - HLS multivariant playlists: inject `#EXT-X-MEDIA` subtitle tags.
+/// - HLS media playlists: wrap in a synthetic multivariant playlist that references the media playlist.
+/// - Progressive MP4/WebM: synthesize a multivariant + media playlist so multiple sidecar
+///   tracks appear in AVPlayerViewController's subtitle options.
 final class HLSSubtitleResourceLoader: NSObject, AVAssetResourceLoaderDelegate {
     static let videoScheme = "capgohls"
+    static let mediaPlaylistScheme = "capgohls-media"
     static let subtitlePlaylistScheme = "capgohls-sub"
     private static let subtitleGroupID = "capgosubs"
     private static let mpegURLContentType = UTType.m3uPlaylist.identifier
+    private static let progressiveSegmentDuration = 86400.0
 
     private let originalVideoURL: URL
     private let subtitleTracks: [HLSSubtitleTrack]
+    private let isProgressive: Bool
 
     private struct LoadedResource {
         let data: Data
         let contentType: String?
     }
 
-    init(videoURL: URL, subtitleTracks: [HLSSubtitleTrack]) {
+    init(videoURL: URL, subtitleTracks: [HLSSubtitleTrack], isProgressive: Bool = false) {
         self.originalVideoURL = videoURL
         self.subtitleTracks = subtitleTracks
+        self.isProgressive = isProgressive
     }
 
+    deinit {}
+
     static func assetURL(for videoURL: URL) -> URL? {
         guard var components = URLComponents(url: videoURL, resolvingAgainstBaseURL: false) else {
             return nil
@@ -76,6 +99,14 @@ final class HLSSubtitleResourceLoader: NSObject, AVAssetResourceLoaderDelegate {
         return components.url
     }
 
+    static func mediaPlaylistURL(for videoURL: URL) -> URL? {
+        guard var components = URLComponents(url: videoURL, resolvingAgainstBaseURL: false) else {
+            return nil
+        }
+        components.scheme = mediaPlaylistScheme
+        return components.url
+    }
+
     static func subtitlePlaylistURL(for videoURL: URL, index: Int) -> URL? {
         guard var components = URLComponents(url: videoURL, resolvingAgainstBaseURL: false) else {
             return nil
@@ -111,10 +142,25 @@ final class HLSSubtitleResourceLoader: NSObject, AVAssetResourceLoaderDelegate {
         if requestURL.scheme == Self.subtitlePlaylistScheme {
             let index = subtitleIndex(from: requestURL) ?? 0
             let track = subtitleTracks[min(max(index, 0), subtitleTracks.count - 1)]
-            let data = Data(subtitleMediaPlaylist(for: track.url).utf8)
+            let data = Data(Self.subtitleMediaPlaylist(for: track.url).utf8)
             return LoadedResource(data: data, contentType: Self.mpegURLContentType)
         }
 
+        if requestURL.scheme == Self.mediaPlaylistScheme {
+            let data = Data(Self.progressiveMediaPlaylist(for: originalVideoURL).utf8)
+            return LoadedResource(data: data, contentType: Self.mpegURLContentType)
+        }
+
+        if isProgressive {
+            let playlist = Self.multivariantPlaylist(
+                mediaURI: Self.mediaPlaylistURL(for: originalVideoURL)?.absoluteString
+                    ?? originalVideoURL.absoluteString,
+                subtitleTracks: subtitleTracks,
+                videoURL: originalVideoURL
+            )
+            return LoadedResource(data: Data(playlist.utf8), contentType: Self.mpegURLContentType)
+        }
+
         let fetchURL = originalURL(for: requestURL)
         let (data, response) = try await URLSession.shared.data(from: fetchURL)
         if let http = response as? HTTPURLResponse, !(200...299).contains(http.statusCode) {
@@ -123,16 +169,22 @@ final class HLSSubtitleResourceLoader: NSObject, AVAssetResourceLoaderDelegate {
 
         let manifest = String(data: data, encoding: .utf8) ?? ""
 
-        guard hasStreamInfTags(manifest) else {
-            let contentType = Self.contentTypeIdentifier(from: response)
-            return LoadedResource(data: data, contentType: contentType)
+        if hasStreamInfTags(manifest) {
+            let modified = injectSubtitles(
+                into: manifest,
+                baseURL: response.url ?? fetchURL
+            )
+            return LoadedResource(data: Data(modified.utf8), contentType: Self.mpegURLContentType)
         }
 
-        let modified = injectSubtitles(
-            into: manifest,
-            baseURL: response.url ?? fetchURL
+        // Media playlist (no variants): wrap in a multivariant playlist so subtitle tags are selectable.
+        let mediaURI = (response.url ?? fetchURL).absoluteString
+        let playlist = Self.multivariantPlaylist(
+            mediaURI: mediaURI,
+            subtitleTracks: subtitleTracks,
+            videoURL: originalVideoURL
         )
-        return LoadedResource(data: Data(modified.utf8), contentType: Self.mpegURLContentType)
+        return LoadedResource(data: Data(playlist.utf8), contentType: Self.mpegURLContentType)
     }
 
     private func subtitleIndex(from requestURL: URL) -> Int? {
@@ -157,13 +209,6 @@ final class HLSSubtitleResourceLoader: NSObject, AVAssetResourceLoaderDelegate {
         manifest.contains("#EXT-X-STREAM-INF")
     }
 
-    private static func contentTypeIdentifier(from response: URLResponse) -> String? {
-        guard let mimeType = (response as? HTTPURLResponse)?.mimeType else {
-            return nil
-        }
-        return UTType(mimeType: mimeType)?.identifier
-    }
-
     private func absoluteURI(for uri: String, relativeTo baseURL: URL) -> String {
         let trimmed = uri.trimmingCharacters(in: .whitespacesAndNewlines)
         guard let url = URL(string: trimmed, relativeTo: baseURL)?.absoluteURL else {
@@ -172,18 +217,60 @@ final class HLSSubtitleResourceLoader: NSObject, AVAssetResourceLoaderDelegate {
         return url.absoluteString
     }
 
-    private func injectSubtitles(into manifest: String, baseURL: URL) -> String {
-        let mediaTags = subtitleTracks.enumerated().compactMap { index, track -> String? in
-            guard let subtitlePlaylistURI = Self.subtitlePlaylistURL(for: originalVideoURL, index: index)?.absoluteString else {
+    static func multivariantPlaylist(
+        mediaURI: String,
+        subtitleTracks: [HLSSubtitleTrack],
+        videoURL: URL
+    ) -> String {
+        var lines: [String] = ["#EXTM3U", "#EXT-X-VERSION:3"]
+        lines.append(contentsOf: subtitleMediaTags(subtitleTracks: subtitleTracks, videoURL: videoURL))
+        lines.append("#EXT-X-STREAM-INF:BANDWIDTH=2500000,SUBTITLES=\"\(subtitleGroupID)\"")
+        lines.append(mediaURI)
+        return lines.joined(separator: "\n") + "\n"
+    }
+
+    static func progressiveMediaPlaylist(for videoURL: URL) -> String {
+        """
+        #EXTM3U
+        #EXT-X-VERSION:3
+        #EXT-X-TARGETDURATION:\(Int(progressiveSegmentDuration))
+        #EXT-X-MEDIA-SEQUENCE:0
+        #EXT-X-PLAYLIST-TYPE:VOD
+        #EXTINF:\(progressiveSegmentDuration),
+        \(videoURL.absoluteString)
+        #EXT-X-ENDLIST
+        """
+    }
+
+    static func subtitleMediaPlaylist(for subtitleURL: URL) -> String {
+        """
+        #EXTM3U
+        #EXT-X-VERSION:3
+        #EXT-X-TARGETDURATION:\(Int(progressiveSegmentDuration))
+        #EXT-X-MEDIA-SEQUENCE:0
+        #EXT-X-PLAYLIST-TYPE:VOD
+        #EXTINF:\(progressiveSegmentDuration),
+        \(subtitleURL.absoluteString)
+        #EXT-X-ENDLIST
+        """
+    }
+
+    static func subtitleMediaTags(subtitleTracks: [HLSSubtitleTrack], videoURL: URL) -> [String] {
+        subtitleTracks.enumerated().compactMap { index, track -> String? in
+            guard let subtitlePlaylistURI = subtitlePlaylistURL(for: videoURL, index: index)?.absoluteString else {
                 return nil
             }
             let isDefault = index == 0 ? "YES" : "NO"
             let displayName = Locale(identifier: track.language).localizedString(forLanguageCode: track.language)
                 ?? track.language
             return """
-            #EXT-X-MEDIA:TYPE=SUBTITLES,GROUP-ID="\(Self.subtitleGroupID)",NAME="\(displayName)",DEFAULT=\(isDefault),AUTOSELECT=YES,FORCED=NO,LANGUAGE="\(track.language)",URI="\(subtitlePlaylistURI)"
+            #EXT-X-MEDIA:TYPE=SUBTITLES,GROUP-ID="\(subtitleGroupID)",NAME="\(displayName)",DEFAULT=\(isDefault),AUTOSELECT=YES,FORCED=NO,LANGUAGE="\(track.language)",URI="\(subtitlePlaylistURI)"
             """
         }
+    }
+
+    private func injectSubtitles(into manifest: String, baseURL: URL) -> String {
+        let mediaTags = Self.subtitleMediaTags(subtitleTracks: subtitleTracks, videoURL: originalVideoURL)
 
         guard !mediaTags.isEmpty else {
             return manifest
@@ -226,19 +313,6 @@ final class HLSSubtitleResourceLoader: NSObject, AVAssetResourceLoaderDelegate {
         return result.joined(separator: "\n")
     }
 
-    private func subtitleMediaPlaylist(for subtitleURL: URL) -> 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 resource: LoadedResource) {
         if let contentRequest = loadingRequest.contentInformationRequest {
             if let contentType = resource.contentType {

package/ios/Sources/VideoPlayerPlugin/VideoPlayerPlugin.swift

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

package/ios/Sources/VideoPlayerPlugin/VideoSubtitleTrack.swift

@@ -6,6 +6,13 @@ struct VideoSubtitleTrack {
 
     var resolvedURL: URL? {
         guard !url.isEmpty else { return nil }
+        if let parsed = URL(string: url), parsed.scheme != nil {
+            return parsed
+        }
+        // Capacitor filesystem paths sometimes arrive without a file:// scheme.
+        if url.hasPrefix("/") {
+            return URL(fileURLWithPath: url)
+        }
         return URL(string: url)
     }
 }

package/ios/Tests/VideoPlayerPluginTests/HLSSubtitlePlaylistTests.swift

@@ -0,0 +1,91 @@
+import XCTest
+@testable import VideoPlayerPlugin
+
+final class HLSSubtitlePlaylistTests: XCTestCase {
+    func testMultivariantPlaylistIncludesAllSubtitleLanguages() {
+        let videoURL = URL(string: "https://example.com/video.mp4")!
+        let tracks = [
+            HLSSubtitleTrack(url: URL(string: "https://example.com/en.vtt")!, language: "en"),
+            HLSSubtitleTrack(url: URL(string: "https://example.com/fr.vtt")!, language: "fr"),
+            HLSSubtitleTrack(url: URL(string: "https://example.com/es.vtt")!, language: "es")
+        ]
+
+        let playlist = HLSSubtitleResourceLoader.multivariantPlaylist(
+            mediaURI: "capgohls-media://example.com/video.mp4",
+            subtitleTracks: tracks,
+            videoURL: videoURL
+        )
+
+        XCTAssertTrue(playlist.contains("#EXTM3U"))
+        XCTAssertTrue(playlist.contains("LANGUAGE=\"en\""))
+        XCTAssertTrue(playlist.contains("LANGUAGE=\"fr\""))
+        XCTAssertTrue(playlist.contains("LANGUAGE=\"es\""))
+        XCTAssertTrue(playlist.contains("DEFAULT=YES"))
+        XCTAssertTrue(playlist.contains("SUBTITLES=\"capgosubs\""))
+        XCTAssertTrue(playlist.contains("capgohls-media://example.com/video.mp4"))
+        XCTAssertEqual(playlist.components(separatedBy: "TYPE=SUBTITLES").count - 1, 3)
+    }
+
+    func testProgressiveMediaPlaylistPointsAtSourceVideo() {
+        let videoURL = URL(string: "https://example.com/movie.mp4")!
+        let playlist = HLSSubtitleResourceLoader.progressiveMediaPlaylist(for: videoURL)
+        let subtitle = HLSSubtitleResourceLoader.subtitleMediaPlaylist(
+            for: URL(string: "https://example.com/en.vtt")!
+        )
+
+        XCTAssertTrue(playlist.contains("#EXT-X-PLAYLIST-TYPE:VOD"))
+        XCTAssertTrue(playlist.contains(videoURL.absoluteString))
+        XCTAssertTrue(playlist.contains("#EXT-X-ENDLIST"))
+        XCTAssertTrue(playlist.contains("#EXT-X-TARGETDURATION:86400"))
+        XCTAssertTrue(playlist.contains("#EXTINF:86400.0,"))
+        XCTAssertTrue(subtitle.contains("#EXT-X-TARGETDURATION:86400"))
+        XCTAssertTrue(subtitle.contains("#EXTINF:86400.0,"))
+    }
+
+    func testMakeAssetUsesResourceLoaderForProgressiveSubtitles() {
+        let videoURL = URL(string: "https://example.com/movie.mp4")!
+        let tracks = [
+            VideoSubtitleTrack(url: "https://example.com/en.vtt", language: "en"),
+            VideoSubtitleTrack(url: "https://example.com/fr.vtt", language: "fr")
+        ]
+
+        let result = HLSVideoAssetFactory.makeAsset(videoURL: videoURL, subtitleTracks: tracks)
+
+        XCTAssertNotNil(result.resourceLoader)
+        XCTAssertEqual(result.asset.url.scheme, HLSSubtitleResourceLoader.videoScheme)
+    }
+
+    func testMakeAssetSkipsResourceLoaderWithoutSubtitles() {
+        let videoURL = URL(string: "https://example.com/movie.mp4")!
+        let result = HLSVideoAssetFactory.makeAsset(videoURL: videoURL, subtitleTracks: [])
+
+        XCTAssertNil(result.resourceLoader)
+        XCTAssertEqual(result.asset.url, videoURL)
+    }
+
+    func testMakeAssetSkipsResourceLoaderForLocalProgressiveSubtitles() {
+        let videoURL = URL(fileURLWithPath: "/var/mobile/Containers/Data/Application/video.mp4")
+        let tracks = [
+            VideoSubtitleTrack(url: "file:///var/mobile/Containers/Data/Application/subtitles-en.vtt", language: "en"),
+            VideoSubtitleTrack(url: "file:///var/mobile/Containers/Data/Application/subtitles-fr.vtt", language: "fr")
+        ]
+
+        let result = HLSVideoAssetFactory.makeAsset(videoURL: videoURL, subtitleTracks: tracks)
+
+        XCTAssertNil(result.resourceLoader)
+        XCTAssertEqual(result.asset.url, videoURL)
+        XCTAssertEqual(result.asset.url.scheme, "file")
+    }
+
+    func testMakeAssetUsesResourceLoaderForLocalHLSSubtitles() {
+        let videoURL = URL(fileURLWithPath: "/var/mobile/Containers/Data/Application/stream.m3u8")
+        let tracks = [
+            VideoSubtitleTrack(url: "file:///var/mobile/Containers/Data/Application/subtitles-en.vtt", language: "en")
+        ]
+
+        let result = HLSVideoAssetFactory.makeAsset(videoURL: videoURL, subtitleTracks: tracks)
+
+        XCTAssertNotNil(result.resourceLoader)
+        XCTAssertEqual(result.asset.url.scheme, HLSSubtitleResourceLoader.videoScheme)
+    }
+}

package/ios/Tests/VideoPlayerPluginTests/VideoPlayerPluginTests.swift

@@ -3,13 +3,31 @@ import XCTest
 
 class VideoPlayerTests: XCTestCase {
     func testEcho() {
-        // This is an example of a functional test case for a plugin.
-        // Use XCTAssert and related functions to verify your tests produce the correct results.
-
         let implementation = VideoPlayer()
         let value = "Hello, World!"
         let result = implementation.echo(value)
-
         XCTAssertEqual(value, result)
     }
+
+    func testSubtitleTrackParserPrefersSubtitlesArray() {
+        let tracks = VideoSubtitleTrackParser.parse(
+            from: [
+                ["subtitle": "https://example.com/en.vtt", "language": "en"],
+                ["subtitle": "https://example.com/fr.vtt", "language": "fr"]
+            ],
+            legacySubtitle: "https://example.com/legacy.vtt",
+            legacyLanguage: "de"
+        )
+
+        XCTAssertEqual(tracks.count, 2)
+        XCTAssertEqual(tracks[0].url, "https://example.com/en.vtt")
+        XCTAssertEqual(tracks[0].language, "en")
+        XCTAssertEqual(tracks[1].language, "fr")
+    }
+
+    func testSubtitleTrackResolvesBareFilePath() {
+        let track = VideoSubtitleTrack(url: "/var/mobile/Containers/Data/Application/subtitles-en.vtt", language: "en")
+        XCTAssertEqual(track.resolvedURL?.isFileURL, true)
+        XCTAssertEqual(track.resolvedURL?.path, "/var/mobile/Containers/Data/Application/subtitles-en.vtt")
+    }
 }

package/package.json

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