@capgo/capacitor-video-player 8.1.16 → 8.1.18

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

@@ -38,7 +38,7 @@ import java.util.Map;
 )
 public class VideoPlayerPlugin extends Plugin {
 
-    private final String pluginVersion = "8.1.16";
+    private final String pluginVersion = "8.1.18";
 
     // 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

@@ -28,6 +28,9 @@ class FullscreenVideoPlayer: NSObject {
     private var fairplayContentKeySpcUrl: String?
     private var contentKeySession: AVContentKeySession?
     private var castController: VideoPlayerCastController?
+    private weak var presentingViewController: UIViewController?
+    private var subtitleUrl: String?
+    private var subtitleLanguage: String?
 
     init(
         playerId: String,
@@ -41,6 +44,8 @@ class FullscreenVideoPlayer: NSObject {
         title: String? = nil,
         smallTitle: String? = nil,
         artwork: String? = nil,
+        subtitleUrl: String? = nil,
+        subtitleLanguage: String? = nil,
         fairplayCertificateUrl: String? = nil,
         fairplayContentKeySpcUrl: String? = nil
     ) {
@@ -55,19 +60,41 @@ class FullscreenVideoPlayer: NSObject {
         self.title = title
         self.smallTitle = smallTitle
         self.artwork = artwork
+        self.subtitleUrl = subtitleUrl
+        self.subtitleLanguage = subtitleLanguage
         self.fairplayCertificateUrl = fairplayCertificateUrl
         self.fairplayContentKeySpcUrl = fairplayContentKeySpcUrl
         super.init()
     }
 
-    func setupPlayer() {
+    func setupPlayer(completion: @escaping () -> Void) {
         guard let url = URL(string: videoUrl) else {
+            completion()
+            return
+        }
+
+        let asset = makeVideoAsset(url: url)
+
+        guard let subtitleUrlString = subtitleUrl,
+              !subtitleUrlString.isEmpty,
+              let subtitleURL = URL(string: subtitleUrlString) else {
+            configurePlayer(with: AVPlayerItem(asset: asset))
+            completion()
             return
         }
 
+        Task {
+            let item = await createPlayerItem(videoAsset: asset, subtitleURL: subtitleURL)
+            await MainActor.run {
+                self.configurePlayer(with: item)
+                completion()
+            }
+        }
+    }
+
+    private func makeVideoAsset(url: URL) -> AVURLAsset {
         let asset = AVURLAsset(url: url)
 
-        // Configure FairPlay DRM if certificate URL is provided
         if let certUrl = fairplayCertificateUrl, !certUrl.isEmpty {
             let session = AVContentKeySession(keySystem: .fairPlayStreaming)
             session.setDelegate(self, queue: DispatchQueue.global(qos: .default))
@@ -75,23 +102,112 @@ class FullscreenVideoPlayer: NSObject {
             self.contentKeySession = session
         }
 
-        // Create player item with asset
-        playerItem = AVPlayerItem(asset: asset)
+        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
+            )
+        }
+    }
 
-        // Create player
+    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)
         player?.rate = rate
 
-        // Create player view controller
         playerViewController = AVPlayerViewController()
         playerViewController?.player = player
         playerViewController?.showsPlaybackControls = showControls
-
-        // Picture in Picture support
         playerViewController?.allowsPictureInPicturePlayback = pipEnabled
-        setupChromecast()
+        if pipEnabled {
+            playerViewController?.delegate = self
+        }
 
-        // Setup observers
+        setupChromecast()
         setupObservers()
     }
 
@@ -188,6 +304,7 @@ class FullscreenVideoPlayer: NSObject {
             return
         }
 
+        presentingViewController = viewController
         viewController.present(playerVC, animated: true) {
             self.play()
             completion()
@@ -346,6 +463,36 @@ class FullscreenVideoPlayer: NSObject {
     }
 }
 
+// MARK: - AVPlayerViewControllerDelegate (Picture in Picture)
+
+extension FullscreenVideoPlayer: AVPlayerViewControllerDelegate {
+    func playerViewControllerShouldAutomaticallyDismissAtPictureInPictureStart(
+        _ playerViewController: AVPlayerViewController
+    ) -> Bool {
+        false
+    }
+
+    func playerViewController(
+        _ playerViewController: AVPlayerViewController,
+        restoreUserInterfaceForPictureInPictureStopWithCompletionHandler completionHandler: @escaping (Bool) -> Void
+    ) {
+        guard let presentingViewController else {
+            completionHandler(false)
+            return
+        }
+
+        if playerViewController.presentingViewController == nil {
+            DispatchQueue.main.async {
+                presentingViewController.present(playerViewController, animated: false) {
+                    completionHandler(true)
+                }
+            }
+        } else {
+            completionHandler(true)
+        }
+    }
+}
+
 // MARK: - AVContentKeySessionDelegate (FairPlay DRM)
 
 extension FullscreenVideoPlayer: AVContentKeySessionDelegate {

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.16"
+    private let pluginVersion: String = "8.1.18"
     public let identifier = "VideoPlayerPlugin"
     public let jsName = "VideoPlayer"
     public let pluginMethods: [CAPPluginMethod] = [
@@ -79,6 +79,8 @@ extension VideoPlayerPlugin {
         let title = call.getString("title")
         let smallTitle = call.getString("smallTitle")
         let artwork = call.getString("artwork")
+        let subtitle = call.getString("subtitle")
+        let language = call.getString("language")
 
         // Extract FairPlay DRM options if provided
         let drm = call.getObject("drm")
@@ -99,6 +101,8 @@ extension VideoPlayerPlugin {
             title: title,
             smallTitle: smallTitle,
             artwork: artwork,
+            subtitleUrl: subtitle,
+            subtitleLanguage: language,
             fairplayCertificateUrl: fairplayCertificateUrl,
             fairplayContentKeySpcUrl: fairplayContentKeySpcUrl
         )
@@ -114,19 +118,20 @@ extension VideoPlayerPlugin {
                 return
             }
 
-            player.setupPlayer()
-            self.configureCallbacks(for: player, playerId: playerId)
+            player.setupPlayer {
+                self.configureCallbacks(for: player, playerId: playerId)
 
-            // Store player
-            self.videoPlayers[playerId] = player
-            self.currentPlayerId = playerId
+                // Store player
+                self.videoPlayers[playerId] = player
+                self.currentPlayerId = playerId
 
-            player.present(on: viewController) {
-                call.resolve([
-                    "result": true,
-                    "method": "initPlayer",
-                    "value": playerId
-                ])
+                player.present(on: viewController) {
+                    call.resolve([
+                        "result": true,
+                        "method": "initPlayer",
+                        "value": playerId
+                    ])
+                }
             }
         }
     }

package/package.json

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