SPB Git

Repository Public

AppEnvironment.swift 29.8 KB 606 lines swift

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
Files main
Menu

Theme