@picsa/capacitor-video-player 7.1.0

package/ios/Plugin/VideoPlayer/FullScreenVideoPlayerView.swift

@@ -0,0 +1,601 @@
+//
+//  FullScreenVideoPlayerView.swift
+//  Plugin
+//
+//  Created by  Quéau Jean Pierre on 13/01/2020.
+//  Copyright © 2021 Max Lynch. All rights reserved.
+//
+
+import UIKit
+import AVKit
+import MediaPlayer
+
+// swiftlint:disable file_length
+// swiftlint:disable type_body_length
+open class FullScreenVideoPlayerView: UIView {
+    private var _url: URL
+    private var _isReadyToPlay: Bool = false
+    private var _videoId: String = "fullscreen"
+    private var _currentTime: Double = 0
+    private var _duration: Double = 0
+    private var _isLoaded: [String: Bool] = [:]
+    private var _isBufferEmpty: [String: Bool] = [:]
+    private var _exitOnEnd: Bool = true
+    private var _loopOnEnd: Bool = false
+    private var _pipEnabled: Bool = true
+    private var _firstReadyToPlay: Bool = true
+    private var _stUrl: URL?
+    private var _stLanguage: String?
+    private var _stHeaders: [String: String]?
+    private var _stOptions: [String: Any]?
+    private var _videoRate: Float
+    private var _showControls: Bool = true
+    private var _displayMode: String = "all"
+    private var _title: String?
+    private var _smallTitle: String?
+    private var _artwork: String?
+
+    var player: AVPlayer?
+    var videoPlayer: AVPlayerViewController
+    var videoAsset: AVURLAsset
+    var playerItem: AVPlayerItem?
+    var isPlaying: Bool
+    var itemBufferObserver: NSKeyValueObservation?
+    var itemStatusObserver: NSKeyValueObservation?
+    var playerRateObserver: NSKeyValueObservation?
+    var videoPlayerFrameObserver: NSKeyValueObservation?
+    var videoPlayerMoveObserver: NSKeyValueObservation?
+    var periodicTimeObserver: Any?
+
+    init(url: URL, rate: Float, playerId: String, exitOnEnd: Bool,
+         loopOnEnd: Bool, pipEnabled: Bool, showControls: Bool,
+         displayMode: String, stUrl: URL?, stLanguage: String?,
+         stHeaders: [String: String]?, stOptions: [String: Any]?,
+         title: String?, smallTitle: String?, artwork: String?) {
+        //self._videoPath = videoPath
+        self._url = url
+        self._stUrl = stUrl
+        self._stLanguage = stLanguage
+        self._stOptions = stOptions
+        self._exitOnEnd = exitOnEnd
+        self._loopOnEnd = loopOnEnd
+        self._pipEnabled = pipEnabled
+        self._videoId = playerId
+        self._videoRate = rate
+        self._stHeaders = stHeaders
+        self._displayMode = displayMode
+        self.videoPlayer = AllOrientationAVPlayerController()
+        if displayMode == "landscape" {
+            self.videoPlayer = LandscapeAVPlayerController()
+        }
+        if displayMode == "portrait" {
+            self.videoPlayer = PortraitAVPlayerController()
+        }
+        self._showControls = showControls
+        self._title = title
+        self._smallTitle = smallTitle
+        self._artwork = artwork
+
+        if let headers = self._stHeaders {
+            self.videoAsset = AVURLAsset(url: url, options: ["AVURLAssetHTTPHeaderFieldsKey": headers])
+        } else {
+            self.videoAsset = AVURLAsset(url: url)
+        }
+
+        self.isPlaying = false
+        super.init(frame: .zero)
+        self.initialize()
+        self.addObservers()
+    }
+
+    // swiftlint:disable function_body_length
+    // swiftlint:disable cyclomatic_complexity
+    private func initialize() {
+        // Set SubTitles if any
+        if var subTitleUrl = self._stUrl {
+            //check if subtitle is .srt
+            if subTitleUrl.pathExtension == "srt" {
+                let vttUrl: URL = srtSubtitleToVtt(srtURL: subTitleUrl)
+                self._stUrl = vttUrl
+                subTitleUrl = vttUrl
+            }
+            var textStyle: [AVTextStyleRule] = []
+            if let opt = self._stOptions {
+                textStyle.append(contentsOf: self.setSubTitleStyle(options: opt))
+            }
+
+            let subTitleAsset = AVAsset(url: subTitleUrl)
+            let composition = AVMutableComposition()
+
+            if let videoTrack = composition.addMutableTrack(
+                withMediaType: AVMediaType.video,
+                preferredTrackID: Int32(kCMPersistentTrackID_Invalid)) {
+                if let audioTrack = composition.addMutableTrack(
+                    withMediaType: AVMediaType.audio,
+                    preferredTrackID: Int32(kCMPersistentTrackID_Invalid)) {
+                    do {
+                        try videoTrack.insertTimeRange(
+                            CMTimeRangeMake(start: CMTime.zero,
+                                            duration: self.videoAsset.duration),
+                            of: self.videoAsset.tracks(
+                                withMediaType: AVMediaType.video)[0],
+                            at: CMTime.zero)
+                        // if video has an audio track
+                        if self.videoAsset.tracks.count > 0 {
+                            let clipAudioTrack = self.videoAsset.tracks(
+                                withMediaType: AVMediaType.audio)[0]
+                            try audioTrack.insertTimeRange(CMTimeRangeMake(
+                                                            start: CMTime.zero,
+                                                            duration: self.videoAsset.duration),
+                                                           of: clipAudioTrack, at: CMTime.zero)
+                        }
+                        //Adds subtitle track
+                        if let subtitleTrack = composition.addMutableTrack(
+                            withMediaType: .text,
+                            preferredTrackID: kCMPersistentTrackID_Invalid) {
+                            do {
+                                let duration = self.videoAsset.duration
+                                try subtitleTrack.insertTimeRange(
+                                    CMTimeRangeMake(start: CMTime.zero,
+                                                    duration: duration),
+                                    of: subTitleAsset.tracks(
+                                        withMediaType: .text)[0],
+                                    at: CMTime.zero)
+
+                                self.playerItem = AVPlayerItem(asset: composition)
+                                self.playerItem?.textStyleRules = textStyle
+
+                            } catch {
+                                self.playerItem = AVPlayerItem(asset: self.videoAsset)
+                            }
+                        } else {
+                            self.playerItem = AVPlayerItem(asset: self.videoAsset)
+                        }
+                    } catch {
+                        self.playerItem = AVPlayerItem(asset: self.videoAsset)
+                    }
+                } else {
+                    self.playerItem = AVPlayerItem(asset: self.videoAsset)
+                }
+            } else {
+                self.playerItem = AVPlayerItem(asset: self.videoAsset)
+            }
+        } else {
+            self.playerItem = AVPlayerItem(asset: self.videoAsset)
+        }
+        self.player = AVPlayer(playerItem: self.playerItem)
+        self.player?.currentItem?.audioTimePitchAlgorithm = .timeDomain
+        if !self._showControls {
+            self.videoPlayer.showsPlaybackControls = false
+        }
+        self.videoPlayer.player = self.player
+        self.videoPlayer.updatesNowPlayingInfoCenter = false
+        if #available(iOS 13.0, *) {
+            self.videoPlayer.isModalInPresentation = true
+        } else {
+            // Fallback on earlier versions
+        }
+        self.videoPlayer.allowsPictureInPicturePlayback = false
+        if isPIPModeAvailable && self._pipEnabled {
+            self.videoPlayer.allowsPictureInPicturePlayback = true
+        }
+
+        self._isLoaded.updateValue(false, forKey: self._videoId)
+
+    }
+    // swiftlint:enable cyclomatic_complexity
+    // swiftlint:enable function_body_length
+
+    private func setSubTitleStyle(options: [String: Any]) -> [AVTextStyleRule] {
+        var styles: [AVTextStyleRule] = []
+        var backColor: [Float] = [1.0, 0.0, 0.0, 0.0]
+        if let bckCol = options["backgroundColor"] as? String {
+            let color = self.getColorFromRGBA(rgba: bckCol)
+            backColor = color.count > 0 ? color : backColor
+        }
+        if let textStyle: AVTextStyleRule = AVTextStyleRule(textMarkupAttributes: [
+            kCMTextMarkupAttribute_CharacterBackgroundColorARGB as String:
+                backColor
+        ]) {
+            styles.append(textStyle)
+        }
+
+        var foreColor: [Float] = [1.0, 1.0, 1.0, 1.0]
+        if let foreCol = options["foregroundColor"] as? String {
+            let color = self.getColorFromRGBA(rgba: foreCol)
+            foreColor = color.count > 0 ? color : foreColor
+        }
+        if let textStyle1: AVTextStyleRule = AVTextStyleRule(textMarkupAttributes: [
+            kCMTextMarkupAttribute_ForegroundColorARGB as String: foreColor
+        ]) {
+            styles.append(textStyle1)
+        }
+        var ftSize = 160
+        if let pixSize = options["fontSize"] as? Int {
+            ftSize = pixSize * 10
+        }
+        if let textStyle2: AVTextStyleRule = AVTextStyleRule(textMarkupAttributes: [
+            kCMTextMarkupAttribute_RelativeFontSize as String: ftSize,
+            kCMTextMarkupAttribute_CharacterEdgeStyle as String: kCMTextMarkupCharacterEdgeStyle_None
+        ]) {
+            styles.append(textStyle2)
+        }
+        return styles
+    }
+    // MARK: - Add Observers
+
+    // swiftlint:disable function_body_length
+    // swiftlint:disable cyclomatic_complexity
+    private func addObservers() {
+
+        self.itemStatusObserver = self.playerItem?
+            .observe(\.status, options: [.new, .old],
+                     changeHandler: {(playerItem, _) in
+                        // Switch over the status
+                        switch playerItem.status {
+                        case .readyToPlay:
+                            // Player item is ready to play.
+                            if self._firstReadyToPlay {
+                                self._isLoaded.updateValue(true, forKey: self._videoId)
+                                self._isReadyToPlay = true
+                                isVideoEnded = false
+                                if let item = self.playerItem {
+                                    self._currentTime = CMTimeGetSeconds(item.currentTime())
+                                }
+                                let vId: [String: Any] = ["fromPlayerId": self._videoId, "currentTime": self._currentTime,
+                                                          "videoRate": self._videoRate]
+                                NotificationCenter.default.post(name: .playerItemReady, object: nil, userInfo: vId)
+                                self._firstReadyToPlay = false
+                                
+                                self.setNowPlayingInfo()
+                                self.setRemoteCommandCenter()
+                                self.setNowPlayingImage()
+                            }
+                        case .failed:
+                            print("failing to load")
+                            self._isLoaded.updateValue(false, forKey: self._videoId)
+                        case .unknown:
+                            // Player item is not yet ready.
+                            print("playerItem not yet ready")
+
+                        @unknown default:
+                            print("playerItem Error \(String(describing: self.playerItem?.error))")
+                        }
+
+                     })
+
+        self.itemBufferObserver = self.playerItem?
+            .observe(\.isPlaybackBufferEmpty,
+                     options: [.new, .old], changeHandler: {(playerItem, _) in
+                        let empty: Bool = ((self.playerItem?.isPlaybackBufferEmpty) != nil)
+                        if empty {
+                            self._isBufferEmpty.updateValue(true, forKey: self._videoId)
+                        } else {
+                            self._isBufferEmpty.updateValue(false, forKey: self._videoId)
+                        }
+                     })
+        self.playerRateObserver = self.player?
+            .observe(\.rate, options: [.new, .old], changeHandler: {(player, _) in
+                let rate: Float = player.rate
+                if let item = self.playerItem {
+                    self._currentTime = CMTimeGetSeconds(item.currentTime())
+                    self._duration = CMTimeGetSeconds(item.duration)
+                }
+                let vId: [String: Any] = [
+                    "fromPlayerId": self._videoId,
+                    "currentTime": self._currentTime,
+                    "videoRate": self._videoRate
+                ]
+
+                if !(self._isLoaded[self._videoId] ?? true) {
+                    print("AVPlayer Rate for player \(self._videoId): Loading")
+                } else if rate > 0 && self._isReadyToPlay {
+                    if rate != self._videoRate {
+                        player.rate = self._videoRate
+                    }
+
+                    self.isPlaying = true
+                    NotificationCenter.default.post(name: .playerItemPlay, object: nil, userInfo: vId)
+                } else if rate == 0 && !isVideoEnded && abs(self._currentTime - self._duration) < 0.2 {
+                    self.isPlaying = false
+                    player.seek(to: CMTime.zero)
+                    self._currentTime = 0
+                    if /*!isInPIPMode && */self._exitOnEnd {
+                        isVideoEnded = true
+                        NotificationCenter.default.post(name: .playerItemEnd, object: nil, userInfo: vId)
+                    } else {
+                        if self._loopOnEnd {
+                            self.play()
+                        }
+                    }
+                } else if rate == 0 {
+                    if !isInPIPMode && !isInBackgroundMode && !isRateZero {
+                        self.isPlaying = false
+                        if !self.videoPlayer.isBeingDismissed {
+                            print("AVPlayer Rate for player \(self._videoId): Paused")
+                            NotificationCenter.default.post(name: .playerItemPause, object: nil, userInfo: vId)
+                        }
+                    } else {
+                        isRateZero = true
+                    }
+                } else if self._isBufferEmpty[self._videoId] ?? true {
+                    print("AVPlayer Rate for player \(self._videoId): Buffer Empty Loading")
+                }
+            })
+        self.videoPlayerFrameObserver = self.videoPlayer
+            .observe(\.view.frame, options: [.new, .old],
+                     changeHandler: {(_, _) in
+                        if !isInPIPMode {
+                            if self.videoPlayer.isBeingDismissed && !isVideoEnded {
+                                NotificationCenter.default.post(name: .playerFullscreenDismiss, object: nil)
+                            }
+                        }
+
+                     })
+        self.videoPlayerMoveObserver = self.videoPlayer
+            .observe(\.view.center, options: [.new, .old],
+                     changeHandler: {(_, _) in
+                        if !isInPIPMode {
+                            if self.videoPlayer.isBeingDismissed && !isVideoEnded {
+                                NotificationCenter.default.post(name: .playerFullscreenDismiss, object: nil)
+                            }
+
+                        }
+
+                     })
+    }
+
+    // swiftlint:enable function_body_length
+    // swiftlint:enable cyclomatic_complexity
+
+    // MARK: - Remove Observers
+
+    func removeObservers() {
+        self.itemStatusObserver?.invalidate()
+        self.itemBufferObserver?.invalidate()
+        self.playerRateObserver?.invalidate()
+        self.videoPlayerFrameObserver?.invalidate()
+    }
+
+    // MARK: - Required init
+
+    public required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+    // MARK: - Set-up Public functions
+
+    @objc func play() {
+        self.isPlaying = true
+        self.player?.play()
+        self.player?.rate = _videoRate
+    }
+    @objc func pause() {
+        self.isPlaying = false
+        self.player?.pause()
+    }
+    @objc func didFinishPlaying() -> Bool {
+        return isVideoEnded
+    }
+    @objc func getDuration() -> Double {
+        return Double(CMTimeGetSeconds(self.videoAsset.duration))
+    }
+    @objc func getCurrentTime() -> Double {
+        return self._currentTime
+    }
+    // This func will return the updated currentTime of player item
+    // getCurrentTime() is only updated when player plays, pauses, seek, etc
+    // the function is only used in playerFullscreenDismiss() Notification
+    public func getRealCurrentTime() -> Double {
+        if let item = self.playerItem {
+            let currentTime = CMTimeGetSeconds(item.currentTime())
+            return currentTime
+        } else {
+            return 0
+        }
+    }
+    @objc func setCurrentTime(time: Double) {
+        let seekTime: CMTime = CMTimeMake(value: Int64(time*1000), timescale: 1000)
+        self.player?.seek(to: seekTime)
+        self._currentTime = time
+    }
+    @objc func getVolume() -> Float {
+        if let player = self.player {
+            return player.volume
+        } else {
+            return 1.0
+        }
+    }
+    @objc func setVolume(volume: Float) {
+        self.player?.volume = volume
+    }
+    @objc func getRate() -> Float {
+        return _videoRate
+    }
+
+    @objc func setRate(rate: Float) {
+        _videoRate = rate
+    }
+    @objc func getMuted() -> Bool {
+        return ((self.player?.isMuted) != nil)
+    }
+    @objc func setMuted(muted: Bool) {
+        self.player?.isMuted = muted
+    }
+
+    private func getColorFromRGBA(rgba: String) -> [Float] {
+        if let oPar = rgba.firstIndex(of: "(") {
+            if let cPar = rgba.firstIndex(of: ")") {
+                let strColor = rgba[rgba.index(after: oPar)..<cPar]
+                let array = strColor.components(separatedBy: ",")
+                if array.count == 4 {
+                    var retArray: [Float] = []
+                    retArray.append((array[3]
+                                        .trimmingCharacters(in: .whitespaces) as NSString)
+                                        .floatValue)
+                    retArray.append((array[0]
+                                        .trimmingCharacters(in: .whitespaces) as NSString)
+                                        .floatValue / 255)
+                    retArray.append((array[1]
+                                        .trimmingCharacters(in: .whitespaces) as NSString)
+                                        .floatValue / 255)
+                    retArray.append((array[2]
+                                        .trimmingCharacters(in: .whitespaces) as NSString)
+                                        .floatValue / 255)
+                    return retArray
+                } else {
+                    return []
+                }
+            } else {
+                return []
+            }
+        } else {
+            return []
+        }
+    }
+
+    private func srtSubtitleToVtt(srtURL: URL) -> URL {
+        guard let cachesURL = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first else {
+            fatalError("Couldn't get caches directory")
+        }
+        let vttFileName = UUID().uuidString + ".vtt"
+        let vttURL = cachesURL.appendingPathComponent(vttFileName)
+        let session = URLSession(configuration: .default)
+        let vttFolderURL = vttURL.deletingLastPathComponent()
+        do {
+            try FileManager.default.createDirectory(at: vttFolderURL, withIntermediateDirectories: true, attributes: nil)
+        } catch let error {
+            print("Creating folder error: ", error)
+        }
+        let task = session.dataTask(with: srtURL) { (data, _, error) in
+            guard let data = data, error == nil else {
+                print("Download failed: \(error?.localizedDescription ?? "ukn")")
+                return
+            }
+            do {
+                let tempSRTURL = URL(fileURLWithPath: NSTemporaryDirectory()).appendingPathComponent("subtitulos.srt")
+                try data.write(to: tempSRTURL)
+                let srtContent = try String(contentsOf: tempSRTURL, encoding: .utf8)
+                let vttContent = srtContent.replacingOccurrences(of: ",", with: ".")
+                let vttString = "WEBVTT\n\n" + vttContent
+                try vttString.write(toFile: vttURL.path, atomically: true, encoding: .utf8)
+                try FileManager.default.removeItem(at: tempSRTURL)
+
+            } catch let error {
+                print("Processing subs error: \(error)")
+                exit(1)
+            }
+
+        }
+
+        task.resume()
+        return vttURL
+    }
+    
+    func setRemoteCommandCenter() {
+        let rcc = MPRemoteCommandCenter.shared()
+        
+        rcc.playCommand.isEnabled = true
+        rcc.playCommand.addTarget {event in
+            self.play()
+            return .success
+        }
+        rcc.pauseCommand.isEnabled = true
+        rcc.pauseCommand.addTarget {event in
+            self.pause()
+            return .success
+        }
+        rcc.changePlaybackPositionCommand.isEnabled = true
+        rcc.changePlaybackPositionCommand.addTarget {event in
+            let seconds = (event as? MPChangePlaybackPositionCommandEvent)?.positionTime ?? 0
+            let time = CMTime(seconds: seconds, preferredTimescale: 1)
+            self.player?.seek(to: time)
+            return .success
+        }
+        rcc.skipForwardCommand.isEnabled = true
+        rcc.skipForwardCommand.addTarget {event in
+            if let player = self.player, let currentItem = player.currentItem {
+                let currentTime = CMTimeGetSeconds(currentItem.currentTime()) + 10
+                self.player?.seek(to: CMTimeMakeWithSeconds(currentTime, preferredTimescale: 1))
+                return .success
+            } else {
+                return .commandFailed
+            }
+        }
+        rcc.skipBackwardCommand.isEnabled = true
+        rcc.skipBackwardCommand.addTarget {event in
+            if let player = self.player, let currentItem = player.currentItem {
+                let currentTime = CMTimeGetSeconds(currentItem.currentTime()) - 10
+                self.player?.seek(to: CMTimeMakeWithSeconds(currentTime, preferredTimescale: 1))
+                return .success
+            } else {
+                return .commandFailed
+            }
+        }
+        
+        // Next and previous track buttons are disabled because we don't have more than 1 video
+        rcc.nextTrackCommand.isEnabled = false
+        rcc.previousTrackCommand.isEnabled = false
+    }
+    
+    func setNowPlayingImage() {
+        if let artwork = self._artwork {
+            let session = URLSession(configuration: .default)
+            let image = URL(string: artwork)!
+            let task = session.dataTask(with: image) { (data, response, error) in
+                guard let imageData = data, error == nil else {
+                    print("Error while downloading the image: \(error?.localizedDescription ?? "")")
+                    return
+                }
+                
+                let image = UIImage(data: imageData)
+                DispatchQueue.main.async {
+                    var nowPlayingInfo = MPNowPlayingInfoCenter.default().nowPlayingInfo ?? [String: Any]()
+                    nowPlayingInfo[MPMediaItemPropertyArtwork] = MPMediaItemArtwork(boundsSize: image?.size ?? CGSize.zero, requestHandler: { _ in
+                        return image ?? UIImage()
+                    })
+                    MPNowPlayingInfoCenter.default().nowPlayingInfo = nowPlayingInfo
+                }
+            }
+            task.resume()
+        }
+    }
+    
+    func setNowPlayingInfo() {
+        var nowPlayingInfo = [String: Any]()
+        
+        if let title = self._title {
+            nowPlayingInfo[MPMediaItemPropertyTitle] = title
+        }
+        if let smalltitle = self._smallTitle {
+            nowPlayingInfo[MPMediaItemPropertyArtist] = smalltitle
+        }
+        
+        nowPlayingInfo[MPNowPlayingInfoPropertyMediaType] = NSNumber(value: MPNowPlayingInfoMediaType.video.rawValue)
+        MPNowPlayingInfoCenter.default().nowPlayingInfo = nowPlayingInfo
+        UIApplication.shared.beginReceivingRemoteControlEvents()
+        periodicTimeObserver = self.player?.addPeriodicTimeObserver(forInterval: CMTimeMake(value: 1, timescale: 1), queue: DispatchQueue.main) { [weak self] time in
+            guard let self = self else { return }
+            
+            var nowPlayingInfo = MPNowPlayingInfoCenter.default().nowPlayingInfo ?? [String: Any]()
+            if let currentItem = self.player?.currentItem,
+               let currentTime = self.player?.currentTime(),
+               currentItem.status == .readyToPlay {
+                
+                let elapsedTime = CMTimeGetSeconds(currentTime)
+                if currentItem.isPlaybackLikelyToKeepUp {
+                    nowPlayingInfo[MPNowPlayingInfoPropertyPlaybackRate] = self.player?.rate
+                } else {
+                    nowPlayingInfo[MPNowPlayingInfoPropertyPlaybackRate] = 0
+                }
+                
+                nowPlayingInfo[MPNowPlayingInfoPropertyElapsedPlaybackTime] = Float(elapsedTime)
+                nowPlayingInfo[MPMediaItemPropertyPlaybackDuration] = currentItem.duration.seconds
+                
+                MPNowPlayingInfoCenter.default().nowPlayingInfo = nowPlayingInfo
+            }
+        }
+    }
+}
+
+// swiftlint:enable type_body_length
+// swiftlint:enable file_length

package/ios/Plugin/VideoPlayer/Models/Video.swift

@@ -0,0 +1,28 @@
+//
+//  Video.swift
+//  Plugin
+//
+//  Created by  Quéau Jean Pierre on 13/01/2020.
+//  Copyright © 2021 Max Lynch. All rights reserved.
+//
+
+import Foundation
+class Video: NSObject {
+    var urlPath: String?
+    var imgPath: String?
+    var title: String?
+    var content: String?
+    var width: Int?
+    var height: Int?
+    override init() {
+
+    }
+    init(urlPath: String, imgPath: String?, title: String, content: String, width: Int, height: Int) {
+        self.urlPath = urlPath
+        self.imgPath = imgPath
+        self.title = title
+        self.content = content
+        self.width = width
+        self.height = height
+    }
+}

package/ios/Plugin/VideoPlayer/Models/VideoModel.swift

@@ -0,0 +1,42 @@
+//
+//  VideoModel.swift
+//  Plugin
+//
+//  Created by  Quéau Jean Pierre on 13/01/2020.
+//  Copyright © 2021 Max Lynch. All rights reserved.
+//
+
+import UIKit
+
+class VideoModel: NSObject {
+    var videos: [Video] = []
+
+    func addVideo(video: Video) {
+        videos.append(video)
+    }
+
+    func getVideos() -> [Video] {
+        return videos
+    }
+
+    func printVideos() {
+        for video in self.videos {
+            guard let urlPath: String = video.urlPath else {
+                continue
+            }
+            guard let title: String = video.title else {
+                continue
+            }
+            guard let content: String = video.content else {
+                continue
+            }
+            guard let width: Int = video.width else {
+                continue
+            }
+            guard let height: Int = video.height else {
+                continue
+            }
+            print("Video \(urlPath) \n \(title) \n \(content) \n \(width) \(height)")
+        }
+    }
+}