An iOS app: the page in a web view, with the phone's own player (#418)
web/src/native.ts (#45) has handed playback to a host since September, and there was no host in this repo: the earlier app, rays/ipodderx-app, grew native lists beside the page and is left behind. This one is the page and a player: a WKWebView of ipx-web, AVPlayer behind the bridge with the audio session to play on locked, now playing and the remote commands (15 back, 30 forward, scrubbing), and positions and read written from the player's own clock, with DeadAir's copy named so the server reads the position on its clock. Built with XcodeGen on a Mac; nothing here compiles the Swift. Its icon is web/logo.svg at 1024. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01RqkrVDqdiQEMWAkNGQ2tYA
This commit is contained in:
302
ios/Sources/Playback.swift
Normal file
302
ios/Sources/Playback.swift
Normal file
@@ -0,0 +1,302 @@
|
||||
import AVFoundation
|
||||
import MediaPlayer
|
||||
import UIKit
|
||||
|
||||
/// The phone's player: the one that plays on with the screen locked, and the one the lock screen
|
||||
/// and a car's buttons reach. Knows nothing of the web view; the bridge drives it.
|
||||
@MainActor
|
||||
final class Playback: NSObject {
|
||||
/// What is loaded: enough for the lock screen, and to save a position without asking the page.
|
||||
struct Item {
|
||||
var url: URL
|
||||
var enc: Int
|
||||
var feedId: String
|
||||
var guid: String
|
||||
var title: String
|
||||
var feedTitle: String
|
||||
var artwork: String?
|
||||
var duration: Int?
|
||||
}
|
||||
|
||||
var onTime: ((Double, Double?) -> Void)?
|
||||
var onMeta: ((Double) -> Void)?
|
||||
var onState: ((Bool) -> Void)?
|
||||
var onEnded: (() -> Void)?
|
||||
var onError: ((String) -> Void)?
|
||||
|
||||
private let session: URLSession = {
|
||||
let cfg = URLSessionConfiguration.default
|
||||
cfg.httpCookieStorage = .shared
|
||||
cfg.timeoutIntervalForRequest = 20
|
||||
return URLSession(configuration: cfg)
|
||||
}()
|
||||
private var player: AVPlayer?
|
||||
private var item: Item?
|
||||
private var timeObserver: Any?
|
||||
private var statusObservation: NSKeyValueObservation?
|
||||
private var endObserver: NSObjectProtocol?
|
||||
private var lastSaved: Double = 0
|
||||
private var markedRead = false
|
||||
private var rate: Float = 1
|
||||
private var volume: Float = 1
|
||||
|
||||
var isPlaying: Bool { player?.timeControlStatus == .playing }
|
||||
var currentTime: Double { player?.currentTime().seconds ?? 0 }
|
||||
var duration: Double? {
|
||||
guard let d = player?.currentItem?.duration.seconds, d.isFinite, d > 0 else { return nil }
|
||||
return d
|
||||
}
|
||||
|
||||
override init() {
|
||||
super.init()
|
||||
// spokenAudio is what tells the system this is speech, so navigation's voice ducks it
|
||||
// properly, and longFormAudio is what routes it as a podcast does.
|
||||
do {
|
||||
try AVAudioSession.sharedInstance().setCategory(.playback, mode: .spokenAudio,
|
||||
policy: .longFormAudio)
|
||||
} catch {
|
||||
NSLog("ipx: audio session: %@", error.localizedDescription)
|
||||
}
|
||||
wireRemoteCommands()
|
||||
}
|
||||
|
||||
// MARK: - what the page asks for
|
||||
|
||||
func load(_ item: Item) {
|
||||
stop(notify: false)
|
||||
self.item = item
|
||||
markedRead = false
|
||||
lastSaved = 0
|
||||
|
||||
// An AVURLAsset does not read the shared cookie store by itself, and the cookie is how
|
||||
// ipx knows whose file this is.
|
||||
let asset = AVURLAsset(url: item.url, options: [
|
||||
AVURLAssetHTTPCookiesKey: HTTPCookieStorage.shared.cookies(for: item.url) ?? [],
|
||||
])
|
||||
let playerItem = AVPlayerItem(asset: asset)
|
||||
let player = AVPlayer(playerItem: playerItem)
|
||||
player.volume = volume
|
||||
player.defaultRate = rate
|
||||
self.player = player
|
||||
|
||||
// Where to start is the page's to decide, on loadedmetadata, so one piece of code owns it.
|
||||
// Here only the length is reported.
|
||||
statusObservation = playerItem.observe(\.status, options: [.new]) { [weak self] pi, _ in
|
||||
Task { @MainActor in
|
||||
guard let self else { return }
|
||||
switch pi.status {
|
||||
case .readyToPlay:
|
||||
if let d = self.duration { self.onMeta?(d) }
|
||||
case .failed:
|
||||
// A file that will not play, or a session that went while it played: only the
|
||||
// second has something to do about it.
|
||||
let msg = pi.error?.localizedDescription ?? "the file could not be played"
|
||||
let status = await self.request("GET", "/api/me")
|
||||
self.onError?(status == 401 ? "Sign in again" : msg)
|
||||
default: break
|
||||
}
|
||||
}
|
||||
}
|
||||
timeObserver = player.addPeriodicTimeObserver(
|
||||
forInterval: CMTime(seconds: 0.5, preferredTimescale: 600), queue: .main
|
||||
) { [weak self] t in
|
||||
MainActor.assumeIsolated { self?.tick(t.seconds) }
|
||||
}
|
||||
endObserver = NotificationCenter.default.addObserver(
|
||||
forName: .AVPlayerItemDidPlayToEndTime, object: playerItem, queue: .main
|
||||
) { [weak self] _ in
|
||||
MainActor.assumeIsolated { self?.didEnd() }
|
||||
}
|
||||
updateNowPlaying()
|
||||
}
|
||||
|
||||
func play() {
|
||||
guard let player else { return }
|
||||
try? AVAudioSession.sharedInstance().setActive(true)
|
||||
player.playImmediately(atRate: rate)
|
||||
onState?(true)
|
||||
updateNowPlaying()
|
||||
}
|
||||
|
||||
func pause() {
|
||||
player?.pause()
|
||||
onState?(false)
|
||||
savePosition()
|
||||
updateNowPlaying()
|
||||
}
|
||||
|
||||
func seek(to secs: Double) {
|
||||
// Exact, not the default tolerance, which snaps to a keyframe minutes from where the
|
||||
// scrubber was let go on a long episode.
|
||||
player?.seek(to: CMTime(seconds: max(0, secs), preferredTimescale: 600),
|
||||
toleranceBefore: .zero, toleranceAfter: .zero)
|
||||
updateNowPlaying()
|
||||
}
|
||||
|
||||
func setRate(_ r: Float) {
|
||||
rate = r
|
||||
player?.defaultRate = r
|
||||
// Setting rate on a paused player starts it, which changing the speed should not do.
|
||||
if isPlaying { player?.rate = r }
|
||||
updateNowPlaying()
|
||||
}
|
||||
|
||||
func setVolume(_ v: Float) {
|
||||
volume = v
|
||||
player?.volume = v
|
||||
}
|
||||
|
||||
func stop(notify: Bool = true) {
|
||||
savePosition()
|
||||
if let timeObserver { player?.removeTimeObserver(timeObserver) }
|
||||
if let endObserver { NotificationCenter.default.removeObserver(endObserver) }
|
||||
timeObserver = nil
|
||||
endObserver = nil
|
||||
statusObservation = nil
|
||||
player?.pause()
|
||||
player = nil
|
||||
item = nil
|
||||
MPNowPlayingInfoCenter.default().nowPlayingInfo = nil
|
||||
try? AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation)
|
||||
if notify { onState?(false) }
|
||||
}
|
||||
|
||||
/// Where we are, saved from this clock. The page asks for it too, and sends no time of its
|
||||
/// own: a web view frozen in the background holds a time from minutes ago, and writing that
|
||||
/// over where you got to is the stale write player.ts guards against.
|
||||
func savePosition() {
|
||||
guard let item, let player, player.currentItem?.status == .readyToPlay else { return }
|
||||
let secs = Int(player.currentTime().seconds.rounded())
|
||||
guard secs > 0 else { return }
|
||||
lastSaved = Double(secs)
|
||||
var body: [String: Any] = ["secs": secs]
|
||||
if let d = duration { body["duration"] = Int(d.rounded()) }
|
||||
// DeadAir's copy runs on a shorter clock; the server has to know which one this is.
|
||||
if item.url.path.contains("/deadair") { body["deadair"] = item.enc }
|
||||
Task { await request("POST", entryPath(item, "position"), body) }
|
||||
}
|
||||
|
||||
// MARK: - as it plays
|
||||
|
||||
private func tick(_ secs: Double) {
|
||||
guard secs.isFinite else { return }
|
||||
onTime?(secs, duration)
|
||||
updateElapsed(secs)
|
||||
if abs(secs - lastSaved) > 10 { savePosition() }
|
||||
// Heard, not just started: the same 90% the page uses, so an item does not leave Unread
|
||||
// the moment it is pressed. The page does the same while it runs; this is for when it
|
||||
// does not.
|
||||
if let d = duration, secs / d >= 0.9 { markRead() }
|
||||
}
|
||||
|
||||
private func didEnd() {
|
||||
savePosition()
|
||||
markRead()
|
||||
onState?(false)
|
||||
onEnded?()
|
||||
updateNowPlaying()
|
||||
}
|
||||
|
||||
private func markRead() {
|
||||
guard !markedRead, let item else { return }
|
||||
markedRead = true
|
||||
Task { await request("POST", entryPath(item, "flags"), ["read": true]) }
|
||||
}
|
||||
|
||||
// MARK: - the lock screen and the car
|
||||
|
||||
private func wireRemoteCommands() {
|
||||
let c = MPRemoteCommandCenter.shared()
|
||||
c.playCommand.addTarget { [weak self] _ in self?.play(); return .success }
|
||||
c.pauseCommand.addTarget { [weak self] _ in self?.pause(); return .success }
|
||||
c.togglePlayPauseCommand.addTarget { [weak self] _ in
|
||||
guard let self else { return .commandFailed }
|
||||
self.isPlaying ? self.pause() : self.play()
|
||||
return .success
|
||||
}
|
||||
// The page's 15 back and 30 forward, so a steering wheel and the keyboard agree.
|
||||
c.skipBackwardCommand.preferredIntervals = [15]
|
||||
c.skipForwardCommand.preferredIntervals = [30]
|
||||
c.skipBackwardCommand.addTarget { [weak self] _ in
|
||||
guard let self else { return .commandFailed }
|
||||
self.seek(to: self.currentTime - 15)
|
||||
return .success
|
||||
}
|
||||
c.skipForwardCommand.addTarget { [weak self] _ in
|
||||
guard let self else { return .commandFailed }
|
||||
self.seek(to: self.currentTime + 30)
|
||||
return .success
|
||||
}
|
||||
c.changePlaybackPositionCommand.addTarget { [weak self] ev in
|
||||
guard let self, let e = ev as? MPChangePlaybackPositionCommandEvent else {
|
||||
return .commandFailed
|
||||
}
|
||||
self.seek(to: e.positionTime)
|
||||
return .success
|
||||
}
|
||||
}
|
||||
|
||||
private func updateNowPlaying() {
|
||||
guard let item else { return }
|
||||
var info: [String: Any] = [
|
||||
MPMediaItemPropertyTitle: item.title,
|
||||
MPMediaItemPropertyArtist: item.feedTitle,
|
||||
MPMediaItemPropertyAlbumTitle: item.feedTitle,
|
||||
MPNowPlayingInfoPropertyMediaType: MPNowPlayingInfoMediaType.audio.rawValue,
|
||||
MPNowPlayingInfoPropertyPlaybackRate: isPlaying ? rate : 0,
|
||||
MPNowPlayingInfoPropertyElapsedPlaybackTime: currentTime,
|
||||
]
|
||||
if let d = duration ?? item.duration.map(Double.init) {
|
||||
info[MPMediaItemPropertyPlaybackDuration] = d
|
||||
}
|
||||
let centre = MPNowPlayingInfoCenter.default()
|
||||
centre.nowPlayingInfo = info
|
||||
|
||||
guard let art = item.artwork, let url = Server.resolve(art) else { return }
|
||||
Task {
|
||||
guard let (data, _) = try? await session.data(from: url),
|
||||
let image = UIImage(data: data), self.item?.guid == item.guid else { return }
|
||||
// Read back, not `info`: by the time the picture arrives that elapsed time is stale,
|
||||
// and writing it would jerk the progress bar back.
|
||||
var latest = centre.nowPlayingInfo ?? [:]
|
||||
latest[MPMediaItemPropertyArtwork] = Self.artwork(image)
|
||||
centre.nowPlayingInfo = latest
|
||||
}
|
||||
}
|
||||
|
||||
/// Made outside the main actor: the system asks for the picture on a thread of its own.
|
||||
nonisolated private static func artwork(_ image: UIImage) -> MPMediaItemArtwork {
|
||||
MPMediaItemArtwork(boundsSize: image.size) { _ in image }
|
||||
}
|
||||
|
||||
/// The clock alone, each tick: rewriting the whole dictionary that often makes a car's
|
||||
/// progress bar stutter.
|
||||
private func updateElapsed(_ secs: Double) {
|
||||
guard var info = MPNowPlayingInfoCenter.default().nowPlayingInfo else { return }
|
||||
info[MPNowPlayingInfoPropertyElapsedPlaybackTime] = secs
|
||||
info[MPNowPlayingInfoPropertyPlaybackRate] = isPlaying ? rate : 0
|
||||
MPNowPlayingInfoCenter.default().nowPlayingInfo = info
|
||||
}
|
||||
|
||||
// MARK: - ipx
|
||||
|
||||
private func entryPath(_ item: Item, _ what: String) -> String {
|
||||
let esc = { (s: String) in s.addingPercentEncoding(withAllowedCharacters: .alphanumerics) ?? s }
|
||||
return "/api/entries/\(esc(item.feedId))/\(esc(item.guid))/\(what)"
|
||||
}
|
||||
|
||||
/// One call to ipx, signed in by the web view's cookies; its status, or nil if it never
|
||||
/// arrived. A position that does not save is saved again ten seconds on.
|
||||
@discardableResult
|
||||
private func request(_ method: String, _ path: String, _ json: [String: Any]? = nil) async -> Int? {
|
||||
guard let url = Server.resolve(path) else { return nil }
|
||||
var req = URLRequest(url: url)
|
||||
req.httpMethod = method
|
||||
if let json {
|
||||
req.setValue("application/json", forHTTPHeaderField: "Content-Type")
|
||||
req.httpBody = try? JSONSerialization.data(withJSONObject: json)
|
||||
}
|
||||
guard let (_, resp) = try? await session.data(for: req) else { return nil }
|
||||
return (resp as? HTTPURLResponse)?.statusCode
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user