improved code

iOSClient/Viewer/NCViewerMedia/NCPlayer/NCPlayer.swift

@@ -34,38 +34,34 @@ class NCPlayer: NSObject {
     private var playerToolBar: NCPlayerToolBar?
 
     public var metadata: tableMetadata?
-    public var player: AVPlayer?
+    public var player: AVPlayer
     public var videoLayer: AVPlayerLayer?
 
-    init(url: URL) {
+    init(url: URL, imageVideoContainer: imageVideoContainerView?, playerToolBar: NCPlayerToolBar?, metadata: tableMetadata) {
+        
         self.player = AVPlayer(url: url)
-    }
-    
-    deinit {
-        print("deinit NCPlayer")
-    }
-    
-    func setupVideoLayer(imageVideoContainer: imageVideoContainerView?, playerToolBar: NCPlayerToolBar?, metadata: tableMetadata) {
+        
+        super.init()
         
         self.playerToolBar = playerToolBar
         self.metadata = metadata
         
-        self.player?.isMuted = CCUtility.getAudioMute()
-        self.player?.seek(to: .zero)
+        self.player.isMuted = CCUtility.getAudioMute()
+        self.player.seek(to: .zero)
 
         // At end go back to start & show toolbar
-        NotificationCenter.default.addObserver(forName: .AVPlayerItemDidPlayToEndTime, object: self.player?.currentItem, queue: .main) { (notification) in
-            if let item = notification.object as? AVPlayerItem, let currentItem = self.player?.currentItem, item == currentItem {
-                self.player?.seek(to: .zero)
+        NotificationCenter.default.addObserver(forName: .AVPlayerItemDidPlayToEndTime, object: self.player.currentItem, queue: .main) { (notification) in
+            if let item = notification.object as? AVPlayerItem, let currentItem = self.player.currentItem, item == currentItem {
+                self.player.seek(to: .zero)
                 self.playerToolBar?.showToolBar(metadata: metadata, detailView: nil)
                 NCKTVHTTPCache.shared.saveCache(metadata: metadata)
             }
         }
         
-        self.player?.currentItem?.asset.loadValuesAsynchronously(forKeys: ["duration", "playable"], completionHandler: {
-            if let duration: CMTime = (self.player?.currentItem?.asset.duration) {
+        self.player.currentItem?.asset.loadValuesAsynchronously(forKeys: ["duration", "playable"], completionHandler: {
+            if let duration: CMTime = (self.player.currentItem?.asset.duration) {
                 var error: NSError? = nil
-                let status = self.player?.currentItem?.asset.statusOfValue(forKey: "playable", error: &error)
+                let status = self.player.currentItem?.asset.statusOfValue(forKey: "playable", error: &error)
                 switch status {
                 case .loaded:
                     DispatchQueue.main.async {
@@ -82,7 +78,7 @@ class NCPlayer: NSObject {
                         NCManageDatabase.shared.addVideoTime(metadata: metadata, time: nil, durationSeconds: self.durationSeconds)
                         // NO Live Photo, seek to datamebase time
                         if !metadata.livePhoto, let time = NCManageDatabase.shared.getVideoTime(metadata: metadata) {
-                            self.player?.seek(to: time)
+                            self.player.seek(to: time)
                         }
                         DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
                             playerToolBar?.setBarPlayer(ncplayer: self)
@@ -108,12 +104,16 @@ class NCPlayer: NSObject {
         NotificationCenter.default.addObserver(self, selector: #selector(applicationDidEnterBackground(_:)), name: NSNotification.Name(rawValue: NCGlobal.shared.notificationCenterApplicationDidEnterBackground), object: nil)
     }
 
+    deinit {
+        print("deinit NCPlayer")
+    }
+    
     //MARK: - NotificationCenter
 
     @objc func applicationDidEnterBackground(_ notification: NSNotification) {
         
         if metadata?.classFile == NCCommunicationCommon.typeClassFile.video.rawValue {
-            self.player?.pause()
+            self.player.pause()
         }
     }
     
@@ -129,24 +129,24 @@ class NCPlayer: NSObject {
     
     func videoPlay() {
                 
-        self.player?.play()
+        self.player.play()
     }
     
     func videoPause() {
         
-        self.player?.pause()
+        self.player.pause()
     }
     
     func saveCurrentTime() {
         guard let metadata = self.metadata else { return }
 
-        NCManageDatabase.shared.addVideoTime(metadata: metadata, time: self.player?.currentTime(), durationSeconds: nil)
+        NCManageDatabase.shared.addVideoTime(metadata: metadata, time: self.player.currentTime(), durationSeconds: nil)
     }
     
     func videoSeek(time: CMTime) {
         guard let metadata = self.metadata else { return }
         
-        self.player?.seek(to: time)
+        self.player.seek(to: time)
         NCManageDatabase.shared.addVideoTime(metadata: metadata, time: time, durationSeconds: nil)
     }
     
@@ -159,7 +159,7 @@ class NCPlayer: NSObject {
     
     func getVideoCurrentSeconds() -> Float64 {
         
-        return CMTimeGetSeconds(self.player?.currentTime() ?? .zero)
+        return CMTimeGetSeconds(self.player.currentTime())
     }
     
     func getVideoDurationSeconds() -> Float64 {
@@ -171,7 +171,7 @@ class NCPlayer: NSObject {
         
         var image: UIImage?
 
-        if let asset = self.player?.currentItem?.asset {
+        if let asset = self.player.currentItem?.asset {
 
             do {
                 let imageGenerator = AVAssetImageGenerator(asset: asset)

iOSClient/Viewer/NCViewerMedia/NCPlayer/NCPlayerToolBar.swift

@@ -102,9 +102,9 @@ class NCPlayerToolBar: UIView {
                 
         updateToolBar()
         
-        ncplayer.player?.addPeriodicTimeObserver(forInterval: CMTimeMakeWithSeconds(1, preferredTimescale: 1), queue: .main, using: { (CMTime) in
+        ncplayer.player.addPeriodicTimeObserver(forInterval: CMTimeMakeWithSeconds(1, preferredTimescale: 1), queue: .main, using: { (CMTime) in
             
-            if ncplayer.player?.currentItem?.status == .readyToPlay {
+            if ncplayer.player.currentItem?.status == .readyToPlay {
                 if self.isHidden == false {
                     self.updateToolBar()
                 }
@@ -152,7 +152,7 @@ class NCPlayerToolBar: UIView {
     public func updateToolBar() {
 
         var namedPlay = "play.fill"
-        if ncplayer?.player?.rate == 1 { namedPlay = "pause.fill"}
+        if ncplayer?.player.rate == 1 { namedPlay = "pause.fill"}
         let currentSeconds = ncplayer?.getVideoCurrentSeconds() ?? 0
         let durationSeconds = ncplayer?.getVideoDurationSeconds() ?? 0
         
@@ -194,7 +194,7 @@ class NCPlayerToolBar: UIView {
             
             switch touchEvent.phase {
             case .began:
-                wasInPlay = ncplayer?.player?.rate == 1 ? true : false
+                wasInPlay = ncplayer?.player.rate == 1 ? true : false
                 ncplayer?.videoPause()
                 playbackSliderEvent = .began
             case .moved:
@@ -226,15 +226,15 @@ class NCPlayerToolBar: UIView {
     
     @IBAction func playerPause(_ sender: Any) {
         
-        if ncplayer?.player?.timeControlStatus == .playing {
+        if ncplayer?.player.timeControlStatus == .playing {
             ncplayer?.videoPause()
             ncplayer?.saveCurrentTime()
-        } else if ncplayer?.player?.timeControlStatus == .paused {
+        } else if ncplayer?.player.timeControlStatus == .paused {
             ncplayer?.videoPlay()
-        } else if ncplayer?.player?.timeControlStatus == .waitingToPlayAtSpecifiedRate {
+        } else if ncplayer?.player.timeControlStatus == .waitingToPlayAtSpecifiedRate {
             ncplayer?.deleteLocalFile()
             print("timeControlStatus.waitingToPlayAtSpecifiedRate")
-            if let reason = ncplayer?.player?.reasonForWaitingToPlay {
+            if let reason = ncplayer?.player.reasonForWaitingToPlay {
                 switch reason {
                 case .evaluatingBufferingRate:
                     print("reasonForWaitingToPlay.evaluatingBufferingRate")
@@ -254,15 +254,14 @@ class NCPlayerToolBar: UIView {
         let mute = CCUtility.getAudioMute()
         
         CCUtility.setAudioMute(!mute)
-        ncplayer?.player?.isMuted = !mute
+        ncplayer?.player.isMuted = !mute
         updateToolBar()
     }
     
     @IBAction func forwardButtonSec(_ sender: Any) {
         guard let ncplayer = ncplayer else { return }
-        guard let player = ncplayer.player else { return }
 
-        let playerCurrentTime = CMTimeGetSeconds(player.currentTime())
+        let playerCurrentTime = CMTimeGetSeconds(ncplayer.player.currentTime())
         let newTime = playerCurrentTime + seekDuration
         
         if newTime < ncplayer.getVideoDurationSeconds() {
@@ -273,9 +272,8 @@ class NCPlayerToolBar: UIView {
     
     @IBAction func backButtonSec(_ sender: Any) {
         guard let ncplayer = ncplayer else { return }
-        guard let player = ncplayer.player else { return }
 
-        let playerCurrenTime = CMTimeGetSeconds(player.currentTime())
+        let playerCurrenTime = CMTimeGetSeconds(ncplayer.player.currentTime())
         var newTime = playerCurrenTime - seekDuration
         
         if newTime < 0 { newTime = 0 }

iOSClient/Viewer/NCViewerMedia/NCViewerMedia.swift

@@ -132,10 +132,10 @@ class NCViewerMedia: UIViewController {
     override func viewWillDisappear(_ animated: Bool) {
         super.viewWillDisappear(animated)
         
-        if let player = ncplayer?.player, let time = ncplayer?.player?.currentTime() {
+        if let player = ncplayer?.player {
             if player.rate == 1 {
                 player.pause()
-                NCManageDatabase.shared.addVideoTime(metadata: currentMetadata, time: time, durationSeconds: nil)
+                NCManageDatabase.shared.addVideoTime(metadata: currentMetadata, time: player.currentTime(), durationSeconds: nil)
             }
         }
         
@@ -387,9 +387,9 @@ extension NCViewerMedia: UIPageViewControllerDelegate, UIPageViewControllerDataS
     func pageViewController(_ pageViewController: UIPageViewController, willTransitionTo pendingViewControllers: [UIViewController]) {
         
         // Save time video
-        if let player = ncplayer?.player, let time = ncplayer?.player?.currentTime() {
+        if let player = ncplayer?.player {
             if player.rate == 1 {
-                NCManageDatabase.shared.addVideoTime(metadata: currentMetadata, time: time, durationSeconds: nil)
+                NCManageDatabase.shared.addVideoTime(metadata: currentMetadata, time: player.currentTime(), durationSeconds: nil)
             }
         }
         
@@ -506,8 +506,7 @@ extension NCViewerMedia: UIGestureRecognizerDelegate {
                     AudioServicesPlaySystemSound(1519) // peek feedback
                     
                     if let url = NCKTVHTTPCache.shared.getVideoURL(metadata: metadata) {
-                        self.ncplayer = NCPlayer.init(url: url)
-                        self.ncplayer?.setupVideoLayer(imageVideoContainer: self.currentViewerMediaZoom?.imageVideoContainer, playerToolBar: nil, metadata: metadata)
+                        self.ncplayer = NCPlayer.init(url: url, imageVideoContainer: self.currentViewerMediaZoom?.imageVideoContainer, playerToolBar: nil, metadata: metadata)
                         self.ncplayer?.videoPlay()
                     }
                     
@@ -536,8 +535,7 @@ extension NCViewerMedia: UIGestureRecognizerDelegate {
                                 AudioServicesPlaySystemSound(1519) // peek feedback
                                 
                                 if let url = NCKTVHTTPCache.shared.getVideoURL(metadata: metadata) {
-                                    self.ncplayer = NCPlayer.init(url: url)
-                                    self.ncplayer?.setupVideoLayer(imageVideoContainer: self.currentViewerMediaZoom?.imageVideoContainer, playerToolBar: nil, metadata: metadata)
+                                    self.ncplayer = NCPlayer.init(url: url, imageVideoContainer: self.currentViewerMediaZoom?.imageVideoContainer, playerToolBar: nil, metadata: metadata)
                                     self.ncplayer?.videoPlay()
                                 }
                             }

iOSClient/Viewer/NCViewerMedia/NCViewerMediaZoom.swift

@@ -128,11 +128,9 @@ class NCViewerMediaZoom: UIViewController {
         super.viewDidAppear(animated)
         
         if (metadata.classFile == NCCommunicationCommon.typeClassFile.video.rawValue || metadata.classFile == NCCommunicationCommon.typeClassFile.audio.rawValue) && ncplayer == nil && imageVideoContainer.playerLayer == nil {
-            
             if let url = NCKTVHTTPCache.shared.getVideoURL(metadata: metadata) {
-                self.ncplayer = NCPlayer.init(url: url)
+                self.ncplayer = NCPlayer.init(url: url, imageVideoContainer: self.imageVideoContainer, playerToolBar: self.playerToolBar, metadata: self.metadata)
                 self.viewerMedia?.ncplayer = self.ncplayer
-                self.ncplayer?.setupVideoLayer(imageVideoContainer: self.imageVideoContainer, playerToolBar: self.playerToolBar, metadata: self.metadata)
                 //self.player?.videoPlay()
             }
         }