Skip to content

A cross platform Audiobookshelf client for Android and iOS

Dart
9.4 KB
Raw Blame
import AVFoundation
import Flutter
import Foundation
import MediaPlayer
import UIKit

/// Drives the cross-book audio transition in queue mode. Builds a fresh
/// AVPlayerItem for the next book and swaps it into the AVQueuePlayer that
/// just_audio owns via replaceCurrentItem + explicit play + rate. The item
/// is foreign to just_audio, so the Dart side re-syncs just_audio on the
/// next foreground enter. MPNowPlayingInfoCenter is updated from Swift in
/// the same step so the lock screen stays alive through the swap.
final class IOSQueueAdvancer: NSObject {
  static let shared = IOSQueueAdvancer()

  static var logSink: ((String) -> Void)?

  private let queue = DispatchQueue(label: "com.barnabas.absorb.queueadvancer")

  private weak var _justAudioPlayer: AVQueuePlayer?
  private var _justAudioPlayerId: String?

  private var _preparedItem: AVPlayerItem?
  private var _preparedTitle: String = ""
  private var _preparedArtist: String = ""
  private var _preparedAlbum: String = ""
  private var _preparedDurationS: Double = 0
  private var _preparedCoverPath: String?
  private var _preparedStartS: Double = 0

  private override init() {
    super.init()
    NotificationCenter.default.addObserver(
      forName: Notification.Name("AbsorbJustAudioPlayerReady"),
      object: nil,
      queue: .main
    ) { [weak self] note in
      guard let player = note.userInfo?["player"] as? AVQueuePlayer else { return }
      let playerId = note.userInfo?["playerId"] as? String
      self?.queue.async {
        self?._justAudioPlayer = player
        self?._justAudioPlayerId = playerId
        self?.emit("[QueueAdvancer] captured just_audio player id=\(playerId ?? "?")")
      }
    }
    NotificationCenter.default.addObserver(
      forName: Notification.Name("AbsorbJustAudioPlayerReleased"),
      object: nil,
      queue: .main
    ) { [weak self] note in
      let playerId = note.userInfo?["playerId"] as? String
      self?.queue.async {
        if self?._justAudioPlayerId == playerId {
          self?._justAudioPlayer = nil
          self?._justAudioPlayerId = nil
          self?.emit("[QueueAdvancer] released just_audio player id=\(playerId ?? "?")")
        }
      }
    }
  }

  func register(with messenger: FlutterBinaryMessenger) {
    let channel = FlutterMethodChannel(
      name: "com.absorb.queue_advancer",
      binaryMessenger: messenger
    )
    channel.setMethodCallHandler { [weak self] call, result in
      self?.handle(call, result: result)
    }
    emit("[QueueAdvancer] channel registered")
  }

  private func handle(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
    let args = call.arguments as? [String: Any]
    switch call.method {
    case "prepareNext":
      let url = (args?["url"] as? String) ?? ""
      let isLocal = (args?["isLocal"] as? Bool) ?? false
      let headers = (args?["headers"] as? [String: String]) ?? [:]
      let title = (args?["title"] as? String) ?? ""
      let artist = (args?["artist"] as? String) ?? ""
      let album = (args?["album"] as? String) ?? ""
      let duration = (args?["durationS"] as? Double) ?? 0
      let coverPath = args?["coverPath"] as? String
      let startS = (args?["startS"] as? Double) ?? 0
      prepareNext(
        urlStr: url,
        isLocal: isLocal,
        headers: headers,
        title: title,
        artist: artist,
        album: album,
        durationS: duration,
        coverPath: coverPath,
        startS: startS,
        completion: { ok in result(ok) }
      )

    case "commitAdvance":
      let speed = (args?["speed"] as? Double) ?? 1.0
      commitAdvance(speed: speed, completion: { ok in result(ok) })

    case "getPositionS":
      queue.async { [weak self] in
        let pos = self?._justAudioPlayer?.currentItem?.currentTime().seconds ?? 0
        result(pos.isFinite ? pos : 0.0)
      }

    case "clear":
      queue.async { [weak self] in self?.dropPrepared() }
      result(true)

    case "isReady":
      result(_justAudioPlayer != nil)

    case "isPrepared":
      result(_preparedItem != nil)

    default:
      result(FlutterMethodNotImplemented)
    }
  }

  private func prepareNext(
    urlStr: String,
    isLocal: Bool,
    headers: [String: String],
    title: String,
    artist: String,
    album: String,
    durationS: Double,
    coverPath: String?,
    startS: Double,
    completion: @escaping (Bool) -> Void
  ) {
    queue.async { [weak self] in
      guard let self = self else { completion(false); return }
      guard !urlStr.isEmpty else {
        self.emit("[QueueAdvancer] prepareNext: empty url")
        completion(false)
        return
      }
      let url: URL?
      if isLocal {
        let path = urlStr.hasPrefix("file://") ? String(urlStr.dropFirst(7)) : urlStr
        url = URL(fileURLWithPath: path)
      } else {
        url = URL(string: urlStr)
      }
      guard let assetUrl = url else {
        self.emit("[QueueAdvancer] prepareNext: bad url \(urlStr)")
        completion(false)
        return
      }

      var options: [String: Any] = [:]
      if !headers.isEmpty {
        options["AVURLAssetHTTPHeaderFieldsKey"] = headers
      }
      let asset = AVURLAsset(url: assetUrl, options: options)
      asset.loadValuesAsynchronously(forKeys: ["tracks", "duration"]) { [weak self] in
        guard let self = self else { return }
        self.queue.async {
          var trackErr: NSError?
          let status = asset.statusOfValue(forKey: "tracks", error: &trackErr)
          if status != .loaded {
            self.emit("[QueueAdvancer] prepareNext: tracks not loaded status=\(status.rawValue) err=\(trackErr?.localizedDescription ?? "nil")")
            completion(false)
            return
          }
          let item = AVPlayerItem(asset: asset)
          item.audioTimePitchAlgorithm = .timeDomain
          self._preparedItem = item
          self._preparedTitle = title
          self._preparedArtist = artist
          self._preparedAlbum = album
          self._preparedDurationS = durationS
          self._preparedCoverPath = coverPath
          self._preparedStartS = startS
          self.emit("[QueueAdvancer] prepared \(title) (\(assetUrl.lastPathComponent)) start=\(startS)")
          completion(true)
        }
      }
    }
  }

  private func commitAdvance(speed: Double, completion: @escaping (Bool) -> Void) {
    queue.async { [weak self] in
      guard let self = self else { completion(false); return }
      guard let player = self._justAudioPlayer else {
        self.emit("[QueueAdvancer] commitAdvance: no just_audio player ref")
        completion(false)
        return
      }
      guard let item = self._preparedItem else {
        self.emit("[QueueAdvancer] commitAdvance: nothing prepared")
        completion(false)
        return
      }

      self.activateSession()
      self.publishNowPlaying(rate: speed)

      let target = Float(speed > 0 ? speed : 1.0)
      let startS = self._preparedStartS
      DispatchQueue.main.async {
        // Drop stale queued items so AVQueuePlayer can't race us into one.
        for queued in player.items() where queued !== item {
          player.remove(queued)
        }
        player.replaceCurrentItem(with: item)
        if startS > 0 {
          item.seek(to: CMTime(seconds: startS, preferredTimescale: 1000), completionHandler: { _ in
            player.play()
            player.rate = target
          })
        } else {
          player.play()
          player.rate = target
        }
        self.queue.async {
          self.emit("[QueueAdvancer] commitAdvance done rate=\(player.rate) item=\(self._preparedTitle)")
          self._preparedItem = nil
          self.publishNowPlaying(rate: Double(target))
          completion(true)
        }
      }
    }
  }

  private func dropPrepared() {
    _preparedItem = nil
    _preparedTitle = ""
    _preparedArtist = ""
    _preparedAlbum = ""
    _preparedDurationS = 0
    _preparedCoverPath = nil
    _preparedStartS = 0
  }

  private func activateSession() {
    let session = AVAudioSession.sharedInstance()
    do {
      if session.category != .playback {
        try session.setCategory(.playback, mode: .spokenAudio, policy: .longFormAudio)
      }
      try session.setActive(true)
    } catch {
      emit("[QueueAdvancer] session activate failed: \(error.localizedDescription)")
    }
  }

  private func publishNowPlaying(rate: Double) {
    let title = _preparedTitle
    let artist = _preparedArtist
    let album = _preparedAlbum
    let duration = _preparedDurationS
    let coverPath = _preparedCoverPath
    let elapsed = _preparedStartS
    guard !title.isEmpty else { return }
    var info: [String: Any] = [
      MPMediaItemPropertyTitle: title,
      MPMediaItemPropertyArtist: artist,
      MPNowPlayingInfoPropertyPlaybackRate: rate,
      MPNowPlayingInfoPropertyElapsedPlaybackTime: elapsed,
      MPNowPlayingInfoPropertyMediaType: MPNowPlayingInfoMediaType.audio.rawValue,
    ]
    if duration > 0 {
      info[MPMediaItemPropertyPlaybackDuration] = duration
    }
    if !album.isEmpty {
      info[MPMediaItemPropertyAlbumTitle] = album
    }
    if let coverPath = coverPath, let img = UIImage(contentsOfFile: coverPath) {
      let artwork = MPMediaItemArtwork(boundsSize: img.size) { _ in img }
      info[MPMediaItemPropertyArtwork] = artwork
    }
    DispatchQueue.main.async {
      MPNowPlayingInfoCenter.default().nowPlayingInfo = info
      MPNowPlayingInfoCenter.default().playbackState = rate > 0 ? .playing : .paused
    }
  }

  private func emit(_ line: String) {
    NSLog("%@", line)
    Self.logSink?(line)
  }
}