Improvements

Signed-off-by: marinofaggiana <marino@marinofaggiana.com>

iOSClient/Viewer/NCViewerMedia/NCPlayer/NCPlayer.swift

@@ -142,6 +142,8 @@ class NCPlayer: NSObject {
 
     deinit {
         print("deinit NCPlayer")
+        
+        deactivateObserver()
     }
     
     func activateObserver(playerToolBar: NCPlayerToolBar?) {
@@ -173,20 +175,14 @@ class NCPlayer: NSObject {
         NotificationCenter.default.addObserver(self, selector: #selector(applicationDidBecomeActive(_:)), name: NSNotification.Name(rawValue: NCGlobal.shared.notificationCenterApplicationDidBecomeActive), object: nil)
     }
     
-    func deactivateObserver(livePhoto: Bool) {
+    func deactivateObserver() {
         
         if isPlay() {
             playerPause()
         }
         
-        self.playerToolBar?.disableCommandCenter()
         self.playerToolBar = nil
         
-        if livePhoto {
-            self.videoLayer?.removeFromSuperlayer()
-            self.videoLayer = nil
-        }
-        
         if let observerAVPlayerItemDidPlayToEndTime = self.observerAVPlayerItemDidPlayToEndTime {
             NotificationCenter.default.removeObserver(observerAVPlayerItemDidPlayToEndTime)
         }

iOSClient/Viewer/NCViewerMedia/NCPlayer/NCPlayerToolBar.swift

@@ -140,22 +140,7 @@ class NCPlayerToolBar: UIView {
         guard let metadata = self.metadata else { return }
         guard let ncplayer = self.ncplayer else { return }
         var time: CMTime = .zero
-        
-        let imageNameBackward = "gobackward.10"
-        let imageNameForward = "goforward.10"
-        
-        /*
-        if metadata.classFile == NCCommunicationCommon.typeClassFile.audio.rawValue {
-            imageNameBackward = "backward"
-            imageNameForward = "forward"
-        }
-        */
-        
-        // COMMAND CENTER
-        if commandCenter && CCUtility.fileProviderStorageExists(metadata.ocId, fileNameView: metadata.fileNameView) {
-            enableCommandCenter()
-        }
-        
+                
         // MUTE
         if CCUtility.getAudioMute() {
             muteButton.setImage(NCUtility.shared.loadImage(named: "audioOff", color: .white), for: .normal)
@@ -196,9 +181,9 @@ class NCPlayerToolBar: UIView {
         
         // BACK
         if #available(iOS 13.0, *) {
-            backButton.setImage(NCUtility.shared.loadImage(named: imageNameBackward, color: .white), for: .normal)
+            backButton.setImage(NCUtility.shared.loadImage(named: "gobackward.10", color: .white), for: .normal)
         } else {
-            backButton.setImage(NCUtility.shared.loadImage(named: imageNameBackward, color: .white, size: 30), for: .normal)
+            backButton.setImage(NCUtility.shared.loadImage(named: "gobackward.10", color: .white, size: 30), for: .normal)
         }
         backButton.isEnabled = true
                  
@@ -218,131 +203,13 @@ class NCPlayerToolBar: UIView {
         
         // FORWARD
         if #available(iOS 13.0, *) {
-            forwardButton.setImage(NCUtility.shared.loadImage(named: imageNameForward, color: .white), for: .normal)
+            forwardButton.setImage(NCUtility.shared.loadImage(named: "goforward.10", color: .white), for: .normal)
         } else {
-            forwardButton.setImage(NCUtility.shared.loadImage(named: imageNameForward, color: .white, size: 30), for: .normal)
+            forwardButton.setImage(NCUtility.shared.loadImage(named: "goforward.10", color: .white, size: 30), for: .normal)
         }
         forwardButton.isEnabled = true
     }
     
-    // MARK: - Command Center
-    
-    func enableCommandCenter() {
-        guard let ncplayer = self.ncplayer else { return }
-        
-        UIApplication.shared.beginReceivingRemoteControlEvents()
-        var nowPlayingInfo = [String : Any]()
-
-        // Add handler for Play Command
-        MPRemoteCommandCenter.shared().playCommand.isEnabled = true
-        viewerMedia?.playCommand = MPRemoteCommandCenter.shared().playCommand.addTarget { event in
-            
-            if !ncplayer.isPlay() {
-                ncplayer.playerPlay()
-                return .success
-            }
-            return .commandFailed
-        }
-      
-        // Add handler for Pause Command
-        MPRemoteCommandCenter.shared().pauseCommand.isEnabled = true
-        viewerMedia?.pauseCommand = MPRemoteCommandCenter.shared().pauseCommand.addTarget { event in
-          
-            if ncplayer.isPlay() {
-                ncplayer.playerPause()
-                return .success
-            }
-            return .commandFailed
-        }
-        
-        // VIDEO / AUDIO () ()
-        if metadata?.classFile == NCCommunicationCommon.typeClassFile.video.rawValue || metadata?.classFile == NCCommunicationCommon.typeClassFile.audio.rawValue {
-            
-            MPRemoteCommandCenter.shared().skipForwardCommand.isEnabled = true
-            viewerMedia?.skipForwardCommand = MPRemoteCommandCenter.shared().skipForwardCommand.addTarget { event in
-                
-                let seconds = Float64((event as! MPSkipIntervalCommandEvent).interval)
-                self.skip(seconds: seconds)
-                return.success
-            }
-            
-            MPRemoteCommandCenter.shared().skipBackwardCommand.isEnabled = true
-            viewerMedia?.skipBackwardCommand = MPRemoteCommandCenter.shared().skipBackwardCommand.addTarget { event in
-                
-                let seconds = Float64((event as! MPSkipIntervalCommandEvent).interval)
-                self.skip(seconds: -seconds)
-                return.success
-            }
-        }
-                
-        // AUDIO < >
-        /*
-        if metadata?.classFile == NCCommunicationCommon.typeClassFile.audio.rawValue {
-                        
-            MPRemoteCommandCenter.shared().nextTrackCommand.isEnabled = true
-            appDelegate.nextTrackCommand = MPRemoteCommandCenter.shared().nextTrackCommand.addTarget { event in
-                
-                self.forward()
-                return .success
-            }
-            
-            MPRemoteCommandCenter.shared().previousTrackCommand.isEnabled = true
-            appDelegate.previousTrackCommand = MPRemoteCommandCenter.shared().previousTrackCommand.addTarget { event in
-             
-                self.backward()
-                return .success
-            }
-        }
-        */
-        
-        nowPlayingInfo[MPMediaItemPropertyTitle] = metadata?.fileNameView
-        nowPlayingInfo[MPMediaItemPropertyPlaybackDuration] = ncplayer.durationTime.seconds
-        if let image = self.image {
-            nowPlayingInfo[MPMediaItemPropertyArtwork] = MPMediaItemArtwork(boundsSize: image.size) { size in
-                return image
-            }
-        }
-        MPNowPlayingInfoCenter.default().nowPlayingInfo = nowPlayingInfo
-    }
-    
-    func disableCommandCenter() {
-        
-        UIApplication.shared.endReceivingRemoteControlEvents()
-        MPNowPlayingInfoCenter.default().nowPlayingInfo = [:]
-
-        MPRemoteCommandCenter.shared().playCommand.isEnabled = false
-        MPRemoteCommandCenter.shared().pauseCommand.isEnabled = false
-        MPRemoteCommandCenter.shared().skipForwardCommand.isEnabled = false
-        MPRemoteCommandCenter.shared().skipBackwardCommand.isEnabled = false
-        MPRemoteCommandCenter.shared().nextTrackCommand.isEnabled = false
-        MPRemoteCommandCenter.shared().previousTrackCommand.isEnabled = false
-
-        if let playCommand = viewerMedia?.playCommand {
-            MPRemoteCommandCenter.shared().playCommand.removeTarget(playCommand)
-            viewerMedia?.playCommand = nil
-        }
-        if let pauseCommand = viewerMedia?.pauseCommand {
-            MPRemoteCommandCenter.shared().pauseCommand.removeTarget(pauseCommand)
-            viewerMedia?.pauseCommand = nil
-        }
-        if let skipForwardCommand = viewerMedia?.skipForwardCommand {
-            MPRemoteCommandCenter.shared().skipForwardCommand.removeTarget(skipForwardCommand)
-            viewerMedia?.skipForwardCommand = nil
-        }
-        if let skipBackwardCommand = viewerMedia?.skipBackwardCommand {
-            MPRemoteCommandCenter.shared().skipBackwardCommand.removeTarget(skipBackwardCommand)
-            viewerMedia?.skipBackwardCommand = nil
-        }
-        if let nextTrackCommand = viewerMedia?.nextTrackCommand {
-            MPRemoteCommandCenter.shared().nextTrackCommand.removeTarget(nextTrackCommand)
-            viewerMedia?.nextTrackCommand = nil
-        }
-        if let previousTrackCommand = viewerMedia?.previousTrackCommand {
-            MPRemoteCommandCenter.shared().previousTrackCommand.removeTarget(previousTrackCommand)
-            viewerMedia?.previousTrackCommand = nil
-        }
-    }
-    
     // MARK: Handle Notifications
     
     @objc func handleRouteChange(notification: Notification) {

iOSClient/Viewer/NCViewerMedia/NCViewerMedia.swift

@@ -24,6 +24,7 @@
 import UIKit
 import SVGKit
 import NCCommunication
+import MediaPlayer
 
 class NCViewerMedia: UIViewController {
 
@@ -118,7 +119,7 @@ class NCViewerMedia: UIViewController {
             ncplayer.saveCurrentTime()
         }
         
-        currentViewController.playerToolBar.disableCommandCenter()
+        disableCommandCenter()
         
         metadatas.removeAll()
         ncplayerLivePhoto = nil
@@ -388,9 +389,126 @@ class NCViewerMedia: UIViewController {
         
         return image
     }
+    
+    // MARK: - Command Center
+
+    func updateCommandCenter(ncplayer: NCPlayer, metadata: tableMetadata) {
+
+        UIApplication.shared.beginReceivingRemoteControlEvents()
+        var nowPlayingInfo = [String : Any]()
+
+        // Add handler for Play Command
+        MPRemoteCommandCenter.shared().playCommand.isEnabled = true
+        playCommand = MPRemoteCommandCenter.shared().playCommand.addTarget { event in
+            
+            if !ncplayer.isPlay() {
+                ncplayer.playerPlay()
+                return .success
+            }
+            return .commandFailed
+        }
+      
+        // Add handler for Pause Command
+        MPRemoteCommandCenter.shared().pauseCommand.isEnabled = true
+        pauseCommand = MPRemoteCommandCenter.shared().pauseCommand.addTarget { event in
+          
+            if ncplayer.isPlay() {
+                ncplayer.playerPause()
+                return .success
+            }
+            return .commandFailed
+        }
+        
+        // VIDEO / AUDIO () ()
+        if metadata.classFile == NCCommunicationCommon.typeClassFile.video.rawValue || metadata.classFile == NCCommunicationCommon.typeClassFile.audio.rawValue {
+            
+            MPRemoteCommandCenter.shared().skipForwardCommand.isEnabled = true
+            skipForwardCommand = MPRemoteCommandCenter.shared().skipForwardCommand.addTarget { event in
+                
+                let seconds = Float64((event as! MPSkipIntervalCommandEvent).interval)
+                self.currentViewController.playerToolBar.skip(seconds: seconds)
+                return.success
+            }
+            
+            MPRemoteCommandCenter.shared().skipBackwardCommand.isEnabled = true
+            skipBackwardCommand = MPRemoteCommandCenter.shared().skipBackwardCommand.addTarget { event in
+                
+                let seconds = Float64((event as! MPSkipIntervalCommandEvent).interval)
+                self.currentViewController.playerToolBar.skip(seconds: -seconds)
+                return.success
+            }
+        }
+                
+        // AUDIO < >
+        /*
+        if metadata?.classFile == NCCommunicationCommon.typeClassFile.audio.rawValue {
+                        
+            MPRemoteCommandCenter.shared().nextTrackCommand.isEnabled = true
+            appDelegate.nextTrackCommand = MPRemoteCommandCenter.shared().nextTrackCommand.addTarget { event in
+                
+                self.forward()
+                return .success
+            }
+            
+            MPRemoteCommandCenter.shared().previousTrackCommand.isEnabled = true
+            appDelegate.previousTrackCommand = MPRemoteCommandCenter.shared().previousTrackCommand.addTarget { event in
+             
+                self.backward()
+                return .success
+            }
+        }
+        */
+        
+        nowPlayingInfo[MPMediaItemPropertyTitle] = metadata.fileNameView
+        nowPlayingInfo[MPMediaItemPropertyPlaybackDuration] = ncplayer.durationTime.seconds
+        if let image = currentViewController.image {
+            nowPlayingInfo[MPMediaItemPropertyArtwork] = MPMediaItemArtwork(boundsSize: image.size) { size in
+                return image
+            }
+        }
+        MPNowPlayingInfoCenter.default().nowPlayingInfo = nowPlayingInfo
+    }
+
+    func disableCommandCenter() {
+        
+        UIApplication.shared.endReceivingRemoteControlEvents()
+        MPNowPlayingInfoCenter.default().nowPlayingInfo = [:]
+
+        MPRemoteCommandCenter.shared().playCommand.isEnabled = false
+        MPRemoteCommandCenter.shared().pauseCommand.isEnabled = false
+        MPRemoteCommandCenter.shared().skipForwardCommand.isEnabled = false
+        MPRemoteCommandCenter.shared().skipBackwardCommand.isEnabled = false
+        MPRemoteCommandCenter.shared().nextTrackCommand.isEnabled = false
+        MPRemoteCommandCenter.shared().previousTrackCommand.isEnabled = false
+
+        if let playCommand = playCommand {
+            MPRemoteCommandCenter.shared().playCommand.removeTarget(playCommand)
+            self.playCommand = nil
+        }
+        if let pauseCommand = pauseCommand {
+            MPRemoteCommandCenter.shared().pauseCommand.removeTarget(pauseCommand)
+            self.pauseCommand = nil
+        }
+        if let skipForwardCommand = skipForwardCommand {
+            MPRemoteCommandCenter.shared().skipForwardCommand.removeTarget(skipForwardCommand)
+            self.skipForwardCommand = nil
+        }
+        if let skipBackwardCommand = skipBackwardCommand {
+            MPRemoteCommandCenter.shared().skipBackwardCommand.removeTarget(skipBackwardCommand)
+            self.skipBackwardCommand = nil
+        }
+        if let nextTrackCommand = nextTrackCommand {
+            MPRemoteCommandCenter.shared().nextTrackCommand.removeTarget(nextTrackCommand)
+            self.nextTrackCommand = nil
+        }
+        if let previousTrackCommand = previousTrackCommand {
+            MPRemoteCommandCenter.shared().previousTrackCommand.removeTarget(previousTrackCommand)
+            self.previousTrackCommand = nil
+        }
+    }
 }
 
-//MARK: - UIPageViewController Delegate Datasource
+// MARK: - UIPageViewController Delegate Datasource
 
 extension NCViewerMedia: UIPageViewControllerDelegate, UIPageViewControllerDataSource {
     
@@ -405,7 +523,7 @@ extension NCViewerMedia: UIPageViewControllerDelegate, UIPageViewControllerDataS
             direction = .reverse
         }
         
-        currentViewController.ncplayer?.deactivateObserver(livePhoto: currentViewController.metadata.livePhoto)
+        currentViewController.ncplayer?.deactivateObserver()
         
         let viewerMediaZoom = getViewerMediaZoom(index: currentIndex, image: getImageMetadata(metadatas[currentIndex]), metadata: metadatas[currentIndex], direction: direction)
         pageViewController.setViewControllers([viewerMediaZoom], direction: direction, animated: true, completion: nil)
@@ -417,7 +535,7 @@ extension NCViewerMedia: UIPageViewControllerDelegate, UIPageViewControllerDataS
         
         currentIndex = index
         
-        currentViewController.ncplayer?.deactivateObserver(livePhoto: currentViewController.metadata.livePhoto)
+        currentViewController.ncplayer?.deactivateObserver()
 
         let viewerMediaZoom = getViewerMediaZoom(index: currentIndex, image: getImageMetadata(metadatas[currentIndex]), metadata: metadatas[currentIndex], direction: direction)
         viewerMediaZoom.autoPlay = autoPlay
@@ -458,7 +576,7 @@ extension NCViewerMedia: UIPageViewControllerDelegate, UIPageViewControllerDataS
         if (completed && nextIndex != nil) {
             previousViewControllers.forEach { viewController in
                 let viewerMediaZoom = viewController as! NCViewerMediaZoom
-                viewerMediaZoom.ncplayer?.deactivateObserver(livePhoto: false)
+                viewerMediaZoom.ncplayer?.deactivateObserver()
             }
             currentIndex = nextIndex!
         }
@@ -587,7 +705,8 @@ extension NCViewerMedia: UIGestureRecognizerDelegate {
             
             currentViewController.statusViewImage.isHidden = false
             currentViewController.statusLabel.isHidden = false
-            self.ncplayerLivePhoto?.deactivateObserver(livePhoto: true)
+            currentViewController.ncplayer?.videoLayer?.removeFromSuperlayer()
+            ncplayerLivePhoto?.deactivateObserver()
         }
     }
 }

iOSClient/Viewer/NCViewerMedia/NCViewerMediaZoom.swift

@@ -167,6 +167,15 @@ class NCViewerMediaZoom: UIViewController {
                     NotificationCenter.default.postOnMainThread(name: NCGlobal.shared.notificationCenterShowPlayerToolBar, userInfo: ["ocId":metadata.ocId, "enableTimerAutoHide": false])
                 }
             }
+            
+            if let ncplayer = self.ncplayer {
+                print("xxxxxxx \(ncplayer.durationTime.seconds)")
+                self.viewerMedia?.updateCommandCenter(ncplayer: ncplayer, metadata: self.metadata)
+            }
+            
+        } else {
+            
+            viewerMedia?.disableCommandCenter()
         }
         
         // DOWNLOAD