A cross platform Audiobookshelf client for Android and iOS
Dart
Play straight into the next file on iPhone instead of pausing for a moment between files
Barnabas51d41a831309
diff --git a/ios/Runner/Audio/AbsorbAudioEngine.swift b/ios/Runner/Audio/AbsorbAudioEngine.swiftindex 6c280a50..37ab4a43 100644--- a/ios/Runner/Audio/AbsorbAudioEngine.swift+++ b/ios/Runner/Audio/AbsorbAudioEngine.swift@@ -2,10 +2,11 @@ import AVFoundationimport Foundationimport UIKit-/// Single AVPlayer that owns audio playback for the entire app lifetime.-/// All transitions (intra-book track boundaries, cross-book swaps) go through-/// `replaceCurrentItem` on the same player. The player is never destroyed,-/// so iOS keeps granting background audio output across transitions.+/// Single AVQueuePlayer that owns audio playback for the entire app lifetime.+/// The next files of a multi-file book wait in its queue, so the player moves+/// straight on at the end of a file. Loads, seeks into another file and+/// cross-book swaps rebuild the queue on the same player. The player is never+/// destroyed, so iOS keeps granting background audio output across transitions.final class AbsorbAudioEngine: NSObject {static let shared = AbsorbAudioEngine()@@ -15,13 +16,24 @@ final class AbsorbAudioEngine: NSObject {private let queue = DispatchQueue(label: "com.barnabas.absorb.audioengine")- private let player: AVPlayer = {- let p = AVPlayer()+ private let player: AVQueuePlayer = {+ let p = AVQueuePlayer()p.automaticallyWaitsToMinimizeStalling = falsep.allowsExternalPlayback = falsereturn p}()+ // Items in the player's queue, the playing one first. Opening the next file+ // only after the last one stopped left an audible gap between files.+ private static let tracksQueuedAhead = 2+ private var queuedTracks: [(item: AVPlayerItem, index: Int, tapped: Bool)] = []+ private var lastQueuedIndex = -1+ // Bumped whenever the queue is rebuilt, so a file still being prepared for+ // the old queue is dropped.+ private var aheadGeneration: UInt = 0+ private var aheadInFlight = false+ private var currentItemObservation: NSKeyValueObservation?+// Track list of the currently-loaded book.private var trackUrls: [URL] = []private var trackHeaders: [String: String] = [:]@@ -85,6 +97,9 @@ final class AbsorbAudioEngine: NSObject {super.init()addPeriodicTimeObserver()observeAppLifecycle()+ currentItemObservation = player.observe(\.currentItem, options: [.new]) { [weak self] _, _ in+ self?.queue.async { self?.handleQueueAdvance() }+ }}// MARK: - Public API@@ -159,11 +174,12 @@ final class AbsorbAudioEngine: NSObject {guard let self = self else { return }self.currentItem = nilself._currentItemId = nil+ self.resetQueuedTracks()self.processingState = .idleself.emitState()DispatchQueue.main.async {self.player.pause()- self.player.replaceCurrentItem(with: nil)+ self.player.removeAllItems()self.queue.async { _ = self.beginSeek(nil, fallback: 0) }}}@@ -282,6 +298,9 @@ final class AbsorbAudioEngine: NSObject {} else {AbsorbAudioEQProcessor.shared.attachTapSync(to: item)self.tapAttached = true+ if !self.queuedTracks.isEmpty { self.queuedTracks[0].tapped = true }+ // Queued files were built without the tap.+ self.requeueAhead()}}}@@ -455,6 +474,9 @@ final class AbsorbAudioEngine: NSObject {currentEpoch &+= 1let myEpoch = currentEpochlet startSerial = beginSeek(localStart > 0 ? localStart : nil, fallback: localStart)+ resetQueuedTracks()+ lastQueuedIndex = index+ let itemEndAction = endAction(forTrack: index)processingState = .loadingemitState()@@ -490,7 +512,9 @@ final class AbsorbAudioEngine: NSObject {} else {self.tapAttached = false}- self.player.replaceCurrentItem(with: item)+ self.player.actionAtItemEnd = itemEndAction+ self.player.removeAllItems()+ self.player.insert(item, after: nil)let finish: (Bool) -> Void = { _ inif autoPlay {@@ -500,6 +524,10 @@ final class AbsorbAudioEngine: NSObject {self.queue.async {self.settlePendingSeek(serial: startSerial)self.emit("[AudioEngine] loadTrack idx=\(index) localStart=\(localStart) autoPlay=\(autoPlay)")+ if self.currentEpoch == myEpoch {+ self.queuedTracks = [(item: item, index: index, tapped: eqEnabled)]+ self.enqueueAhead()+ }completion(decodedDurationS.isFinite && decodedDurationS > 0 ? decodedDurationS : nil)}}@@ -548,11 +576,13 @@ final class AbsorbAudioEngine: NSObject {forName: .AVPlayerItemDidPlayToEndTime,object: item,queue: nil- ) { [weak self] _ in- self?.queue.async { self?.handleItemEnd() }+ ) { [weak self, weak item] _ in+ self?.queue.async { self?.handleItemEnd(item) }}- statusObservation = item.observe(\.status, options: [.new]) { [weak self] item, _ in+ // Initial too: a queued file is usually ready before it starts playing,+ // and its duration and ready state still have to be reported.+ statusObservation = item.observe(\.status, options: [.initial, .new]) { [weak self] item, _ inself?.queue.async {switch item.status {case .readyToPlay:@@ -598,14 +628,22 @@ final class AbsorbAudioEngine: NSObject {}}- private func handleItemEnd() {+ private func handleItemEnd(_ endedItem: AVPlayerItem?) {+ // The queue already moved on to the next file.+ guard let endedItem = endedItem, endedItem === currentItem else { return }let nextTrack = trackIndex + 1if nextTrack < trackUrls.count {- trackIndex = nextTrack- // Player is paused now that the item ended; reading player.rate would- // wrongly report autoPlay=false. Intra-book advance should keep playing.- loadTrack(atIndex: nextTrack, localStart: 0, autoPlay: true) { _ in }- delegate?.engineDidChangeTrack(trackIndex: nextTrack, totalTracks: trackUrls.count)+ if queuedTracks.contains(where: { $0.index == nextTrack }) {+ // The queue moves on by itself. If it hasn't shortly (the file was+ // still being added when this one ended), load it the old way.+ queue.asyncAfter(deadline: .now() + 1) { [weak self] in+ guard let self = self, self.currentItem === endedItem else { return }+ self.emit("[AudioEngine] queue did not move on to idx=\(nextTrack), loading it")+ self.loadNextTrackAfterEnd(nextTrack)+ }+ return+ }+ loadNextTrackAfterEnd(nextTrack)return}@@ -619,6 +657,112 @@ final class AbsorbAudioEngine: NSObject {delegate?.engineDidCompleteBook()}+ private func loadNextTrackAfterEnd(_ nextTrack: Int) {+ trackIndex = nextTrack+ // Player is paused now that the item ended; reading player.rate would+ // wrongly report autoPlay=false. Intra-book advance should keep playing.+ loadTrack(atIndex: nextTrack, localStart: 0, autoPlay: true) { _ in }+ delegate?.engineDidChangeTrack(trackIndex: nextTrack, totalTracks: trackUrls.count)+ }++ // MARK: - Track queue++ /// The player moved on to a queued file at the end of the last one.+ private func handleQueueAdvance() {+ guard let item = player.currentItem, item !== currentItem,+ let position = queuedTracks.firstIndex(where: { $0.item === item }) else { return }+ let entry = queuedTracks[position]+ if position > 1 {+ emit("[AudioEngine] queue skipped \(position - 1) file(s) before idx=\(entry.index)")+ }+ queuedTracks.removeFirst(position)+ detachCurrentItem()+ currentItem = item+ trackIndex = entry.index+ tapAttached = entry.tapped+ _ = beginSeek(nil, fallback: 0)+ observeNewCurrentItem(item)+ let itemEndAction = endAction(forTrack: entry.index)+ DispatchQueue.main.async { self.player.actionAtItemEnd = itemEndAction }+ emit("[AudioEngine] queue moved on to idx=\(entry.index)")+ delegate?.engineDidChangeTrack(trackIndex: entry.index, totalTracks: trackUrls.count)+ enqueueAhead()+ }++ /// Advance through the book's files, but stop on the last one so the end of+ /// the book still leaves it loaded (completion, next-book swap, replay).+ private func endAction(forTrack index: Int) -> AVPlayer.ActionAtItemEnd {+ index + 1 < trackUrls.count ? .advance : .pause+ }++ private func resetQueuedTracks() {+ queuedTracks = []+ aheadGeneration &+= 1+ aheadInFlight = false+ }++ /// Prepare the next file and add it behind the queued ones, one at a time so+ /// they stay in order, until enough are waiting.+ private func enqueueAhead() {+ guard !aheadInFlight, let playing = queuedTracks.first, playing.item === currentItem else { return }+ let index = lastQueuedIndex + 1+ guard index < trackUrls.count, index <= playing.index + Self.tracksQueuedAhead else { return }+ aheadInFlight = true+ let generation = aheadGeneration+ let tap = eqEnabled+ let item = makePlayerItem(url: trackUrls[index], headers: trackHeaders)+ let asset = item.asset+ asset.loadValuesAsynchronously(forKeys: ["tracks", "duration"]) { [weak self] in+ guard let self = self else { return }+ var err: NSError?+ let loaded = asset.statusOfValue(forKey: "tracks", error: &err) == .loaded+ self.queue.async {+ guard generation == self.aheadGeneration else { return }+ guard loaded, let after = self.queuedTracks.last?.item else {+ self.aheadInFlight = false+ self.emit("[AudioEngine] could not queue idx=\(index) err=\(err?.localizedDescription ?? "nil")")+ return+ }+ // Listed before it is inserted, so an advance onto it is recognised.+ self.queuedTracks.append((item: item, index: index, tapped: tap))+ self.lastQueuedIndex = index+ DispatchQueue.main.async {+ // The file it goes after may have finished already.+ let inserted = self.player.items().contains { $0 === after }+ && self.player.canInsert(item, after: after)+ if inserted {+ // audioMix must be set before playback starts or the tap is ignored.+ if tap { AbsorbAudioEQProcessor.shared.attachTapSync(to: item) }+ self.player.insert(item, after: after)+ }+ self.queue.async {+ guard generation == self.aheadGeneration else { return }+ self.aheadInFlight = false+ if inserted {+ self.enqueueAhead()+ } else {+ self.queuedTracks.removeAll { $0.item === item }+ self.lastQueuedIndex = index - 1+ }+ }+ }+ }+ }+ }++ /// Rebuild the files queued behind the playing one.+ private func requeueAhead() {+ guard let playing = queuedTracks.first else { return }+ let stale = queuedTracks.dropFirst().map { $0.item }+ resetQueuedTracks()+ queuedTracks = [playing]+ lastQueuedIndex = playing.index+ DispatchQueue.main.async {+ for item in stale { self.player.remove(item) }+ self.queue.async { self.enqueueAhead() }+ }+ }+private func swapToNextBook() {guard let item = nextItem else { return }@@ -636,6 +780,10 @@ final class AbsorbAudioEngine: NSObject {currentItem = itemcurrentEpoch &+= 1+ resetQueuedTracks()+ queuedTracks = [(item: item, index: 0, tapped: eqEnabled)]+ lastQueuedIndex = 0+ let itemEndAction = endAction(forTrack: 0)observeNewCurrentItem(item)@@ -659,7 +807,10 @@ final class AbsorbAudioEngine: NSObject {} else {self.tapAttached = false}- self.player.replaceCurrentItem(with: item)+ self.player.actionAtItemEnd = itemEndAction+ self.player.removeAllItems()+ self.player.insert(item, after: nil)+ self.queue.async { self.enqueueAhead() }if startS > 0 {item.seek(to: CMTime(seconds: startS, preferredTimescale: 1000),toleranceBefore: .zero, toleranceAfter: .zero) { _ in