URLSession・ミラー・SHA-256 で 2 GB のモデルを iOS でバックグラウンドダウンロードする

ls -l LFM2-2.6B-Q4_K_M.gguf          # 1563668704
shasum -a 256 LFM2-2.6B-Q4_K_M.gguf  # 384bc877b6c37064982f96885bef69e4475919f5969218ed4e3b9399ae0340df

import Foundation

struct ModelSpec: Sendable {
    let id: String
    let urls: [URL]          // tried in order: your mirror first, the original last
    let fileName: String
    let bytes: Int64         // for progress when the server sends no Content-Length
    let sha256: String

    static let lfm2 = ModelSpec(
        id: "lfm2-2.6b-q4_k_m",
        urls: [
            URL(string: "https://cdn.example.com/models/lfm2-2.6b-q4_k_m.gguf")!,
            URL(string: "https://huggingface.co/LiquidAI/LFM2-2.6B-GGUF/resolve/main/LFM2-2.6B-Q4_K_M.gguf")!,
        ],
        fileName: "lfm2-2.6b-q4_k_m.gguf",
        bytes: 1_563_668_704,
        sha256: "384bc877b6c37064982f96885bef69e4475919f5969218ed4e3b9399ae0340df"
    )
}

import Foundation
import CryptoKit
import Observation

@MainActor
@Observable
final class ModelDownloader: NSObject {
    enum State: Equatable {
        case notDownloaded, downloading(Double), verifying, ready, failed(String)
    }

    let spec: ModelSpec
    private(set) var state: State = .notDownloaded

    @ObservationIgnored private var session: URLSession!
    @ObservationIgnored private var task: URLSessionDownloadTask?
    @ObservationIgnored private var urlIndex = 0
    @ObservationIgnored static var completions: [String: () -> Void] = [:]

    nonisolated var identifier: String { "model.\(spec.id)" }

    nonisolated var file: URL {
        let dir = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask)[0]
            .appendingPathComponent("Models", isDirectory: true)
        try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
        return dir.appendingPathComponent(spec.fileName)
    }

    init(_ spec: ModelSpec) {
        self.spec = spec
        super.init()
        let config = URLSessionConfiguration.background(withIdentifier: identifier)
        config.isDiscretionary = false          // start now, not when iOS finds it convenient
        config.sessionSendsLaunchEvents = true  // relaunch the app when the transfer finishes
        session = URLSession(configuration: config, delegate: self, delegateQueue: .main)

        if FileManager.default.fileExists(atPath: file.path) { state = .ready; return }
        reattach()
    }
}

extension ModelDownloader {
    private func reattach() {
        session.getAllTasks { [weak self] tasks in
            guard let running = tasks.first as? URLSessionDownloadTask else { return }
            Task { @MainActor in
                guard let self else { return }
                self.task = running
                self.urlIndex = Int(running.taskDescription ?? "0") ?? 0
                self.state = .downloading(self.fraction(running.countOfBytesReceived,
                                                         running.countOfBytesExpectedToReceive))
            }
        }
    }

    func download() {
        guard task == nil, state != .ready else { return }
        urlIndex = 0
        start()
    }

    private func start() {
        guard urlIndex < spec.urls.count else {
            state = .failed("The download didn't work. Check the connection and try again, ideally on Wi-Fi.")
            return
        }
        state = .downloading(0)
        task = session.downloadTask(with: spec.urls[urlIndex])
        task?.taskDescription = String(urlIndex)   // survives relaunch: which mirror is this?
        task?.resume()
    }

    private func next() {
        task = nil
        urlIndex += 1
        start()
    }

    private func fraction(_ written: Int64, _ expected: Int64) -> Double {
        let total = expected > 0 ? expected : spec.bytes
        return min(1, Double(written) / Double(max(total, 1)))
    }
}

extension ModelDownloader: URLSessionDownloadDelegate {
    nonisolated func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask,
                                didWriteData _: Int64, totalBytesWritten written: Int64,
                                totalBytesExpectedToWrite expected: Int64) {
        Task { @MainActor in self.state = .downloading(self.fraction(written, expected)) }
    }

    nonisolated func urlSession(_ session: URLSession, downloadTask: URLSessionDownloadTask,
                                didFinishDownloadingTo location: URL) {
        if let http = downloadTask.response as? HTTPURLResponse, !(200...299).contains(http.statusCode) {
            Task { @MainActor in self.finished(ok: false) }
            return
        }
        var target = file
        try? FileManager.default.removeItem(at: target)
        let ok = (try? FileManager.default.moveItem(at: location, to: target)) != nil
        if ok {
            var values = URLResourceValues()
            values.isExcludedFromBackup = true    // 1.6 GB does not belong in iCloud Backup
            try? target.setResourceValues(values)
        }
        Task { @MainActor in self.finished(ok: ok) }
    }

    nonisolated func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
        guard let error, (error as NSError).code != NSURLErrorCancelled else { return }
        Task { @MainActor in
            if (error as NSError).code == NSURLErrorNotConnectedToInternet {
                self.task = nil
                self.state = .failed("You're offline. Try again when you're connected.")
            } else {
                self.next()      // timeouts, resets, TLS errors: try the next mirror
            }
        }
    }
}

extension ModelDownloader {
    fileprivate func finished(ok: Bool) {
        task = nil
        guard ok else { next(); return }
        state = .verifying
        let file = self.file, expected = spec.sha256.lowercased()
        Task.detached(priority: .utility) {
            let good = Self.sha256(of: file) == expected
            await MainActor.run {
                if good { self.state = .ready }
                else {
                    try? FileManager.default.removeItem(at: file)
                    self.next()   // wrong or broken file from this source: try the next one
                }
            }
        }
    }

    nonisolated static func sha256(of url: URL) -> String? {
        guard let handle = try? FileHandle(forReadingFrom: url) else { return nil }
        defer { try? handle.close() }
        var hasher = SHA256()
        while let chunk = try? handle.read(upToCount: 8 << 20), !chunk.isEmpty {
            hasher.update(data: chunk)
        }
        return hasher.finalize().map { String(format: "%02x", $0) }.joined()
    }
}

import SwiftUI

final class AppDelegate: NSObject, UIApplicationDelegate {
    func application(_ application: UIApplication,
                     handleEventsForBackgroundURLSession identifier: String,
                     completionHandler: @escaping () -> Void) {
        guard identifier.hasPrefix("model.") else { completionHandler(); return }
        ModelDownloader.completions[identifier] = completionHandler
    }
}

extension ModelDownloader {
    nonisolated func urlSessionDidFinishEvents(forBackgroundURLSession session: URLSession) {
        let id = session.configuration.identifier ?? ""
        Task { @MainActor in ModelDownloader.completions.removeValue(forKey: id)?() }
    }
}

@main
struct MyApp: App {
    @UIApplicationDelegateAdaptor(AppDelegate.self) private var delegate
    var body: some Scene { WindowGroup { ContentView() } }
}

struct ModelRow: View {
    let downloader: ModelDownloader

    var body: some View {
        switch downloader.state {
        case .notDownloaded:      Button("Download (1.6 GB)") { downloader.download() }
        case .downloading(let p): ProgressView(value: p) { Text("Downloading \(Int(p * 100)) %") }
        case .verifying:          Text("Checking the file …")
        case .ready:              Label("Ready", systemImage: "checkmark.circle")
        case .failed(let reason): Text(reason)
        }
    }
}