@picsa/capacitor-video-player 7.1.0

package/ios/Plugin/Extensions/CapacitorVideoPlayerPlugin.File.swift

@@ -0,0 +1,126 @@
+//
+//  CapacitorVideoPlayerPlugin.swift
+//  Plugin
+//
+//  Created by  Quéau Jean Pierre on 30/05/2021.
+//  Copyright © 2021 Max Lynch. All rights reserved.
+//
+
+import Foundation
+
+extension CapacitorVideoPlayerPlugin {
+
+    // MARK: - getURLFromFilePath
+
+    // swiftlint:disable cyclomatic_complexity
+    // swiftlint:disable function_body_length
+    func getURLFromFilePath(filePath: String) -> [String: Any] {
+        var dict: [String: Any] = [:]
+        dict["message"] = ""
+        let docPath: String =
+            NSSearchPathForDirectoriesInDomains(.documentDirectory,
+                                                .userDomainMask,
+                                                true)[0]
+        let appPath: String =
+            NSSearchPathForDirectoriesInDomains(.applicationDirectory,
+                                                .userDomainMask,
+                                                true)[0]
+
+        if String(filePath.prefix(4)) == "http" {
+            if let url = URL(string: filePath) {
+                dict["url"] = url
+                return dict
+            } else {
+                dict["message"] = "cannot convert filePath in URL"
+                return dict
+            }
+        }
+        if String(filePath.prefix(13)) == "public/assets" {
+            if let appFolder = Bundle.main.resourceURL {
+                dict["url"] = appFolder.appendingPathComponent(filePath)
+                return dict
+            } else {
+                dict["message"] = "did not find appFolder"
+                return dict
+            }
+        }
+        if String(filePath.prefix(11)) == "application" {
+            let path: String = String(filePath.dropFirst(12))
+            let vPath: String = docPath.appendingFormat("/\(path)")
+            if !isFileExists(filePath: vPath) {
+                print("*** file does not exist at path \n \(vPath) \n***")
+                let info: [String: Any] = ["dismiss": true]
+                self.notifyListeners("jeepCapVideoPlayerExit", data: info, retainUntilConsumed: true)
+                dict["message"] = "file does not exist"
+                return dict
+            }
+            dict["url"] = URL(fileURLWithPath: vPath)
+            return dict
+        }
+        if String(filePath.prefix(29)) == "file:///var/mobile/Containers" {
+
+            // get the appId from the appPath
+            let pathArray = appPath.components(separatedBy: "Application")
+            let appId: String = pathArray[1].replacingOccurrences(of: "/", with: "")
+            // remove the appId from the given filePath and replace it with the current appId
+            let fPathArray = filePath.components(separatedBy: "Application")
+            if let uPath = URL(string: pathArray[0]) {
+                let fPath = (uPath.appendingPathComponent("Application")
+                                .appendingPathComponent(appId)
+                                .appendingPathComponent(
+                                    String(fPathArray[1].dropFirst(38)))
+                ).absoluteString
+                if !isFileExists(filePath: fPath) {
+                    print("*** file does not exist at path \n \(fPath) \n***")
+                    let info: [String: Any] = ["dismiss": true]
+                    self.notifyListeners("jeepCapVideoPlayerExit", data: info,
+                                         retainUntilConsumed: true)
+                    dict["message"] = "file does not exist"
+                    return dict
+                }
+                dict["url"] = URL(fileURLWithPath: fPath)
+            } else {
+                dict["message"] = "file path not correct"
+            }
+            return dict
+        }
+         if String(filePath.prefix(19)) == "file:///var/mobile/" {
+             let pathArray = appPath.components(separatedBy: "Containers")
+             let fPathArray = filePath.components(separatedBy: "mobile/")
+
+             if let uPath = URL(string: pathArray[0]) {
+                 let fPath = (uPath.appendingPathComponent(
+                                 String(fPathArray[1]))
+                 ).absoluteString
+                 if !isFileExists(filePath: fPath) {
+                     print("*** file does not exist at path \n \(fPath) \n***")
+                     let info: [String: Any] = ["dismiss": true]
+                     self.notifyListeners("jeepCapVideoPlayerExit", data: info,
+                                          retainUntilConsumed: true)
+                     dict["message"] = "file does not exist"
+                     return dict
+                 }
+                 dict["url"] = URL(fileURLWithPath: fPath)
+             } else {
+                 dict["message"] = "file path not correct"
+             }
+             return dict
+        }
+        dict["message"] = "filePath not implemented"
+        return dict
+    }
+    // swiftlint:enable function_body_length
+    // swiftlint:enable cyclomatic_complexity
+
+    // MARK: - isFileExists
+
+    func isFileExists(filePath: String) -> Bool {
+        var ret: Bool = false
+        let fileManager = FileManager.default
+        if fileManager.fileExists(atPath: filePath) {
+            ret = true
+        }
+        return ret
+    }
+
+}

package/ios/Plugin/Extensions/CapacitorVideoPlayerPlugin.Fullscreen.swift

@@ -0,0 +1,94 @@
+//
+//  CapacitorVideoPlayerPlugin.Fullscreen.swift
+//  Plugin
+//
+//  Created by  Quéau Jean Pierre on 30/05/2021.
+//  Copyright © 2021 Max Lynch. All rights reserved.
+//
+
+import Foundation
+import Capacitor
+import AVKit
+
+extension CapacitorVideoPlayerPlugin {
+
+    // MARK: - createVideoPlayerFullScreenView
+
+    // swiftlint:disable function_body_length
+    // swiftlint:disable function_parameter_count
+    func createVideoPlayerFullscreenView(
+        call: CAPPluginCall, videoUrl: URL, rate: Float,
+        exitOnEnd: Bool, loopOnEnd: Bool, pipEnabled: Bool,
+        backModeEnabled: Bool, showControls: Bool,
+        displayMode: String,
+        subTitleUrl: URL?, subTitleLanguage: String?,
+        subTitleOptions: [String: Any]?,
+        headers: [String: String]?, title: String?,
+        smallTitle: String?, artwork: String?) {
+        DispatchQueue.main.async { [weak self] in
+            let playerId: String = self?.fsPlayerId ?? "fullscreen"
+            if let fullscreenView = self?.implementation
+                .createFullscreenPlayer(
+                    playerId: playerId, videoUrl: videoUrl,
+                    rate: rate, exitOnEnd: exitOnEnd, loopOnEnd: loopOnEnd,
+                    pipEnabled: pipEnabled,
+                    showControls: showControls,
+                    displayMode: displayMode,
+                    subTitleUrl: subTitleUrl,
+                    language: subTitleLanguage, headers: headers, options: subTitleOptions,
+                    title: title, smallTitle: smallTitle, artwork: artwork) {
+                self?.videoPlayerFullScreenView = fullscreenView
+                if backModeEnabled {
+                    self?.bgPlayer = self?.videoPlayerFullScreenView?
+                        .videoPlayer.player
+                }
+                guard let videoPlayer: AVPlayerViewController =
+                        self?.videoPlayerFullScreenView?.videoPlayer else {
+                    let error: String = "No videoPlayer available"
+                    print(error)
+                    call.resolve([ "result": false, "method": "createVideoPlayerFullScreenView",
+                                   "message": error])
+                    return
+                }
+                videoPlayer.delegate = self
+                self?.bridge?.viewController?.present(
+                    videoPlayer, animated: true, completion: {
+                        if backModeEnabled {
+                            // add audio session
+                            self?.audioSession = AVAudioSession.sharedInstance()
+                            // Set the audio session category, mode, and options.
+                            do {
+                                try self?.audioSession?
+                                    .setCategory(.playback,
+                                                 mode: .moviePlayback,
+                                                 options: [])
+                                try self?.audioSession?.setActive(true)
+                                call.resolve([
+                                                "result": true,
+                                                "method": "createVideoPlayerFullScreenView",
+                                                "value": true])
+                                return
+                            } catch let error as NSError {
+                                print("Unable to activate audio session:  \(error.localizedDescription)")
+                                call.resolve([
+                                                "result": false,
+                                                "method": "createVideoPlayerFullScreenView",
+                                                "message": error.localizedDescription])
+                                return
+                            }
+                        } else {
+                            call.resolve([
+                                            "result": true,
+                                            "method": "createVideoPlayerFullScreenView",
+                                            "value": true])
+                            return
+                        }
+                    })
+
+            }
+        }
+    }
+    // swiftlint:enable function_parameter_count
+    // swiftlint:enable function_body_length
+
+}

package/ios/Plugin/Extensions/CapacitorVideoPlayerPlugin.Notifications.swift

@@ -0,0 +1,140 @@
+//
+//  CapacitorVideoPlayerPlugin.Notifications.swift
+//  Plugin
+//
+//  Created by  Quéau Jean Pierre on 30/05/2021.
+//  Copyright © 2021 Max Lynch. All rights reserved.
+//
+
+import Foundation
+import MediaPlayer
+
+// MARK: - Handle Notifications
+
+extension CapacitorVideoPlayerPlugin {
+
+    // MARK: - playerItemPlay
+
+    @objc func playerItemPlay(notification: Notification) {
+        guard let info = notification.userInfo as? [String: Any] else { return }
+        DispatchQueue.main.async {
+            self.notifyListeners("jeepCapVideoPlayerPlay", data: info, retainUntilConsumed: true)
+            return
+        }
+    }
+
+    // MARK: - playerItemPause
+
+    @objc func playerItemPause(notification: Notification) {
+        guard let info = notification.userInfo as? [String: Any] else { return }
+        DispatchQueue.main.async {
+            self.notifyListeners("jeepCapVideoPlayerPause", data: info, retainUntilConsumed: true)
+            return
+        }
+    }
+
+    // MARK: - playerItemEnd
+
+    @objc func playerItemEnd(notification: Notification) {
+        guard let info = notification.userInfo as? [String: Any] else { return }
+        DispatchQueue.main.async {
+            self.notifyListeners("jeepCapVideoPlayerEnded", data: info, retainUntilConsumed: true)
+            if self.mode == "fullscreen" {
+                self.playerFullscreenExit()
+            }
+
+            return
+        }
+    }
+
+    // MARK: - playerItemReady
+
+    @objc func playerItemReady(notification: Notification) {
+        guard let info = notification.userInfo as? [String: Any] else { return }
+        guard let playerId = info["fromPlayerId"] as? String else { return}
+        DispatchQueue.main.async {
+            self.notifyListeners("jeepCapVideoPlayerReady", data: info, retainUntilConsumed: true)
+            if self.mode == "fullscreen" && playerId == self.fsPlayerId {
+                if let vPFSV = self.videoPlayerFullScreenView {
+                    vPFSV.play()
+                }
+            }
+            return
+        }
+    }
+
+    // MARK: - playerFullscreenDismiss
+
+    @objc func playerFullscreenDismiss(notification: Notification) {
+
+        var currentTime: Double = 0.0
+        if let playerView = self.videoPlayerFullScreenView {
+            currentTime = playerView.getRealCurrentTime()
+        }
+        let info: [String: Any] = ["dismiss": true, "currentTime": currentTime]
+        DispatchQueue.main.async {
+            if self.mode == "fullscreen" {
+                if let vPFSV = self.videoPlayerFullScreenView {
+                    vPFSV.pause()
+                }
+                self.playerFullscreenExit()
+            }
+            self.notifyListeners("jeepCapVideoPlayerExit", data: info, retainUntilConsumed: true)
+            return
+        }
+    }
+
+    // MARK: - playerFullscreenExit
+
+    func playerFullscreenExit() {
+        if let vPFSV = self.videoPlayerFullScreenView {
+            vPFSV.removeObservers()
+            self.terminateNowPlayingInfo()
+            vPFSV.videoPlayer.player = nil
+            vPFSV.player = nil
+            /*
+            if self.displayMode == "landscape" {
+                vPFSV.videoPlayer = PortraitAVPlayerController()
+            } else if self.displayMode == "portrait" {
+                vPFSV.videoPlayer = LandscapeAVPlayerController()
+            } else {
+                vPFSV.videoPlayer = AllOrientationAVPlayerController()
+            }
+            */
+            self.videoPlayerFullScreenView = nil
+        }
+        if let viewController = self.bridge?.viewController {
+            viewController.dismiss(animated: true, completion: {
+                if self.backModeEnabled {
+                    if let audioSession = self.audioSession {
+                        do {
+                            try audioSession.setActive(false)
+                            self.audioSession = nil
+                        } catch {
+                            let error: String = "playerFullscreenExit: Failed to deactivate audio session category"
+                            print(error)
+                        }
+                    }
+                }
+            })
+        }
+    }
+
+    private func terminateNowPlayingInfo() {
+        if let vPFSV = self.videoPlayerFullScreenView {
+            if let token = vPFSV.periodicTimeObserver {
+                vPFSV.player?.removeTimeObserver(token)
+                vPFSV.periodicTimeObserver = nil
+            }
+            let rcc = MPRemoteCommandCenter.shared()
+            rcc.changePlaybackPositionCommand.isEnabled = false
+            rcc.playCommand.isEnabled = false
+            rcc.pauseCommand.isEnabled = false
+            rcc.skipForwardCommand.isEnabled = false
+            rcc.skipBackwardCommand.isEnabled = false
+            MPNowPlayingInfoCenter.default().nowPlayingInfo = [:]
+            MPNowPlayingInfoCenter.default().nowPlayingInfo = nil
+        }
+    }
+
+}

package/ios/Plugin/Extensions/CapacitorVideoPlayerPlugin.Observers.swift

@@ -0,0 +1,180 @@
+//
+//  CapacitorVideoPlayerPlugin.Observers.swift
+//  Plugin
+//
+//  Created by  Quéau Jean Pierre on 30/05/2021.
+//  Copyright © 2021 Max Lynch. All rights reserved.
+//
+
+import Foundation
+import UIKit
+import AVFoundation
+
+extension CapacitorVideoPlayerPlugin {
+
+    // MARK: - Add Observers
+
+    // swiftlint:disable function_body_length
+    @objc func addObserversToNotificationCenter() {
+        // add Observers
+
+        playObserver = NotificationCenter.default
+            .addObserver(forName: .playerItemPlay, object: nil, queue: nil,
+                         using: playerItemPlay)
+        pauseObserver = NotificationCenter.default
+            .addObserver(forName: .playerItemPause, object: nil,
+                         queue: nil, using: playerItemPause)
+        endObserver = NotificationCenter.default
+            .addObserver(forName: .playerItemEnd, object: nil, queue: nil,
+                         using: playerItemEnd)
+        readyObserver = NotificationCenter.default
+            .addObserver(forName: .playerItemReady, object: nil,
+                         queue: nil, using: playerItemReady)
+        fsDismissObserver = NotificationCenter.default
+            .addObserver(forName: .playerFullscreenDismiss, object: nil,
+                         queue: nil, using: playerFullscreenDismiss)
+        vpInternalObserver = NotificationCenter.default
+            .addObserver(forName: .videoPathInternalReady, object: nil,
+                         queue: nil, using: videoPathInternalReady)
+
+        backgroundObserver =
+            NotificationCenter.default.addObserver(
+                forName: UIApplication.didEnterBackgroundNotification,
+                object: nil, queue: nil) { (_) in
+                if self.backModeEnabled {
+                    isInBackgroundMode = true
+                    if !isInPIPMode &&
+                        self.videoPlayerFullScreenView != nil {
+                        self.videoPlayerFullScreenView?
+                            .videoPlayer.player = nil
+
+                        if let playerItem = self.videoPlayerFullScreenView?
+                            .playerItem {
+                            self.videoTrackEnable(playerItem: playerItem,
+                                                  enable: false)
+                        }
+                    }
+                } else {
+                    if self.videoPlayerFullScreenView != nil {
+
+                        self.videoPlayerFullScreenView?
+                            .videoPlayer.player?.pause()
+                    }
+                }
+            }
+        foregroundObserver =
+            NotificationCenter.default.addObserver(forName: UIApplication.willEnterForegroundNotification, object: nil,
+                                                   queue: OperationQueue.main) { (_) in
+
+                if self.backModeEnabled {
+                    isInBackgroundMode = false
+                    if !isInPIPMode && self.bgPlayer != nil &&
+                        self.videoPlayerFullScreenView != nil {
+                        //enable video track
+                        if let playerItem =
+                            self.videoPlayerFullScreenView?.playerItem {
+                            self.videoTrackEnable(playerItem: playerItem,
+                                                  enable: true)
+                        }
+
+                        self.videoPlayerFullScreenView?
+                            .videoPlayer.player = self.bgPlayer
+                    }
+                } else {
+                    if self.videoPlayerFullScreenView != nil {
+
+                        if let playerItem =
+                            self.videoPlayerFullScreenView?.playerItem {
+                            self.videoTrackEnable(playerItem: playerItem,
+                                                  enable: true)
+                        }
+                        self.videoPlayerFullScreenView?
+                            .videoPlayer.player?.play()
+                    }
+
+                }
+            }
+    }
+    // swiftlint:enable function_body_length
+
+    // MARK: - videoTrackEnable
+
+    func videoTrackEnable(playerItem: AVPlayerItem, enable: Bool) {
+        let tracks = playerItem.tracks
+        for playerItemTrack in tracks {
+            // Find the video tracks.
+            if let mediaType = playerItemTrack.assetTrack?.mediaType {
+                if mediaType == AVMediaType.video {
+                    // Enable/Disable the track.
+                    playerItemTrack.isEnabled = enable
+                }
+            }
+        }
+
+    }
+
+    // MARK: - videoPathInternalReady
+
+    // swiftlint:disable function_body_length
+    func videoPathInternalReady(notification: Notification) {
+        self.bridge?.viewController?.dismiss(animated: true, completion: {
+        })
+        guard let info = notification.userInfo as? [String: Any]
+        else { return }
+        guard let videoUrl = info["videoUrl"] as? URL else {
+            NotificationCenter.default.post(
+                name: .playerFullscreenDismiss, object: nil)
+            return
+        }
+        guard let videoRate = info["videoRate"] as? Float else {
+            NotificationCenter.default.post(
+                name: .playerFullscreenDismiss, object: nil)
+            return
+        }
+        guard let exitOnEnd = info["exitOnEnd"] as? Bool else {
+            NotificationCenter.default.post(
+                name: .playerFullscreenDismiss, object: nil)
+            return
+        }
+        guard let loopOnEnd = info["loopOnEnd"] as? Bool else {
+            NotificationCenter.default.post(
+                name: .playerFullscreenDismiss, object: nil)
+            return
+        }
+        guard let pipEnabled = info["pipEnabled"] as? Bool else {
+            NotificationCenter.default.post(
+                name: .playerFullscreenDismiss, object: nil)
+            return
+        }
+        guard let showControls = info["showControls"] as? Bool else {
+            NotificationCenter.default.post(
+                name: .playerFullscreenDismiss, object: nil)
+            return
+        }
+        guard let displayMode = info["displayMode"] as? String else {
+            NotificationCenter.default.post(
+                name: .playerFullscreenDismiss, object: nil)
+            return
+        }
+        guard let backModeEnabled = info["backModeEnabled"] as? Bool else {
+            NotificationCenter.default.post(
+                name: .playerFullscreenDismiss, object: nil)
+            return
+        }
+        guard let call = self.call else { return }
+
+        self.createVideoPlayerFullscreenView(
+            call: call, videoUrl: videoUrl,
+            rate: videoRate, exitOnEnd: exitOnEnd,
+            loopOnEnd: loopOnEnd, pipEnabled: pipEnabled,
+            backModeEnabled: backModeEnabled,
+            showControls: showControls,
+            displayMode: displayMode,
+            subTitleUrl: nil, subTitleLanguage: nil,
+            subTitleOptions: nil, headers: nil,
+            title: nil, smallTitle: nil, artwork: nil)
+        return
+    }
+    // swiftlint:enable function_body_length
+
+}

package/ios/Plugin/Info.plist

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>$(DEVELOPMENT_LANGUAGE)</string>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleIdentifier</key>
+	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>$(PRODUCT_NAME)</string>
+	<key>CFBundlePackageType</key>
+	<string>FMWK</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleVersion</key>
+	<string>$(CURRENT_PROJECT_VERSION)</string>
+	<key>NSPrincipalClass</key>
+	<string></string>
+</dict>
+</plist>