Repository Public
1// Author: Simon-Pierre Boucher — contact@spboucher.ai2// File: App/AppEnvironment.swift3// Description: Application model: session lifecycle, sign-in, synchronisation, downloads and playback wiring.4import SwiftUI5import AVFoundation6import SPMusicCore78enum SidebarItem: Hashable {9 case home, albums, artists, tracks, favorites, history, downloads, admin10 case playlist(String)11}1213enum Route: Hashable {14 case album(String), artist(String), playlist(String)15}1617struct Toast: Identifiable, Equatable {18 let id = UUID()19 var text: String20 var isError = false21}2223/// The application's state and the only place where the interface meets the core: session lifecycle, sign-in,24/// synchronisation, downloads, playback wiring. Views read it and call its methods; they never talk to the network.25@Observable26final class AppModel {27 enum Phase { case launching, signedOut, ready }2829 let settings = AppSettings()30 let connectivity = Connectivity()31 let playback = PlaybackController()32 @ObservationIgnored let outputs = AudioOutputManager()33 @ObservationIgnored private(set) var api: APIClient34 @ObservationIgnored private(set) var session: LibrarySession?35 @ObservationIgnored let nowPlaying = NowPlayingBridge()36 @ObservationIgnored let passkeys = PasskeySignIn()37 @ObservationIgnored private var tasks: [Task<Void, Never>] = []38 @ObservationIgnored private var lastSavedSnapshot: PlaybackSnapshot?39 @ObservationIgnored private var lastMatchedInfo: DecoderInfo?40 @ObservationIgnored private var syncDebounce: Task<Void, Never>?41 @ObservationIgnored var externalArtwork: [String: NSImage] = [:]4243 var phase: Phase = .launching44 var account: Account?45 var isOnline = true46 var sessionExpired = false47 /// Bumped when the local library changes; views reload what they show.48 var libraryRevision = 049 var playlists: [Playlist] = []50 var liveProgress: [String: LiveProgress] = [:]51 var downloadSpeed: Double = 052 var activeDownloads = 053 var downloadsPaused = false54 var syncing = false55 var lastSync: Date?56 var pendingChanges = 057 var toasts: [Toast] = []58 var selection: SidebarItem? = .home59 var path: [Route] = []60 var searchText = ""61 var showNowPlaying = false62 var showQueue = false63 var outputDevices: [OutputDevice] = []64 var libraryRootAvailable = true65 // Sign-in66 var deviceLink: WireDeviceStart?67 var signInError: String?68 var signingIn = false69 // Library move70 var moveProgress: Double?7172 var isAdmin: Bool { account?.isAdmin == true }73 var admin: AdminAPI? { isAdmin ? AdminAPI(api: api) : nil }74 /// Offline, or when the listener asks for it, lists show only what is on this Mac.75 var downloadedOnly: Bool { settings.downloadedOnly || !isOnline }76 var store: LibraryStore? { session?.store }7778 static let isDebugBuild: Bool = { Bundle.main.bundleIdentifier?.hasSuffix(".debug") == true }()79 static var dataRoot: URL {80 if let p = UserDefaults.standard.string(forKey: "SPMusicDataDir") { return URL(fileURLWithPath: (p as NSString).expandingTildeInPath, isDirectory: true) }81 let base = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask)[0]82 return base.appendingPathComponent(isDebugBuild ? "SP Music Debug" : "SP Music", isDirectory: true)83 }8485 init() {86 // Development builds pointed at a test data folder keep the test session in that folder; everything else uses the Keychain.87 let devMode = Self.isDebugBuild && UserDefaults.standard.string(forKey: "SPMusicDataDir") != nil88 let credentials: CredentialStore = devMode ? FileCredentialStore(url: Self.dataRoot.appendingPathComponent("dev-session.json"))89 : KeychainCredentialStore(service: (Bundle.main.bundleIdentifier ?? "ai.spboucher.spmusic") + ".session")90 api = APIClient(baseURL: settings.serverURL, credentials: credentials, connectivity: connectivity)91 connectivity.forcedOffline = settings.forcedOffline92 playback.apply(settings.engineSettings)93 playback.onPlayed = { [weak self] track, ms, completed, kind in self?.recordPlay(track, ms, completed, kind) }94 playback.onTrackChanged = { [weak self] in self?.trackChanged() }95 nowPlaying.attach(self)96 }9798 // MARK: Launch and session99100 func start() async {101 let api = self.api102 connectivity.start(probe: { await api.probe() })103 api.setUnauthenticatedHandler { [weak self] in Task { @MainActor in self?.sessionExpired = true } }104 tasks.append(Task { [weak self] in105 guard let states = self?.connectivity.states() else { return }106 for await online in states { self?.connectivityChanged(online) }107 })108 refreshOutputs()109 outputs.observe { [weak self] in Task { @MainActor in self?.refreshOutputs() } }110 tasks.append(Task { [weak self] in111 while !Task.isCancelled { try? await Task.sleep(nanoseconds: 500_000_000); self?.housekeeping() }112 })113114 if Self.isDebugBuild, let token = UserDefaults.standard.string(forKey: "SPMusicDevToken") {115 // Development only: a session issued for the test backend, handed on the command line.116 try? api.adopt(Credential(serverURL: api.baseURL, sessionToken: token, csrfToken: "", account: Account(id: "", email: "", displayName: "", role: "listener", isOwner: false), expiresAt: nil))117 _ = try? await AuthService(api: api).refresh()118 }119 if let c = api.currentCredential, !c.account.id.isEmpty {120 await open(c.account)121 } else {122 phase = .signedOut123 }124 }125126 private func open(_ account: Account) async {127 do {128 let root = UserDefaults.standard.string(forKey: "SPMusicLibraryRoot").map { URL(fileURLWithPath: ($0 as NSString).expandingTildeInPath, isDirectory: true) }129 let s = try await LibrarySession(api: api, account: account, dataRoot: Self.dataRoot, libraryRoot: root, maxConcurrentDownloads: settings.maxConcurrentDownloads)130 session = s131 self.account = account132 sessionExpired = false133 libraryRootAvailable = s.storage.isRootAvailable134 let settings = self.settings135 playback.configure(resolver: { [s] track in try await s.resolve(track, normalize: await MainActor.run { settings.normalize && !settings.directMode }) },136 isAvailableOffline: { [s] in s.isAvailableOffline($0) },137 isOnline: { [connectivity] in connectivity.isOnline })138 observe(s)139 await reloadPlaylists()140 await restorePlayback(s)141 phase = .ready142 await s.downloads.start()143 if connectivity.isOnline { Task { await self.refreshAndSync() } }144 handleLaunchArguments()145 } catch {146 signInError = "Impossible d’ouvrir la bibliothèque locale : \(error.localizedDescription)"147 phase = .signedOut148 }149 }150151 private func observe(_ s: LibrarySession) {152 tasks.append(Task { [weak self] in153 for await _ in await s.store.changes() {154 guard let self else { return }155 self.libraryRevision &+= 1156 await self.reloadPlaylists()157 self.pendingChanges = await s.store.pendingOpCount()158 for n in await s.store.takeNotices() { self.toast(n) }159 // Give SwiftUI a breath between bursts of changes (a sync applies many rows).160 try? await Task.sleep(nanoseconds: 120_000_000)161 }162 })163 tasks.append(Task { [weak self] in164 for await event in await s.downloads.events() {165 guard let self else { return }166 self.liveProgress = await s.downloads.liveProgress()167 self.downloadSpeed = await s.downloads.totalSpeed168 self.activeDownloads = await s.downloads.activeCount169 switch event {170 case .failed(_, let message): self.toast("Téléchargement : \(message)", error: true)171 case .idle(let completed):172 if self.settings.notifyDownloads { Notifier.downloadsFinished(count: completed) }173 if self.settings.normalize { Task.detached(priority: .background) { await s.analyzeLoudness(limit: 200) } }174 default: break175 }176 }177 })178 tasks.append(Task { [weak self] in179 // Periodic synchronisation while the app runs.180 while !Task.isCancelled {181 try? await Task.sleep(nanoseconds: 300 * 1_000_000_000)182 if self?.connectivity.isOnline == true { await self?.syncNow() }183 }184 })185 }186187 private func closeSession() async {188 for t in tasks.dropFirst(2) { t.cancel() } // keep the connectivity and housekeeping loops189 tasks = Array(tasks.prefix(2))190 playback.stop()191 if let s = session { await s.shutdown() }192 session = nil; account = nil; playlists = []; liveProgress = [:]; path = []; selection = .home193 }194195 private func connectivityChanged(_ online: Bool) {196 let was = isOnline197 isOnline = online198 guard phase == .ready, online, !was else { return }199 Task { await refreshAndSync() }200 }201202 private func refreshAndSync() async {203 guard let s = session else { return }204 do {205 let fresh = try await s.auth.refresh()206 account = fresh; sessionExpired = false207 await s.downloads.sessionRestored()208 } catch APIError.unauthenticated { sessionExpired = true; return } catch { return }209 await syncNow()210 }211212 func syncNow(full: Bool = false) async {213 guard let s = session, !syncing, connectivity.isOnline, !sessionExpired else { return }214 syncing = true215 defer { syncing = false }216 do {217 let r = try await s.sync.sync(full: full)218 lastSync = Date()219 if r.conflicts > 0 { toast("Une liste modifiée ici et ailleurs a été conservée en deux versions.") }220 s.storage.trimStreamCache(limit: Int64(settings.streamCacheLimitGB * 1_073_741_824))221 } catch APIError.unauthenticated { sessionExpired = true222 } catch { if !APIClient.isOffline(error) { toast("Synchronisation impossible : \(describe(error))", error: true) } }223 pendingChanges = await s.store.pendingOpCount()224 }225226 /// After a local change: sends it soon, without a request per keystroke.227 func scheduleSync() {228 syncDebounce?.cancel()229 syncDebounce = Task { [weak self] in230 try? await Task.sleep(nanoseconds: 1_500_000_000)231 guard !Task.isCancelled else { return }232 await self?.syncNow()233 }234 }235236 func setForcedOffline(_ on: Bool) {237 settings.forcedOffline = on238 connectivity.forcedOffline = on239 if !on { Task { await refreshAndSync() } }240 }241242 func describe(_ error: Error) -> String {243 switch error {244 case APIError.offline: "serveur injoignable"245 case APIError.unauthenticated: "session expirée"246 case APIError.http(_, _, let message): message247 default: error.localizedDescription248 }249 }250251 func toast(_ text: String, error: Bool = false) {252 let t = Toast(text: text, isError: error)253 toasts.append(t)254 if toasts.count > 3 { toasts.removeFirst(toasts.count - 3) }255 Task { [weak self] in256 try? await Task.sleep(nanoseconds: (error ? 7 : 4) * 1_000_000_000)257 self?.toasts.removeAll { $0.id == t.id }258 }259 }260261 private func reloadPlaylists() async {262 guard let s = session else { return }263 let p = await s.store.playlists()264 if p != playlists { playlists = p }265 libraryRootAvailable = s.storage.isRootAvailable266 }267268 // MARK: Sign-in and out269270 func beginDeviceLink() async {271 signInError = nil; signingIn = true272 defer { signingIn = false }273 let auth = AuthService(api: api)274 do {275 let start = try await auth.startDeviceLink()276 deviceLink = start277 if let url = URL(string: start.verificationUrl) { NSWorkspace.shared.open(url) }278 let account = try await auth.awaitDeviceLink(start)279 deviceLink = nil280 await signedIn(account)281 } catch is CancellationError { deviceLink = nil282 } catch {283 deviceLink = nil284 signInError = switch error {285 case APIError.offline: "Le serveur est injoignable. Vérifiez votre connexion."286 case APIError.http(403, _, _): "La demande a été refusée dans le navigateur."287 case APIError.http(410, _, _): "Le code a expiré. Recommencez."288 case APIError.http(429, _, _): "Trop de tentatives. Réessayez dans quelques minutes."289 default: "La connexion a échoué : \(describe(error))"290 }291 }292 }293294 func signInWithPasskey() async {295 signInError = nil; signingIn = true296 defer { signingIn = false }297 let auth = AuthService(api: api)298 do {299 let challenge = try await auth.passkeyChallenge()300 let a = try await passkeys.assert(challenge: challenge.challenge, relyingParty: challenge.relyingParty)301 let account = try await auth.passkeyVerify(challenge, credentialID: a.credentialID, clientDataJSON: a.clientDataJSON, authenticatorData: a.authenticatorData, signature: a.signature, userHandle: a.userHandle)302 await signedIn(account)303 } catch PasskeySignIn.Failure.cancelled { /* the listener closed the system sheet */304 } catch PasskeySignIn.Failure.notAssociated {305 signInError = "Cette copie de l’application ne peut pas utiliser les clés d’accès de music.spboucher.ai (installez SP Music dans le dossier Applications). Utilisez « Associer avec le navigateur »."306 } catch {307 signInError = switch error {308 case APIError.offline: "Le serveur est injoignable. Vérifiez votre connexion."309 case APIError.http(401, _, _): "Connexion refusée : cette clé d’accès n’est pas reconnue."310 default: "La connexion par clé d’accès a échoué : \(describe(error))"311 }312 }313 }314315 private func signedIn(_ account: Account) async {316 if session != nil {317 // Signing in again after the session expired: same library, new session.318 if account.id == self.account?.id { sessionExpired = false; self.account = account; await session?.downloads.sessionRestored(); await syncNow(); return }319 await closeSession()320 }321 await open(account)322 }323324 /// Signs out. The music downloaded on this Mac stays where it is; signing in again finds it.325 func signOut() async {326 let auth = AuthService(api: api)327 await closeSession()328 await auth.signOut()329 sessionExpired = false330 phase = .signedOut331 }332333 // MARK: Playback helpers334335 func play(_ tracks: [Track], at index: Int = 0, shuffle: Bool? = nil) {336 let playable = downloadedOnly && !isOnline ? tracks.filter { session?.isAvailableOffline($0) ?? false } : tracks337 guard !playable.isEmpty else { toast("Aucun de ces titres n’est disponible hors ligne."); return }338 let target = tracks.indices.contains(index) ? tracks[index].id : nil339 let start = target.flatMap { id in playable.firstIndex { $0.id == id } } ?? 0340 playback.play(playable, startAt: start, shuffle: shuffle)341 }342 func playAlbum(_ id: String, shuffle: Bool? = nil) async {343 guard let s = store else { return }344 play(await s.albumTracks(id), shuffle: shuffle)345 }346 func playPlaylist(_ id: String, shuffle: Bool? = nil) async {347 guard let s = store else { return }348 play(await s.playlistEntries(id).map(\.track), shuffle: shuffle)349 }350351 private func recordPlay(_ track: Track, _ ms: Int, _ completed: Bool, _ kind: SourceKind) {352 guard track.externalFileURL == nil, let s = session else { return }353 let play = PlayRecord(id: UUID().uuidString.lowercased(), trackID: track.id, playedAt: Date(), listenedMs: ms, completed: completed, source: kind == .stream ? "stream" : "local")354 Task { await s.store.addPlay(play); self.scheduleSync() }355 }356357 private func trackChanged() {358 nowPlaying.update(self, artworkChanged: true)359 }360361 private func restorePlayback(_ s: LibrarySession) async {362 guard let json = await s.store.value("playback"), let snap = try? JSONDecoder().decode(PlaybackSnapshot.self, from: Data(json.utf8)) else { return }363 let tracks = await s.store.tracks(ids: snap.trackIDs)364 guard !tracks.isEmpty else { return }365 // The saved index refers to the saved list; tracks deleted since may have shifted it.366 var fixed = snap367 if snap.trackIDs.indices.contains(snap.index), let i = tracks.firstIndex(where: { $0.id == snap.trackIDs[snap.index] }) { fixed.index = i } else { fixed.index = 0; fixed.position = 0 }368 playback.restore(fixed, tracks: tracks)369 lastSavedSnapshot = playback.snapshot()370 }371372 /// Twice a second: Now Playing clock, sample-rate matching, playback state persistence.373 private func housekeeping() {374 nowPlaying.update(self, artworkChanged: false)375 if settings.matchSampleRate, let info = playback.info, info != lastMatchedInfo {376 lastMatchedInfo = info377 let device = settings.outputDeviceUID.isEmpty ? AudioOutputManager.defaultOutputID : (AudioOutputManager.device(uid: settings.outputDeviceUID)?.id ?? AudioOutputManager.defaultOutputID)378 if AudioOutputManager.sampleRate(of: device) != info.sampleRate { AudioOutputManager.setSampleRate(info.sampleRate, on: device) }379 }380 let snap = playback.snapshot()381 if let last = lastSavedSnapshot, last.trackIDs == snap.trackIDs, last.index == snap.index, abs(last.position - snap.position) < 5, last.shuffle == snap.shuffle, last.repeatMode == snap.repeatMode { return }382 lastSavedSnapshot = snap383 if let s = session, let data = try? JSONEncoder().encode(snap), let json = String(data: data, encoding: .utf8) { Task { await s.store.setValue("playback", json) } }384 }385386 func applyAudioSettings() { playback.apply(settings.engineSettings) }387388 func refreshOutputs() {389 outputDevices = AudioOutputManager.outputDevices()390 let uid = settings.outputDeviceUID391 if uid.isEmpty { playback.engine.setOutputDevice(AudioOutputManager.defaultOutputID) }392 else if !outputDevices.contains(where: { $0.uid == uid }) {393 // The chosen device was unplugged: back to the system's output.394 settings.outputDeviceUID = ""395 playback.engine.setOutputDevice(AudioOutputManager.defaultOutputID)396 toast("Sortie audio déconnectée : retour à la sortie du système.")397 }398 }399 func selectOutput(uid: String) {400 settings.outputDeviceUID = uid401 let id = uid.isEmpty ? AudioOutputManager.defaultOutputID : (AudioOutputManager.device(uid: uid)?.id ?? AudioOutputManager.defaultOutputID)402 if !playback.engine.setOutputDevice(id) { toast("Cette sortie audio n’a pas pu être sélectionnée.", error: true) }403 lastMatchedInfo = nil404 outputDevices = AudioOutputManager.outputDevices()405 }406 var currentOutput: OutputDevice? {407 settings.outputDeviceUID.isEmpty ? outputDevices.first { $0.isDefault } : outputDevices.first { $0.uid == settings.outputDeviceUID }408 }409410 // MARK: Library actions411412 func toggleFavorite(_ track: Track) {413 guard track.externalFileURL == nil, let s = store else { return }414 Task { try? await s.setFavorite(kind: "track", id: track.id, on: !track.favorite); self.scheduleSync() }415 }416 func toggleFavorite(_ album: Album) {417 guard let s = store else { return }418 Task { try? await s.setFavorite(kind: "album", id: album.id, on: !album.favorite); self.scheduleSync() }419 }420 func createPlaylist(name: String, trackIDs: [String] = []) async -> String? {421 guard let s = store else { return nil }422 let clean = name.trimmingCharacters(in: .whitespacesAndNewlines)423 guard !clean.isEmpty else { return nil }424 let id = try? await s.createPlaylist(name: String(clean.prefix(120)), trackIDs: trackIDs)425 scheduleSync()426 return id427 }428 func addToPlaylist(_ id: String, tracks: [Track]) {429 guard let s = store else { return }430 let ids = tracks.filter { $0.externalFileURL == nil }.map(\.id)431 Task {432 try? await s.addToPlaylist(id, trackIDs: ids)433 if await s.isPinned(.playlist, id: id) { _ = await self.session?.downloads.enqueue(ids) }434 self.toast(ids.count == 1 ? "Ajouté à la liste." : "\(ids.count) titres ajoutés à la liste.")435 self.scheduleSync()436 }437 }438 func renamePlaylist(_ id: String, name: String) {439 guard let s = store, !name.trimmingCharacters(in: .whitespaces).isEmpty else { return }440 Task { try? await s.renamePlaylist(id, name: String(name.trimmingCharacters(in: .whitespaces).prefix(120))); self.scheduleSync() }441 }442 func deletePlaylist(_ id: String) {443 guard let s = store else { return }444 if selection == .playlist(id) { selection = .home }445 path.removeAll { $0 == .playlist(id) }446 Task { try? await s.deletePlaylist(id); self.scheduleSync() }447 }448 func setPlaylistOrder(_ id: String, entryIDs: [String]) {449 guard let s = store else { return }450 Task { try? await s.setPlaylistEntries(id, entryIDs: entryIDs); self.scheduleSync() }451 }452453 // MARK: Downloads454455 func download(_ tracks: [Track]) {456 guard let s = session else { return }457 guard libraryRootAvailable else { toast("Le dossier de la bibliothèque est indisponible (disque externe débranché ?).", error: true); return }458 Task { _ = await s.downloads.enqueue(tracks.filter { $0.externalFileURL == nil }.map(\.id)) }459 }460 func removeDownloads(_ tracks: [Track]) {461 guard let s = session else { return }462 Task { await s.downloads.remove(tracks.map(\.id)) }463 }464 func downloadAlbum(_ album: Album) {465 guard let s = session else { return }466 Task { await s.pinAndDownload(.album, id: album.id, trackIDs: await s.store.albumTracks(album.id).map(\.id)) }467 }468 func removeAlbumDownload(_ album: Album) {469 guard let s = session else { return }470 Task { await s.unpinAndRemove(.album, id: album.id, trackIDs: await s.store.albumTracks(album.id).map(\.id)) }471 }472 func downloadPlaylist(_ id: String) {473 guard let s = session else { return }474 Task { await s.pinAndDownload(.playlist, id: id, trackIDs: await s.store.playlistEntries(id).map(\.track.id)) }475 }476 func removePlaylistDownload(_ id: String) {477 guard let s = session else { return }478 Task {479 await s.store.setPinned(.playlist, id: id, false)480 // Tracks that another pinned album or playlist still needs stay; the others go.481 let ids = await s.store.playlistEntries(id).map(\.track.id)482 let stillNeeded = Set(await s.store.missingPinnedTrackIDs())483 var removable: [String] = []484 for t in ids { await s.store.setDownloadState(t, .paused); removable.append(t) }485 let needed = Set(await s.store.missingPinnedTrackIDs()).union(stillNeeded)486 for t in ids { await s.store.setDownloadState(t, .done) }487 await s.downloads.remove(removable.filter { !needed.contains($0) })488 }489 }490 /// Bytes still to fetch for the whole library, and the free space where it would go.491 func libraryDownloadEstimate() async -> (needed: Int64, free: Int64, tracks: Int) {492 guard let s = session else { return (0, 0, 0) }493 let ids = await s.store.allTrackIDs()494 let missing = await s.store.tracks(ids: ids).filter { !$0.isDownloaded }495 return (missing.reduce(0) { $0 + $1.sizeBytes }, StorageManager.freeSpace(at: s.storage.libraryRoot), missing.count)496 }497 func downloadLibrary() {498 guard let s = session else { return }499 Task { await s.pinAndDownload(.library, id: "all", trackIDs: await s.store.allTrackIDs()) }500 }501 func stopKeepingLibraryOffline() { Task { await session?.store.setPinned(.library, id: "all", false) } }502 func setDownloadsPaused(_ paused: Bool) {503 downloadsPaused = paused504 Task { if paused { await session?.downloads.pauseAll() } else { await session?.downloads.resumeAll() } }505 }506 func setMaxConcurrentDownloads(_ n: Int) {507 settings.maxConcurrentDownloads = n508 Task { await session?.downloads.setMaxConcurrent(n) }509 }510511 func moveLibrary(to url: URL) async {512 guard let s = session else { return }513 moveProgress = 0514 defer { moveProgress = nil }515 do {516 try await s.moveLibrary(to: url) { done, total in Task { @MainActor in self.moveProgress = total > 0 ? Double(done) / Double(total) : 1 } }517 libraryRootAvailable = s.storage.isRootAvailable518 libraryRevision &+= 1519 toast("Bibliothèque déplacée.")520 } catch StorageError.destinationNotEmpty { toast("Ce dossier contient déjà des fichiers. Choisissez un dossier vide.", error: true)521 } catch StorageError.insufficientSpace(let needed, let free) { toast("Espace insuffisant : \(Format.bytes(needed)) nécessaires, \(Format.bytes(free)) libres.", error: true)522 } catch { toast("Le déplacement a échoué ; rien n’a été supprimé. \(error.localizedDescription)", error: true) }523 }524525 // MARK: Local files (Open With, drag and drop)526527 static let audioExtensions: Set<String> = ["flac", "mp3", "m4a", "mp4", "wav", "wave", "aif", "aiff", "aifc", "aac", "caf"]528529 func openFiles(_ urls: [URL]) {530 let files = urls.filter { Self.audioExtensions.contains($0.pathExtension.lowercased()) }.sorted { $0.lastPathComponent.localizedStandardCompare($1.lastPathComponent) == .orderedAscending }531 guard !files.isEmpty else { return }532 Task {533 var tracks: [Track] = []534 for url in files { tracks.append(await self.externalTrack(url)) }535 self.playback.play(tracks)536 }537 }538539 private func externalTrack(_ url: URL) async -> Track {540 let asset = AVURLAsset(url: url)541 var t = Track(id: "file:" + url.path, title: url.deletingPathExtension().lastPathComponent, externalFileURL: url)542 if let d = try? await asset.load(.duration), d.isNumeric { t.durationMs = Int(d.seconds * 1000) }543 if let items = try? await asset.load(.commonMetadata) {544 for item in items {545 guard let key = item.commonKey else { continue }546 switch key {547 case .commonKeyTitle: if let v = try? await item.load(.stringValue), !v.isEmpty { t.title = v }548 case .commonKeyArtist: if let v = try? await item.load(.stringValue) { t.artistName = v; t.albumArtistName = v }549 case .commonKeyAlbumName: if let v = try? await item.load(.stringValue) { t.albumTitle = v }550 case .commonKeyArtwork: if let d = try? await item.load(.dataValue), let img = NSImage(data: d) { externalArtwork[t.id] = img }551 default: break552 }553 }554 }555 t.codec = url.pathExtension.lowercased() == "m4a" ? "aac" : url.pathExtension.lowercased()556 t.container = url.pathExtension.lowercased()557 return t558 }559560 // MARK: Navigation561562 func show(_ route: Route) { showNowPlaying = false; if path.last != route { path.append(route) } }563 func select(_ item: SidebarItem) { path = []; selection = item; showNowPlaying = false }564565 /// Development and functional tests: `-SPMusicRoute albums|artists|tracks|downloads|admin|album:<id>|nowplaying`, `-SPMusicPlay <track title>`.566 private func handleLaunchArguments() {567 guard Self.isDebugBuild else { return }568 let d = UserDefaults.standard569 if let r = d.string(forKey: "SPMusicRoute") {570 switch r {571 case "albums": selection = .albums572 case "artists": selection = .artists573 case "tracks": selection = .tracks574 case "favorites": selection = .favorites575 case "history": selection = .history576 case "downloads": selection = .downloads577 case "admin": selection = .admin578 default:579 Task {580 try? await Task.sleep(nanoseconds: 2_500_000_000)581 guard let s = self.store else { return }582 if r.hasPrefix("album:"), let a = await s.albums().first(where: { $0.title == String(r.dropFirst(6)) }) { self.selection = .albums; self.path = [.album(a.id)] }583 if r.hasPrefix("artist:"), let a = await s.artists().first(where: { $0.name == String(r.dropFirst(7)) }) { self.selection = .artists; self.path = [.artist(a.id)] }584 if r.hasPrefix("search:") { self.searchText = String(r.dropFirst(7)) }585 }586 }587 }588 if let title = d.string(forKey: "SPMusicPlay") {589 Task {590 try? await Task.sleep(nanoseconds: 3_000_000_000)591 guard let s = self.store, let t = await s.tracks().first(where: { $0.title == title }) else { return }592 let album = await s.albumTracks(t.albumID)593 self.play(album, at: album.firstIndex { $0.id == t.id } ?? 0)594 if d.bool(forKey: "SPMusicShowNowPlaying") { self.showNowPlaying = true }595 if let seek = d.object(forKey: "SPMusicSeek") as? Double ?? Double(d.string(forKey: "SPMusicSeek") ?? "") { try? await Task.sleep(nanoseconds: 1_500_000_000); self.playback.seek(to: seek) }596 }597 }598 if let album = d.string(forKey: "SPMusicDownloadAlbum") {599 Task {600 try? await Task.sleep(nanoseconds: 3_000_000_000)601 if let s = self.store, let a = await s.albums().first(where: { $0.title == album }) { self.downloadAlbum(a) }602 }603 }604 }605}606