Swift Concurrency in Apps

// Packages/FieldNotesKit/Package.swift (targets excerpt)
.target(
    name: "FieldNotesServices",
    dependencies: ["FieldNotesModel"],
    swiftSettings: [
        .enableUpcomingFeature("NonisolatedNonsendingByDefault"),
        .enableUpcomingFeature("InferIsolatedConformances"),
    ]
),

// Packages/FieldNotesUI/Package.swift (targets excerpt)
.target(
    name: "FieldNotesUI",
    dependencies: [.product(name: "FieldNotesServices", package: "FieldNotesKit")],
    swiftSettings: [.defaultIsolation(MainActor.self)]
),

// FieldNotes app target, SWIFT_DEFAULT_ACTOR_ISOLATION = MainActor

// Inferred @MainActor: safe to read and write from any view, no annotation needed.
var lastSyncDate: Date?

// Inferred @MainActor as well, including its methods.
@Observable
final class SyncStatus {
    var isSyncing = false
    func markSynced() {
        isSyncing = false
        lastSyncDate = .now
    }
}

// Packages/FieldNotesKit/Sources/FieldNotesServices/CloudNoteSyncer.swift
import FieldNotesModel

public actor CloudNoteSyncer: NoteSyncing {
    private var pendingChanges: [Note] = []

    public init() {}

    public func enqueue(_ notes: [Note]) {
        pendingChanges.append(contentsOf: notes)
    }

    public func sync() async throws {
        let batch = pendingChanges
        pendingChanges.removeAll()
        // Upload `batch`; networking is covered on the Networking page.
        _ = batch
    }
}

// FieldNotes/Persistence/NoteArchive.swift (app target)
import Foundation
import FieldNotesModel

nonisolated struct NoteArchive: Sendable {
    let directory: URL

    @concurrent
    func notes(in notebookID: Notebook.ID?) async throws -> [Note] {
        let file = directory.appending(path: "\(notebookID?.uuidString ?? "inbox").fieldnotes")
        let data = try Data(contentsOf: file)
        try Task.checkCancellation()
        return try NoteFileFormat.decode(data)   // file format: see page 23
    }
}

// FieldNotes/Views/NoteList.swift (excerpt)
struct NoteList: View {
    @Environment(NoteStore.self) private var store
    @State private var loadError: (any Error)?
    private let archive = NoteArchive(directory: .documentsDirectory)
    let notebookID: Notebook.ID?

    var body: some View {
        List(store.notes.filter { $0.notebookID == notebookID }) { NoteRow(note: $0) }
            .task(id: notebookID, name: "Load notebook") {
                do {
                    let loaded = try await archive.notes(in: notebookID)
                    store.notes.removeAll { $0.notebookID == notebookID }
                    store.notes.append(contentsOf: loaded)
                } catch is CancellationError {
                    // The user picked another notebook, or the view went away: nothing to do.
                } catch {
                    loadError = error
                }
            }
    }
}

// FieldNotes/Views/SyncButton.swift
struct SyncButton: View {
    @Environment(NoteStore.self) private var store
    @State private var isSyncing = false

    var body: some View {
        Button("Sync Now", systemImage: "arrow.triangle.2.circlepath") {
            Task.immediate(name: "Manual sync") {
                isSyncing = true                 // runs before the action returns
                defer { isSyncing = false }
                do {
                    try await store.refresh()    // first suspension point
                } catch {
                    // Report the failure; see the logging page.
                }
            }
        }
        .disabled(isSyncing)
    }
}

// FieldNotes/Editing/Autosave.swift
import OSLog

let autosaveLog = Logger(subsystem: "com.example.fieldnotes", category: "autosave")

func scheduleAutosave(of note: Note, in archive: NoteArchive) -> Task<Void, any Error> {
    Task(name: "Autosave \(note.title)") {
        try await Task.sleep(for: .seconds(2))
        try await archive.write(note)
        autosaveLog.debug("Finished \(Task.name ?? "unnamed task", privacy: .public)")
    }
}

// FieldNotes/Views/NoteEditor.swift (excerpt)
@State private var pendingAutosave: Task<Void, any Error>?

func noteDidChange(_ note: Note) {
    pendingAutosave?.cancel()                              // not a child: cancel explicitly
    pendingAutosave = scheduleAutosave(of: note, in: archive)
}

// FieldNotes/Legacy/ThumbnailRenderer+Async.swift
import SwiftUI

// The old API: calls `completion` exactly once, on an arbitrary queue.
final class ThumbnailRenderer: Sendable {
    func renderThumbnail(for note: Note,
                         completion: @escaping @Sendable (CGImage?) -> Void) { /* ... */ }
}

extension ThumbnailRenderer {
    func thumbnail(for note: Note) async -> CGImage? {
        await withCheckedContinuation { continuation in
            renderThumbnail(for: note) { image in
                continuation.resume(returning: image)
            }
        }
    }
}

// LegacyExportClient.export(noteID:completion:) calls back once with a Result<URL, any Error>.
extension LegacyExportClient {
    func export(_ note: Note) async throws -> URL {
        try await withCheckedThrowingContinuation { continuation in
            export(noteID: note.id) { (result: Result<URL, any Error>) in
                continuation.resume(with: result)
            }
        }
    }
}

// FieldNotes/Location/LocationFixStream.swift
import CoreLocation

nonisolated final class LocationFixStream: NSObject, CLLocationManagerDelegate {
    private var continuation: AsyncStream<CLLocation>.Continuation?
    private let manager = CLLocationManager()

    override init() {
        super.init()
        manager.delegate = self
    }

    /// Starts location updates and returns a fresh stream of fixes. A stream can be iterated only once and
    /// ends for good when it finishes or its consuming task is cancelled, so every `start()` makes a new one.
    func start() -> AsyncStream<CLLocation> {
        continuation?.finish()
        let (stream, continuation) = AsyncStream.makeStream(of: CLLocation.self,
                                                            bufferingPolicy: .bufferingNewest(1))
        self.continuation = continuation
        manager.requestWhenInUseAuthorization()
        manager.startUpdatingLocation()
        return stream
    }

    func stop() {
        manager.stopUpdatingLocation()
        continuation?.finish()
        continuation = nil
    }

    func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
        for location in locations { continuation?.yield(location) }
    }
}

// FieldNotes/Views/NoteEditor.swift (excerpt)
@State private var locator = LocationFixStream()
@State private var lastFix: CLLocation?

var locationSection: some View {
    LabeledContent("Location", value: lastFix.map { "\($0.coordinate.latitude), \($0.coordinate.longitude)" } ?? "--")
        .task(name: "Location fixes") {
            for await fix in locator.start() {   // a new stream each time the editor appears
                lastFix = fix
            }
        }
        .onDisappear { locator.stop() }   // stops GPS; leaving also cancels the task and ends its stream
}

// FieldNotesServices, CloudNoteSyncer
// openSession(for:) returns the upload session written on the Networking page.
public func syncNotebook(_ notebook: Notebook) async throws {
    let session = try await openSession(for: notebook.id)
    defer { await session.close() }        // allowed from Swift 6.4
    try await session.upload(pendingChanges.filter { $0.notebookID == notebook.id })
}

// FieldNotes/Persistence/NoteArchive+Save.swift
extension NoteArchive {
    func saveCompletely(_ note: Note) async throws {
        if #available(iOS 27, macOS 27, watchOS 27, visionOS 27, *) {
            try await withTaskCancellationShield {
                try await write(note)          // never observes the surrounding cancellation
            }
        } else {
            try await write(note)              // 26: write(_:) avoids cancellation checks mid-file
        }
    }
}

if #available(iOS 27, macOS 27, watchOS 27, visionOS 27, *), Task.hasActiveCancellationShield {
    autosaveLog.debug("Writing inside a cancellation shield")
}

// Warning in Swift 6.4: the error thrown by refresh() is silently ignored.
Task { try await store.refresh() }

// Fix 1: handle the error inside the task.
Task {
    do { try await store.refresh() } catch { syncError = error }
}

// Fix 2: keep the task and check its result later.
let refresh = Task { try await store.refresh() }
// ...
do { try await refresh.value } catch { syncError = error }

// FieldNotesServices
public final class ExportCoordinator: Sendable {
    public weak let store: NoteStore?      // NoteStore is @MainActor, therefore Sendable

    public init(store: NoteStore) {
        self.store = store
    }
}

// FieldNotesServices: a mutable, single-owner buffer of unsaved edits.
public class DraftBuffer: ~Sendable {
    public var pendingEdits: [String] = []
    public init() {}
}

// A subclass that protects its own state can still opt in.
public final class LockedDraftBuffer: DraftBuffer, @unchecked Sendable { /* guarded by a Mutex */ }