Repository Public
1// SP Music iOS2// File: App/AppEnvironment.swift3// Description: Shared state of the app: services, session, synchronisation, playback state, actions used by the screens.4//5// Author: Simon-Pierre Boucher6// Contact: contact@spboucher.ai78import Foundation9import Observation10import SPMusicCore11import SwiftUI12import UIKit1314/// Live state of the downloads, for badges and progress rings. Progress ticks change `items` only; `version` moves15/// when a download starts, ends, fails or is removed, so lists reload only then.16@MainActor @Observable17final class DownloadsModel {18 private(set) var items: [String: DownloadProgress] = [:]19 private(set) var version = 02021 func load(from db: Database) async {22 var all: [String: DownloadProgress] = [:]23 for d in await db.downloads() { all[d.trackId] = DownloadProgress(trackId: d.trackId, state: d.state, bytesDone: d.bytesDone, bytesTotal: d.bytesTotal, error: d.error) }24 items = all; version += 125 }26 func apply(_ p: DownloadProgress) {27 let before = items[p.trackId]?.state28 if p.state == nil { items[p.trackId] = nil } else { items[p.trackId] = p }29 if before != p.state { version += 1 }30 }31 func state(_ trackId: String) -> DownloadState? { items[trackId]?.state }32 var activeCount: Int { items.values.filter { $0.state == .running || $0.state == .queued || $0.state == .preparing }.count }33 var failedCount: Int { items.values.filter { $0.state == .failed }.count }34}3536/// Everything the screens share. One instance for the process: the iPhone/iPad windows and the CarPlay scene see37/// the same player, the same library, the same downloads.38@MainActor @Observable39final class AppEnvironment {40 static let shared = AppEnvironment()4142 enum SyncState: Equatable { case idle, running, failed(String) }4344 let api: APIClient45 let auth: AuthService46 let db: Database47 let files: OfflineFiles48 let settings: AppSettings49 let network: NetworkMonitor50 let downloads: DownloadManager51 let downloadsModel = DownloadsModel()52 let sync: SyncEngine53 let audioSession = AudioSessionManager()54 let player: AudioPlayer55 let artwork: ArtworkStore5657 /// Moves whenever the local library changed: screens reload their data on it.58 private(set) var libraryVersion = 059 private(set) var syncState = SyncState.idle60 private(set) var lastSync: Date?61 private(set) var isLocked = false62 private(set) var started = false63 var showNowPlaying = false64 var toast: String?6566 @ObservationIgnored private var saveTask: Task<Void, Never>?67 @ObservationIgnored private var lastServerSave = Date.distantPast68 @ObservationIgnored private var backgroundedAt: Date?6970 var isOnline: Bool { network.status.online }71 /// Only what is on the device is shown: by choice, without a network, or when listening signed out.72 var downloadedOnly: Bool { settings.downloadedOnly || !isOnline || (auth.state != .signedIn && auth.offlineGuest) }7374 private init() {75 let env = ProcessInfo.processInfo.environment76 var base = URL(string: "https://music.spboucher.ai")!77 var defaults = UserDefaults.standard78 var files = OfflineFiles.standard()79 var tokens: SessionTokenStore = KeychainTokenStore()80 #if DEBUG81 // Automated tests point the app at the disposable backend and keep their state apart from the real one.82 if let s = env["SPMUSIC_BASE_URL"], let u = URL(string: s) {83 base = u84 defaults = UserDefaults(suiteName: "ai.spboucher.spmusic.tests")!85 let root = FileManager.default.temporaryDirectory.appendingPathComponent("spmusic-test-state", isDirectory: true)86 if env["SPMUSIC_RESET"] == "1" { try? FileManager.default.removeItem(at: root); defaults.removePersistentDomain(forName: "ai.spboucher.spmusic.tests") }87 files = OfflineFiles(root: root.appendingPathComponent("support"), caches: root.appendingPathComponent("caches"))88 tokens = InMemoryTokenStore(env["SPMUSIC_TEST_SESSION"])89 }90 #endif91 let device = UIDevice.current92 let version = Bundle.main.object(forInfoDictionaryKey: "CFBundleShortVersionString") as? String ?? "?"93 api = APIClient(baseURL: base, tokens: tokens, userAgent: "SPMusic-iOS/\(version) (\(device.userInterfaceIdiom == .pad ? "iPad" : "iPhone"); iOS \(device.systemVersion))")94 self.files = files95 settings = AppSettings(defaults: defaults)96 network = NetworkMonitor()97 // A database that cannot be opened is replaced: it only holds a copy of what the server and the disk know.98 if let d = try? Database(url: files.databaseURL) { db = d }99 else { try? FileManager.default.removeItem(at: files.databaseURL); db = try! Database(url: files.databaseURL) }100 auth = AuthService(api: api, defaults: defaults)101 let settings = settings, network = network102 #if DEBUG103 let configuration = env["SPMUSIC_BASE_URL"] != nil ? URLSessionConfiguration.ephemeral : DownloadManager.backgroundConfiguration(maxConnections: settings.transferSnapshot.maxConcurrentDownloads)104 #else105 let configuration = DownloadManager.backgroundConfiguration(maxConnections: settings.transferSnapshot.maxConcurrentDownloads)106 #endif107 downloads = DownloadManager(db: db, api: api, files: files, configuration: configuration, settings: { settings.transferSnapshot }, network: { network.current })108 sync = SyncEngine(db: db, api: api)109 player = AudioPlayer(resolver: SourceResolver(api: api, downloads: downloads, settings: { settings.transferSnapshot }, network: { network.current }), session: audioSession)110 artwork = ArtworkStore(api: api, files: files, network: network)111 #if DEBUG112 if env["SPMUSIC_MUTE"] == "1" { player.player.volume = 0 } // automated runs make no sound on the Mac113 #endif114 isLocked = self.settings.biometricLock115 }116117 /// Once per process, from the first scene (window or CarPlay) that appears.118 func start() async {119 guard !started else { return }120 started = true121 audioSession.configure()122 player.artworkProvider = { [artwork] id in await artwork.image(id, size: 640) }123 player.onStateChanged = { [weak self] in self?.schedulePlaybackSave() }124 player.onPlayed = { [weak self] event in Task { await self?.sync.recordPlay(event); self?.bump() } }125 player.onToggleFavorite = { [weak self] track in Task { await self?.setFavorite(track: track, !track.favorite) } }126 auth.whenSignedIn { [weak self] in await self?.signedIn() }127 auth.whenSignedOut { [weak self] in await self?.signedOut() }128 network.onChange { [weak self] status in if status.online { Task { await self?.networkReturned() } } }129 Task { [weak self, downloads] in for await p in downloads.updates { self?.downloadsModel.apply(p); if p.state == .done || p.state == nil { self?.bump() } } }130 await downloads.start()131 await downloadsModel.load(from: db)132 lastSync = await sync.lastSync()133 await restorePlayback()134 await auth.refresh()135 if isLocked { await unlock() }136 }137138 func bump() { libraryVersion &+= 1 }139140 // MARK: Session141142 private func signedIn() async {143 await syncNow()144 await downloads.retryFailed()145 await downloads.completeCompanions()146 }147 private func signedOut() async {148 await db.clearAccountData()149 bump()150 }151 private func networkReturned() async {152 if auth.state == .signedIn { if auth.unverified { await auth.refresh() } else { await syncNow() } }153 await downloads.pump()154 player.networkBecameAvailable()155 }156157 func syncNow(full: Bool = false) async {158 guard auth.state == .signedIn, syncState != .running else { return }159 syncState = .running160 do {161 let report = try await sync.sync(full: full)162 lastSync = Date(); syncState = .idle163 await downloads.reconcilePins()164 await downloadsModel.load(from: db)165 if player.queue.isEmpty, let p = report.playback { await adoptServerPlayback(p) }166 await refreshQueueTracks()167 bump()168 } catch let e as APIError where e.isUnauthenticated { syncState = .idle }169 catch { syncState = .failed((error as? APIError)?.errorDescription ?? "Synchronisation impossible"); bump() }170 }171172 func sceneBecameActive() async {173 if let at = backgroundedAt, settings.biometricLock, Date().timeIntervalSince(at) > 30 { isLocked = true }174 backgroundedAt = nil175 if isLocked { await unlock() }176 guard started, auth.state == .signedIn, isOnline else { return }177 if lastSync.map({ Date().timeIntervalSince($0) > 300 }) ?? true { await syncNow() }178 }179 func sceneWentToBackground() {180 backgroundedAt = Date()181 savePlaybackNow()182 }183 func unlock() async { if await BiometricLock.unlock() { isLocked = false } }184 func setBiometricLock(_ on: Bool) async {185 if on { guard await BiometricLock.unlock(reason: "Activer le verrouillage de SP Music") else { return } }186 settings.biometricLock = on187 }188189 // MARK: Playback state190191 private struct SavedPlayback: Codable { var queue: [String]; var index: Int; var positionMs: Int; var shuffle: Bool; var `repeat`: String }192193 private func schedulePlaybackSave() {194 saveTask?.cancel()195 saveTask = Task { [weak self] in196 try? await Task.sleep(for: .seconds(1))197 guard !Task.isCancelled else { return }198 self?.savePlaybackNow()199 }200 }201 private func savePlaybackNow() {202 let s = player.snapshot()203 let local = SavedPlayback(queue: s.queue, index: s.index, positionMs: s.positionMs, shuffle: s.shuffle, repeat: s.repeat)204 let sendToServer = auth.state == .signedIn && isOnline && Date().timeIntervalSince(lastServerSave) > 10205 if sendToServer { lastServerSave = Date() }206 Task { [db, api] in207 await db.setValue("playback.state", try? JSONEncoder().encode(local))208 if sendToServer { try? await api.savePlayback(s) }209 }210 }211 private func restorePlayback() async {212 guard let data = await db.value("playback.state"), let s = try? JSONDecoder().decode(SavedPlayback.self, from: data) else { return }213 await restore(queue: s.queue, index: s.index, positionMs: s.positionMs, shuffle: s.shuffle, repeatRaw: s.repeat)214 }215 private func adoptServerPlayback(_ p: UserSync.Playback) async {216 await restore(queue: p.queue, index: p.index, positionMs: p.positionMs, shuffle: p.shuffle, repeatRaw: p.repeat)217 }218 private func restore(queue ids: [String], index: Int, positionMs: Int, shuffle: Bool, repeatRaw: String) async {219 let tracks = await db.tracks(ids: ids)220 guard !tracks.isEmpty else { return }221 // Tracks deleted since are dropped; the position follows the surviving current track.222 let currentId = ids.indices.contains(index) ? ids[index] : nil223 let i = tracks.firstIndex { $0.id == currentId }224 player.restore(tracks: tracks, index: i ?? 0, position: i == nil ? 0 : Double(positionMs) / 1000, shuffle: shuffle, repeatMode: RepeatMode(rawValue: repeatRaw) ?? .off)225 }226 private func refreshQueueTracks() async {227 guard !player.queue.isEmpty else { return }228 let fresh = await db.tracks(ids: player.queue.tracks.map(\.id))229 player.refreshTracks(Dictionary(fresh.map { ($0.id, $0) }, uniquingKeysWith: { a, _ in a }))230 }231232 // MARK: Actions shared by the screens233234 func play(_ tracks: [Track], startAt index: Int = 0, shuffle: Bool? = nil) {235 // Offline, tracks that are not on the device cannot be played: leave them out rather than fail on each.236 guard downloadedOnly else { player.play(tracks, startAt: index, shuffle: shuffle, pickRandomStart: shuffle == true); return }237 let chosen = tracks.indices.contains(index) ? tracks[index].id : nil238 let playable = tracks.filter { downloadsModel.state($0.id) == .done }239 guard !playable.isEmpty else { toast = "Aucun de ces titres n'est téléchargé."; return }240 player.play(playable, startAt: playable.firstIndex { $0.id == chosen } ?? 0, shuffle: shuffle, pickRandomStart: shuffle == true)241 }242243 func setFavorite(track: Track, _ on: Bool) async {244 await sync.setFavorite(kind: "track", id: track.id, on: on)245 await refreshQueueTracks(); bump()246 }247 func setFavorite(album: Album, _ on: Bool) async {248 await sync.setFavorite(kind: "album", id: album.id, on: on); bump()249 }250251 /// Playlist edits need the server (they are refused offline with a message rather than queued blindly).252 func playlistEdit(_ work: @Sendable (APIClient) async throws -> Void) async -> Bool {253 guard isOnline, auth.state == .signedIn else { toast = "Connexion requise pour modifier une liste de lecture."; return false }254 do {255 try await work(api)256 try await sync.refreshAccount()257 await downloads.reconcilePins()258 bump(); return true259 } catch { toast = (error as? APIError)?.errorDescription ?? "Modification impossible."; return false }260 }261262 /// nil: the download started. Otherwise the number of bytes to confirm on a cellular connection.263 func download(_ kind: PinKind, _ id: String, confirmed: Bool = false) async -> Int64? {264 let ids: [String] = switch kind {265 case .track: [id]266 case .album: await db.trackIds(albumId: id)267 case .playlist: await db.trackIds(playlistId: id)268 case .library: await db.allTrackIds()269 }270 let bytes = await downloads.estimate(trackIds: ids)271 if !confirmed, NetworkPolicy.needsCellularConfirmation(settings.transfer, network.status, bytes: bytes) { return bytes }272 await downloads.pin(kind, id)273 await downloadsModel.load(from: db)274 if let blocked = NetworkPolicy.download(settings.transfer, network.status) {275 toast = switch blocked {276 case .offline: "Hors ligne : le téléchargement commencera au retour de la connexion."277 case .cellularNotAllowed: "En attente du Wi-Fi (téléchargements cellulaires désactivés)."278 case .lowDataMode: "En attente : le mode Données réduites est actif."279 }280 }281 bump()282 return nil283 }284 func removeDownload(_ kind: PinKind, _ id: String) async {285 if kind == .track { await downloads.removeTrack(id) } else { await downloads.unpin(kind, id) }286 await downloadsModel.load(from: db); bump()287 }288 func removeAllDownloads() async {289 await downloads.removeEverything()290 await downloadsModel.load(from: db); bump()291 }292}293