coding

iOSClient/AppDelegate.swift

@@ -64,6 +64,8 @@ class AppDelegate: UIResponder, UIApplicationDelegate, UNUserNotificationCenterD
     var shares: [tableShare] = []
     var timerErrorNetworking: Timer?
     
+    var player: AVPlayer?
+    
     func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
         
         let userAgent = CCUtility.getUserAgent() as String

iOSClient/Viewer/NCViewerMedia/NCPlayer/NCPlayer.swift

@@ -24,8 +24,9 @@
 import Foundation
 import NCCommunication
 import UIKit
+import AVFoundation
 
-class NCPlayer: AVPlayer {
+class NCPlayer: NSObject {
    
     private let appDelegate = UIApplication.shared.delegate as! AppDelegate
     private var imageVideoContainer: imageVideoContainerView?
@@ -35,33 +36,41 @@ class NCPlayer: AVPlayer {
     public var metadata: tableMetadata?
     public var videoLayer: AVPlayerLayer?
 
+    init(url: URL) {
+        appDelegate.player = AVPlayer(url: url)
+    }
+    
+    deinit {
+        print("deinit NCPlayer")
+    }
+    
     func setupVideoLayer(imageVideoContainer: imageVideoContainerView?, playerToolBar: NCPlayerToolBar?, metadata: tableMetadata) {
         
         self.playerToolBar = playerToolBar
         self.metadata = metadata
         
-        isMuted = CCUtility.getAudioMute()
-        seek(to: .zero)
+        appDelegate.player?.isMuted = CCUtility.getAudioMute()
+        appDelegate.player?.seek(to: .zero)
 
         // At end go back to start & show toolbar
-        NotificationCenter.default.addObserver(forName: .AVPlayerItemDidPlayToEndTime, object: currentItem, queue: .main) { (notification) in
-            if let item = notification.object as? AVPlayerItem, let currentItem = self.currentItem, item == currentItem {
-                self.seek(to: .zero)
+        NotificationCenter.default.addObserver(forName: .AVPlayerItemDidPlayToEndTime, object: appDelegate.player?.currentItem, queue: .main) { (notification) in
+            if let item = notification.object as? AVPlayerItem, let currentItem = self.appDelegate.player?.currentItem, item == currentItem {
+                self.appDelegate.player?.seek(to: .zero)
                 self.playerToolBar?.showToolBar(metadata: metadata, detailView: nil)
                 NCKTVHTTPCache.shared.saveCache(metadata: metadata)
             }
         }
         
-        currentItem?.asset.loadValuesAsynchronously(forKeys: ["duration", "playable"], completionHandler: {
-            if let duration: CMTime = (self.currentItem?.asset.duration) {
+        appDelegate.player?.currentItem?.asset.loadValuesAsynchronously(forKeys: ["duration", "playable"], completionHandler: {
+            if let duration: CMTime = (self.appDelegate.player?.currentItem?.asset.duration) {
                 var error: NSError? = nil
-                let status = self.currentItem?.asset.statusOfValue(forKey: "playable", error: &error)
+                let status = self.appDelegate.player?.currentItem?.asset.statusOfValue(forKey: "playable", error: &error)
                 switch status {
                 case .loaded:
                     DispatchQueue.main.async {
                         if let imageVideoContainer = imageVideoContainer {
                             self.imageVideoContainer = imageVideoContainer
-                            self.videoLayer = AVPlayerLayer(player: self)
+                            self.videoLayer = AVPlayerLayer(player: self.appDelegate.player)
                             self.videoLayer!.frame = imageVideoContainer.bounds
                             self.videoLayer!.videoGravity = .resizeAspect
                             imageVideoContainer.layer.addSublayer(self.videoLayer!)
@@ -71,10 +80,10 @@ class NCPlayer: AVPlayer {
                         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.seek(to: time)
+                            self.appDelegate.player?.seek(to: time)
                         }
                         DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
-                            playerToolBar?.setBarPlayer(player: self)
+                            playerToolBar?.setBarPlayer(ncplayer: self)
                         }
                     }
                     break
@@ -96,17 +105,13 @@ class NCPlayer: AVPlayer {
         
         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.pause()
+            appDelegate.player?.pause()
         }
     }
     
@@ -122,20 +127,20 @@ class NCPlayer: AVPlayer {
     
     func videoPlay() {
                 
-        play()
+        appDelegate.player?.play()
     }
     
     func videoPause() {
         guard let metadata = self.metadata else { return }
         
-        pause()
-        NCManageDatabase.shared.addVideoTime(metadata: metadata, time: currentTime(), durationSeconds: nil)
+        appDelegate.player?.pause()
+        NCManageDatabase.shared.addVideoTime(metadata: metadata, time: appDelegate.player?.currentTime(), durationSeconds: nil)
     }
     
     func videoSeek(time: CMTime) {
         guard let metadata = self.metadata else { return }
         
-        seek(to: time)
+        appDelegate.player?.seek(to: time)
         NCManageDatabase.shared.addVideoTime(metadata: metadata, time: time, durationSeconds: nil)
     }
     
@@ -148,7 +153,7 @@ class NCPlayer: AVPlayer {
     
     func getVideoCurrentSeconds() -> Float64 {
         
-        return CMTimeGetSeconds(currentTime())
+        return CMTimeGetSeconds(appDelegate.player?.currentTime() ?? .zero)
     }
     
     func getVideoDurationSeconds() -> Float64 {
@@ -160,7 +165,7 @@ class NCPlayer: AVPlayer {
         
         var image: UIImage?
 
-        if let asset = self.currentItem?.asset {
+        if let asset = appDelegate.player?.currentItem?.asset {
 
             do {
                 let imageGenerator = AVAssetImageGenerator(asset: asset)

iOSClient/Viewer/NCViewerMedia/NCPlayer/NCPlayerToolBar.swift

@@ -40,7 +40,8 @@ class NCPlayerToolBar: UIView {
         case moved
     }
         
-    private var player: NCPlayer?
+    private let appDelegate = UIApplication.shared.delegate as! AppDelegate
+    private var ncplayer: NCPlayer?
     private var wasInPlay: Bool = false
     private var playbackSliderEvent: sliderEventType = .ended
     private let seekDuration: Float64 = 15
@@ -87,23 +88,23 @@ class NCPlayerToolBar: UIView {
         print("deinit NCPlayerToolBar")
     }
     
-    func setBarPlayer(player: NCPlayer) {
+    func setBarPlayer(ncplayer: NCPlayer) {
                         
-        self.player = player
+        self.ncplayer = ncplayer
         
         playbackSlider.value = 0
         playbackSlider.minimumValue = 0
-        playbackSlider.maximumValue = Float(player.getVideoDurationSeconds())
+        playbackSlider.maximumValue = Float(ncplayer.getVideoDurationSeconds())
         playbackSlider.addTarget(self, action: #selector(onSliderValChanged(slider:event:)), for: .valueChanged)
 
         labelCurrentTime.text = NCUtility.shared.stringFromTimeInterval(interval: 0)
-        labelOverallDuration.text = "-" + NCUtility.shared.stringFromTimeInterval(interval:player.getVideoDurationSeconds())
+        labelOverallDuration.text = "-" + NCUtility.shared.stringFromTimeInterval(interval:ncplayer.getVideoDurationSeconds())
                 
         updateToolBar()
         
-        player.addPeriodicTimeObserver(forInterval: CMTimeMakeWithSeconds(1, preferredTimescale: 1), queue: .main, using: { (CMTime) in
+        appDelegate.player?.addPeriodicTimeObserver(forInterval: CMTimeMakeWithSeconds(1, preferredTimescale: 1), queue: .main, using: { (CMTime) in
             
-            if player.currentItem?.status == .readyToPlay {
+            if self.appDelegate.player?.currentItem?.status == .readyToPlay {
                 if self.isHidden == false {
                     self.updateToolBar()
                 }
@@ -151,9 +152,9 @@ class NCPlayerToolBar: UIView {
     public func updateToolBar() {
 
         var namedPlay = "play.fill"
-        if player?.rate == 1 { namedPlay = "pause.fill"}
-        let currentSeconds = player?.getVideoCurrentSeconds() ?? 0
-        let durationSeconds = player?.getVideoDurationSeconds() ?? 0
+        if appDelegate.player?.rate == 1 { namedPlay = "pause.fill"}
+        let currentSeconds = ncplayer?.getVideoCurrentSeconds() ?? 0
+        let durationSeconds = ncplayer?.getVideoDurationSeconds() ?? 0
         
         playbackSlider.value = Float(currentSeconds)
         playbackSlider.isEnabled = true
@@ -193,16 +194,16 @@ class NCPlayerToolBar: UIView {
             
             switch touchEvent.phase {
             case .began:
-                wasInPlay = player?.rate == 1 ? true : false
-                player?.videoPause()
+                wasInPlay = appDelegate.player?.rate == 1 ? true : false
+                ncplayer?.videoPause()
                 playbackSliderEvent = .began
             case .moved:
-                player?.videoSeek(time: targetTime)
+                ncplayer?.videoSeek(time: targetTime)
                 playbackSliderEvent = .moved
             case .ended:
-                player?.videoSeek(time: targetTime)
+                ncplayer?.videoSeek(time: targetTime)
                 if wasInPlay {
-                    player?.videoPlay()
+                    ncplayer?.videoPlay()
                 }
                 playbackSliderEvent = .ended
             default:
@@ -225,14 +226,14 @@ class NCPlayerToolBar: UIView {
     
     @IBAction func playerPause(_ sender: Any) {
         
-        if player?.timeControlStatus == .playing {
-            player?.videoPause()
-        } else if player?.timeControlStatus == .paused {
-            player?.videoPlay()
-        } else if player?.timeControlStatus == .waitingToPlayAtSpecifiedRate {
-            player?.deleteLocalFile()
+        if appDelegate.player?.timeControlStatus == .playing {
+            ncplayer?.videoPause()
+        } else if appDelegate.player?.timeControlStatus == .paused {
+            ncplayer?.videoPlay()
+        } else if appDelegate.player?.timeControlStatus == .waitingToPlayAtSpecifiedRate {
+            ncplayer?.deleteLocalFile()
             print("timeControlStatus.waitingToPlayAtSpecifiedRate")
-            if let reason = player?.reasonForWaitingToPlay {
+            if let reason = appDelegate.player?.reasonForWaitingToPlay {
                 switch reason {
                 case .evaluatingBufferingRate:
                     print("reasonForWaitingToPlay.evaluatingBufferingRate")
@@ -252,24 +253,26 @@ class NCPlayerToolBar: UIView {
         let mute = CCUtility.getAudioMute()
         
         CCUtility.setAudioMute(!mute)
-        player?.isMuted = !mute
+        appDelegate.player?.isMuted = !mute
         updateToolBar()
     }
     
     @IBAction func forwardButtonSec(_ sender: Any) {
-        guard let player = player else { return }
+        guard let ncplayer = ncplayer else { return }
+        guard let player = appDelegate.player else { return }
 
         let playerCurrentTime = CMTimeGetSeconds(player.currentTime())
         let newTime = playerCurrentTime + seekDuration
         
-        if newTime < player.getVideoDurationSeconds() {
+        if newTime < ncplayer.getVideoDurationSeconds() {
             let time: CMTime = CMTimeMake(value: Int64(newTime * 1000 as Float64), timescale: 1000)
-            player.videoSeek(time: time)
+            ncplayer.videoSeek(time: time)
         }
     }
     
     @IBAction func backButtonSec(_ sender: Any) {
-        guard let player = player else { return }
+        guard let ncplayer = ncplayer else { return }
+        guard let player = appDelegate.player else { return }
 
         let playerCurrenTime = CMTimeGetSeconds(player.currentTime())
         var newTime = playerCurrenTime - seekDuration
@@ -277,6 +280,6 @@ class NCPlayerToolBar: UIView {
         if newTime < 0 { newTime = 0 }
         let time: CMTime = CMTimeMake(value: Int64(newTime * 1000 as Float64), timescale: 1000)
         
-        player.videoSeek(time: time)
+        ncplayer.videoSeek(time: time)
     }
 }