Data Protection: 내 앱이 자기 파일을 언제 읽을 수 있을지 고르기

class                                    readable while locked?          created while locked?
---------------------------------------  ------------------------------  ---------------------
.none                                    yes                             yes
.completeUntilFirstUserAuthentication    yes, after the first unlock     yes   (the default)
.completeUnlessOpen                      only if it was already open     yes
.complete                                no                              no

Choose by what the file holds and when the app must touch it:
  health records, a writer's notes, a share inbox  -> .complete, and drain only when unlocked
  a capture that arrives in the background         -> .completeUnlessOpen, so it can be written
  caches that are cheap to rebuild                 -> the default

import Foundation
import UIKit

enum DrainStatus: Equatable, Sendable {
    case drained(Int)
    case waitingForUnlock          // not an error: the files are there, just sealed
}

@MainActor
final class ProtectedOutbox {
    private let folder: URL

    init(folder: URL) {
        self.folder = folder
    }

    /// Complete: unreadable while the device is locked, even by this app.
    func save(_ data: Data, named name: String) throws {
        try FileManager.default.createDirectory(at: folder, withIntermediateDirectories: true)
        try data.write(to: folder.appending(path: name), options: [.atomic, .completeFileProtection])
    }

    /// A background drain checks before every read, and says what it is waiting for instead of
    /// throwing I/O errors. The phone can lock while a send is suspended at the await.
    func drain(send: (Data) async throws -> Void) async throws -> DrainStatus {
        guard UIApplication.shared.isProtectedDataAvailable else { return .waitingForUnlock }
        let files = try FileManager.default.contentsOfDirectory(at: folder, includingPropertiesForKeys: nil)
        var sent = 0
        for file in files.sorted(by: { $0.lastPathComponent < $1.lastPathComponent }) {
            guard UIApplication.shared.isProtectedDataAvailable else { return .waitingForUnlock }
            let data: Data
            do {
                data = try Data(contentsOf: file)
            } catch where !UIApplication.shared.isProtectedDataAvailable {
                return .waitingForUnlock            // locked between the check and the read
            }
            try await send(data)
            try FileManager.default.removeItem(at: file)
            sent += 1
        }
        return .drained(sent)
    }

    /// Resume the moment the device unlocks.
    func onUnlock(_ resume: @escaping @MainActor () -> Void) -> NSObjectProtocol {
        NotificationCenter.default.addObserver(
            forName: UIApplication.protectedDataDidBecomeAvailableNotification,
            object: nil, queue: .main
        ) { _ in
            MainActor.assumeIsolated { resume() }
        }
    }
}