Fix/memory leak

Course/Course/Presentation/Video/PlayerViewController.swift

@@ -17,7 +17,7 @@ struct PlayerViewController: UIViewControllerRepresentable {
     var seconds: ((Double) -> Void)
 
     init(
-        videoURL: URL?, 
+        videoURL: URL?,
         controller: AVPlayerViewController,
         bitrate: CGSize,
         progress: @escaping ((Float) -> Void),
@@ -33,15 +33,12 @@ struct PlayerViewController: UIViewControllerRepresentable {
     func makeUIViewController(context: Context) -> AVPlayerViewController {
         controller.modalPresentationStyle = .fullScreen
         controller.allowsPictureInPicturePlayback = true
-        controller.player = AVPlayer()
-
-        addPeriodicTimeObserver(
-            controller,
-            currentProgress: { progress, seconds in
-                self.progress(progress)
-                self.seconds(seconds)
-            }
-        )
+        let player = AVPlayer()
+        controller.player = player
+        context.coordinator.setPlayer(player) { progress, seconds in
+            self.progress(progress)
+            self.seconds(seconds)
+        }
 
         do {
             try AVAudioSession.sharedInstance().setCategory(.playback)
@@ -52,40 +49,64 @@ struct PlayerViewController: UIViewControllerRepresentable {
         return controller
     }
 
-    private func addPeriodicTimeObserver(
-        _ controller: AVPlayerViewController,
-        currentProgress: @escaping ((Float, Double) -> Void)
-    ) {
-        let interval = CMTime(
-            seconds: 0.1,
-            preferredTimescale: CMTimeScale(NSEC_PER_SEC)
-        )
-
-        self.controller.player?.addPeriodicTimeObserver(forInterval: interval, queue: .main) { time in
-            var progress: Float = .zero
-            let currentSeconds = CMTimeGetSeconds(time)
-            guard let duration = controller.player?.currentItem?.duration else { return }
-            let totalSeconds = CMTimeGetSeconds(duration)
-            progress = Float(currentSeconds / totalSeconds)
-            currentProgress(progress, currentSeconds)
+    func updateUIViewController(_ playerController: AVPlayerViewController, context: Context) {
+        let asset = playerController.player?.currentItem?.asset as? AVURLAsset
+        if asset?.url.absoluteString != videoURL?.absoluteString {
+            let player = context.coordinator.player(from: playerController)
+            player?.replaceCurrentItem(with: AVPlayerItem(url: videoURL!))
+            player?.currentItem?.preferredMaximumResolution = videoResolution
+
+            context.coordinator.setPlayer(player) { progress, seconds in
+                self.progress(progress)
+                self.seconds(seconds)
+            }
         }
     }
 
-    func updateUIViewController(_ playerController: AVPlayerViewController, context: Context) {
-        DispatchQueue.main.async {
-            let asset = playerController.player?.currentItem?.asset as? AVURLAsset
-            if asset?.url.absoluteString != videoURL?.absoluteString {
-                if playerController.player == nil {
-                    playerController.player = AVPlayer()
-                    playerController.player?.allowsExternalPlayback = true
-                }
-                playerController.player?.replaceCurrentItem(with: AVPlayerItem(url: videoURL!))
-                playerController.player?.currentItem?.preferredMaximumResolution = videoResolution
-                addPeriodicTimeObserver(playerController, currentProgress: { progress, seconds in
-                    self.progress(progress)
-                    self.seconds(seconds)
-                })
+    func makeCoordinator() -> Coordinator {
+        Coordinator()
+    }
+
+    static func dismantleUIViewController(_ uiViewController: AVPlayerViewController, coordinator: Coordinator) {
+        coordinator.setPlayer(nil) { _, _ in }
+    }
+
+    class Coordinator {
+        var currentPlayer: AVPlayer?
+        var observer: Any?
+
+        func player(from playerController: AVPlayerViewController) -> AVPlayer? {
+            var player = playerController.player
+            if player == nil {
+                player = AVPlayer()
+                player?.allowsExternalPlayback = true
+                playerController.player = player
+            }
+            return player
+        }
+
+        func setPlayer(_ player: AVPlayer?, currentProgress: @escaping ((Float, Double) -> Void)) {
+            if let observer = observer {
+                currentPlayer?.removeTimeObserver(observer)
+                currentPlayer?.pause()
+            }
+
+            let interval = CMTime(
+                seconds: 0.1,
+                preferredTimescale: CMTimeScale(NSEC_PER_SEC)
+            )
+
+            observer = player?.addPeriodicTimeObserver(forInterval: interval, queue: .main) {[weak player] time in
+                var progress: Float = .zero
+                let currentSeconds = CMTimeGetSeconds(time)
+                guard let duration = player?.currentItem?.duration else { return }
+                let totalSeconds = CMTimeGetSeconds(duration)
+                progress = Float(currentSeconds / totalSeconds)
+                currentProgress(progress, currentSeconds)
             }
+
+            currentPlayer = player
+
         }
     }
 }