Fork PR

SwiftAudioEx/Classes/AVPlayerWrapper/AVPlayerWrapper.swift

@@ -20,10 +20,10 @@ public enum PlaybackEndedReason: String {
     case failed
 }
 
-class AVPlayerWrapper: AVPlayerWrapperProtocol {
+public class AVPlayerWrapper: AVPlayerWrapperProtocol {
     // MARK: - Properties
 
-    fileprivate var avPlayer = AVPlayer()
+    var avPlayer = AVQueuePlayer()
     private let playerObserver = AVPlayerObserver()
     internal let playerTimeObserver: AVPlayerTimeObserver
     private let playerItemNotificationObserver = AVPlayerItemNotificationObserver()
@@ -37,7 +37,11 @@ class AVPlayerWrapper: AVPlayerWrapperProtocol {
         label: "AVPlayerWrapper.stateQueue",
         attributes: .concurrent
     )
-
+
+    private var nextAsset: AVAsset?
+    private var nextPreloadUrl: URL?
+    private var wasPlayingBeforeStall = false
+
     public init() {
         playerTimeObserver = AVPlayerTimeObserver(periodicObserverTimeInterval: timeEventFrequency.getTime())
 
@@ -56,20 +60,17 @@ class AVPlayerWrapper: AVPlayerWrapperProtocol {
     var _state: AVPlayerWrapperState = AVPlayerWrapperState.idle
     var state: AVPlayerWrapperState {
         get {
-            var state: AVPlayerWrapperState!
-            stateQueue.sync {
-                state = _state
-            }
-
-            return state
+            return stateQueue.sync { _state }
         }
         set {
             stateQueue.async(flags: .barrier) { [weak self] in
                 guard let self = self else { return }
                 let currentState = self._state
-                if (currentState != newValue) {
+                if currentState != newValue {
                     self._state = newValue
-                    self.delegate?.AVWrapper(didChangeState: newValue)
+                    DispatchQueue.main.async {
+                        self.delegate?.AVWrapper(didChangeState: newValue)
+                    }
                 }
             }
         }
@@ -174,7 +175,15 @@ class AVPlayerWrapper: AVPlayerWrapperProtocol {
     func pause() {
         playWhenReady = false
     }
+
+    func recreatePlayer() {
+        recreateAVPlayer()
+    }
 
+    func clearAvPlayerQueue() {
+        avPlayer.removeAllItems()
+    }
+
     func togglePlaying() {
         switch avPlayer.timeControlStatus {
         case .playing, .waitingToPlayAtSpecifiedRate:
@@ -228,73 +237,146 @@ class AVPlayerWrapper: AVPlayerWrapperProtocol {
     }
 
     func load() {
-        if (state == .failed) {
+        if state == .failed {
             recreateAVPlayer()
+        }
+        if let asset {
+            asset.cancelLoading()
+            self.asset = nil
+        }
+        self.stopObservingAVPlayerItem()
+        nextAsset?.cancelLoading()
+        guard let url = url else { return }
+        state = .loading
+        print("---- requesting new item \(url.absoluteString.suffix(10)) ")
+        print("---- \(avPlayer.items().compactMap { ($0.asset as? AVURLAsset)?.url.absoluteString.suffix(10) })")
+        if let item = avPlayer.items().first { ($0.asset as? AVURLAsset)?.url == url }, avPlayer.items().count == 2 {
+            print("---- load existing item")
+            self.item = item
+            self.avPlayer.advanceToNextItem()
+            self.applyAVPlayerRate()
+            self.asset = item.asset
+            self.startObservingAVPlayer(item: item)
+            self.applyAVPlayerRate()
+            self.prefetchNextTracks()
+            return;
+        }
+        let pendingAsset = AVURLAsset(url: url, options: urlOptions)
+        asset = pendingAsset
+        let keys: [String] = [
+            "playable",
+            "availableChapterLocales",
+            "availableMetadataFormats",
+            "commonMetadata",
+            "duration"
+        ]
+
+        pendingAsset.loadValuesAsynchronously(forKeys: keys) { [weak self] in
+            guard let self = self else { return }
+            DispatchQueue.main.async {
+                var error: NSError?
+                let playableStatus = pendingAsset.statusOfValue(forKey: "playable", error: &error)
+                switch playableStatus {
+                case .cancelled, .loading, .unknown:
+                    return
+                case .failed:
+                    self.playbackFailed(error: AudioPlayerError.PlaybackError.failedToLoadKeyValue)
+                    return
+                default: break
+                }
+                self.handleLoadedAsset(pendingAsset)
+            }
+        }
+    }
+
+    private func handleLoadedAsset(_ pendingAsset: AVURLAsset) {
+        guard pendingAsset == asset else { return }
+
+        if !pendingAsset.isPlayable {
+            playbackFailed(error: AudioPlayerError.PlaybackError.itemWasUnplayable)
+            return
+        }
+
+        let keysToLoad: [String] = [
+            "playable",
+            "availableChapterLocales",
+            "availableMetadataFormats",
+            "commonMetadata",
+            "duration"
+        ]
+
+        let item = AVPlayerItem(asset: pendingAsset, automaticallyLoadedAssetKeys: keysToLoad)
+        self.item = item
+        item.preferredForwardBufferDuration = self.bufferDuration
+        print("---- avplayer removeallitems ----")
+        self.avPlayer.removeAllItems()
+        self.avPlayer.insert(item, after: nil)
+        self.prefetchNextTracks()
+        self.startObservingAVPlayer(item: item)
+        self.applyAVPlayerRate()
+        if !pendingAsset.availableChapterLocales.isEmpty {
+            for locale in pendingAsset.availableChapterLocales {
+                let chapters = pendingAsset.chapterMetadataGroups(withTitleLocale: locale, containingItemsWithCommonKeys: nil)
+                self.delegate?.AVWrapper(didReceiveMetadata: chapters)
+            }
         } else {
-            clearCurrentItem()
+            for format in pendingAsset.availableMetadataFormats {
+                let timeRange = CMTimeRange(start: .zero, end: pendingAsset.duration)
+                let group = AVTimedMetadataGroup(items: pendingAsset.metadata(forFormat: format), timeRange: timeRange)
+                self.delegate?.AVWrapper(didReceiveMetadata: [group])
+            }
         }
-        if let url = url {
-            let keys = ["playable"]
-            let pendingAsset = AVURLAsset(url: url, options: urlOptions)
-            asset = pendingAsset
-            state = .loading
-            pendingAsset.loadValuesAsynchronously(forKeys: keys, completionHandler: { [weak self] in
+
+        if let initialTime = self.timeToSeekToAfterLoading {
+            self.timeToSeekToAfterLoading = nil
+            self.seek(to: initialTime)
+        }
+    }
+
+    func prefetchNextTracks() {
+        QueuedAudioPlayer.nextAudioItem.first?.getSourceUrl({ [weak self] urlString in
+            guard let self = self else { return }
+            guard let url = URL(string: urlString) else { return }
+            nextAsset = AVURLAsset(url: url)
+            guard let asset = nextAsset else { return }
+            let keys = [
+                "playable",
+                "availableChapterLocales",
+                "availableMetadataFormats",
+                "commonMetadata",
+                "duration"
+            ]
+            asset.loadValuesAsynchronously(forKeys: keys) { [weak self] in
                 guard let self = self else { return }
+                var error: NSError?
+                let status = asset.statusOfValue(forKey: "playable", error: &error)
+                guard status == .loaded else { return }
+
+                let item = AVPlayerItem(asset: asset)
+                item.preferredForwardBufferDuration = 30
+                item.canUseNetworkResourcesForLiveStreamingWhilePaused = true
 
                 DispatchQueue.main.async {
-                    if (pendingAsset != self.asset) { return; }
-
-                    for key in keys {
-                        var error: NSError?
-                        let keyStatus = pendingAsset.statusOfValue(forKey: key, error: &error)
-                        switch keyStatus {
-                        case .failed:
-                            self.playbackFailed(error: AudioPlayerError.PlaybackError.failedToLoadKeyValue)
-                            return
-                        case .cancelled, .loading, .unknown:
-                            return
-                        case .loaded:
-                            break
-                        default: break
-                        }
-                    }
-
-                    if (!pendingAsset.isPlayable) {
-                        self.playbackFailed(error: AudioPlayerError.PlaybackError.itemWasUnplayable)
-                        return;
-                    }
-
-                    let item = AVPlayerItem(
-                        asset: pendingAsset,
-                        automaticallyLoadedAssetKeys: keys
-                    )
-                    self.item = item;
-                    item.preferredForwardBufferDuration = self.bufferDuration
-                    self.avPlayer.replaceCurrentItem(with: item)
-                    self.startObservingAVPlayer(item: item)
-                    self.applyAVPlayerRate()
-                    if pendingAsset.availableChapterLocales.count > 0 {
-                        for locale in pendingAsset.availableChapterLocales {
-                            let chapters = pendingAsset.chapterMetadataGroups(withTitleLocale: locale, containingItemsWithCommonKeys: nil)
-                            self.delegate?.AVWrapper(didReceiveMetadata: chapters)
-                        }
-                    } else {
-                        for format in pendingAsset.availableMetadataFormats {
-                            let timeRange = CMTimeRange(start: CMTime(seconds: 0, preferredTimescale: 1000), end: pendingAsset.duration)
-                            let group = AVTimedMetadataGroup(items: pendingAsset.metadata(forFormat: format), timeRange: timeRange)
-                            self.delegate?.AVWrapper(didReceiveMetadata: [group])
-                        }
-                    }
-
-                    if let initialTime = self.timeToSeekToAfterLoading {
-                        self.timeToSeekToAfterLoading = nil
-                        self.seek(to: initialTime)
+                    if self.avPlayer.items().count > 1 {
+                        let nextItems = self.avPlayer.items().dropFirst()
+                        nextItems.forEach { self.avPlayer.remove($0) }
                     }
+                    self.avPlayer.insert(item, after: nil)
+                    print("---- preload next item \((self.avPlayer.items().compactMap { ($0.asset as? AVURLAsset)?.url.absoluteString.suffix(10) }).joined(separator: "  ||  ") ) ")
                 }
-            })
-        }
+            }
+        })
     }
 
+    func preloadNextTracks(_ url: URL) {
+        guard !avPlayer.items().contains(where: { ($0.asset as? AVURLAsset)?.url == url} ) else { return }
+        self.nextPreloadUrl = url
+    }
+
+    func clearPreloadedTracks() {
+        avPlayer.removeAllItems()
+    }
+
     func load(from url: URL, playWhenReady: Bool, options: [String: Any]? = nil) {
         self.playWhenReady = playWhenReady
         self.url = url
@@ -377,15 +459,15 @@ class AVPlayerWrapper: AVPlayerWrapperProtocol {
         playerItemNotificationObserver.stopObservingCurrentItem()
     }
 
-    private func recreateAVPlayer() {
+    func recreateAVPlayer() {
         playbackError = nil
         playerTimeObserver.unregisterForBoundaryTimeEvents()
         playerTimeObserver.unregisterForPeriodicEvents()
         playerObserver.stopObserving()
         stopObservingAVPlayerItem()
         clearCurrentItem()
 
-        avPlayer = AVPlayer();
+        avPlayer = AVQueuePlayer();
         setupAVPlayer()
 
         delegate?.AVWrapperDidRecreateAVPlayer()
@@ -394,7 +476,7 @@ class AVPlayerWrapper: AVPlayerWrapperProtocol {
     private func setupAVPlayer() {
         // disabled since we're not making use of video playback
         avPlayer.allowsExternalPlayback = false;
-
+        AudioPlayer.avPlayerRef = avPlayer
         playerObserver.player = avPlayer
         playerObserver.startObserving()
 
@@ -403,6 +485,7 @@ class AVPlayerWrapper: AVPlayerWrapperProtocol {
         playerTimeObserver.registerForPeriodicTimeEvents()
 
         applyAVPlayerRate()
+        avPlayer.actionAtItemEnd = .none
     }
 
     private func applyAVPlayerRate() {
@@ -421,11 +504,13 @@ extension AVPlayerWrapper: AVPlayerObserverDelegate {
             if self.asset == nil && state != .stopped {
                 self.state = .idle
             } else if (state != .failed && state != .stopped) {
-                // Playback may have become paused externally for example due to a bluetooth device disconnecting:
+                // Playback may have become paused externally for example due to a bluetooth device disconnecting,
+                // or a buffer stall when automaticallyWaitsToMinimizeStalling = false:
                 if (self.playWhenReady) {
                     // Only if we are not on the boundaries of the track, otherwise itemDidPlayToEndTime will handle it instead.
                     if (self.currentTime > 0 && self.currentTime < self.duration) {
-                        self.playWhenReady = false;
+                        wasPlayingBeforeStall = true
+                        self.playWhenReady = false
                     }
                 } else {
                     self.state = .paused
@@ -436,6 +521,7 @@ extension AVPlayerWrapper: AVPlayerObserverDelegate {
                 self.state = .buffering
             }
         case .playing:
+            wasPlayingBeforeStall = false
             self.state = .playing
         @unknown default:
             break
@@ -489,8 +575,12 @@ extension AVPlayerWrapper: AVPlayerItemObserverDelegate {
     // MARK: - AVPlayerItemObserverDelegate
 
     func item(didUpdatePlaybackLikelyToKeepUp playbackLikelyToKeepUp: Bool) {
-        if (playbackLikelyToKeepUp && state != .playing) {
+        if playbackLikelyToKeepUp && state != .playing {
             state = .ready
+            if wasPlayingBeforeStall {
+                wasPlayingBeforeStall = false
+                playWhenReady = true
+            }
         }
     }
 

SwiftAudioEx/Classes/AVPlayerWrapper/AVPlayerWrapperProtocol.swift

@@ -46,11 +46,15 @@ protocol AVPlayerWrapperProtocol: AnyObject {
     func play()
 
     func pause()
+
+    func recreatePlayer()
 
+    func clearAvPlayerQueue()
+
     func togglePlaying()
 
     func stop()
-    
+
     func seek(to seconds: TimeInterval)
 
     func seek(by offset: TimeInterval)
@@ -64,4 +68,7 @@ protocol AVPlayerWrapperProtocol: AnyObject {
     func unload()
 
     func reload(startFromCurrentTime: Bool)
+
+    func preloadNextTracks(_ url: URL)
+
 }