Skip to content

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.swift
index 6c280a50..37ab4a43 100644
--- a/ios/Runner/Audio/AbsorbAudioEngine.swift
+++ b/ios/Runner/Audio/AbsorbAudioEngine.swift
@@ -2,10 +2,11 @@ import AVFoundation
import Foundation
import 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 = false
p.allowsExternalPlayback = false
return 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 = nil
self._currentItemId = nil
+ self.resetQueuedTracks()
self.processingState = .idle
self.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 &+= 1
let myEpoch = currentEpoch
let startSerial = beginSeek(localStart > 0 ? localStart : nil, fallback: localStart)
+ resetQueuedTracks()
+ lastQueuedIndex = index
+ let itemEndAction = endAction(forTrack: index)
processingState = .loading
emitState()
@@ -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 = { _ in
if 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, _ in
self?.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 + 1
if 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 = item
currentEpoch &+= 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