@bubblsdk/react-native-sdk 4.1.7 → 5.0.0-alpha.2

package/ios-sdk/BubblSDK/Notification/ScreenPresenter.swift

@@ -0,0 +1,148 @@
+#if os(iOS)
+import SwiftUI
+import UIKit
+import UserNotifications
+#if !COCOAPODS
+import BubblCore
+#endif
+
+/// Shows notifications as Android's NotificationPresenter does: Bubbl's screen straight away when
+/// the app is in front (or the notification was tapped); otherwise a system notification whose tap
+/// opens the screen. True when it's been taken care of, so the system banner isn't needed too.
+@available(iOS 17, *)
+struct ScreenPresenter: NotificationPresenting {
+    func present(_ notification: JSONValue, opened: Bool) async -> Bool {
+        guard let parsed = BubblNotification(notification) else { return false }
+        let inFront = await MainActor.run { UIApplication.shared.applicationState != .background }
+        if opened || inFront {
+            return await MainActor.run { NotificationScreens.shared.show(parsed, opened: opened) }
+        }
+        return await SystemNotifications.post(parsed)
+    }
+}
+
+/// Bubbl's screen, one notification at a time, in a window of its own over the app. Others that
+/// arrive meanwhile wait their turn; one launched by a tap before the app has a scene waits for it.
+@available(iOS 17, *)
+@MainActor
+final class NotificationScreens {
+    static let shared = NotificationScreens()
+
+    private var window: UIWindow?
+    private weak var previousKeyWindow: UIWindow?
+    private var showing: String?
+    private var waiting: [(notification: BubblNotification, opened: Bool)] = []
+    private var watchingScenes = false
+
+    func show(_ notification: BubblNotification, opened: Bool) -> Bool {
+        let id = notification.campaignNotificationId
+        guard showing != id, !waiting.contains(where: { $0.notification.campaignNotificationId == id }) else { return true }
+        guard window == nil, let scene = activeScene() else {
+            waiting.append((notification, opened))
+            watchScenes()
+            return true
+        }
+
+        let events = EngineHost.shared.current.map(EngineHost.shared.notificationEvents)
+        let model = NotificationModel(notification: notification, opened: opened, events: events) { [weak self] in
+            self?.closeCurrent()
+        }
+        let host = UIHostingController(rootView: NotificationScreen(model: model))
+        host.view.backgroundColor = .clear
+
+        let window = UIWindow(windowScene: scene)
+        window.windowLevel = .alert + 1
+        window.rootViewController = host
+        previousKeyWindow = scene.windows.first { $0.isKeyWindow }
+        window.makeKeyAndVisible()
+        self.window = window
+        showing = id
+        return true
+    }
+
+    private func closeCurrent() {
+        window?.isHidden = true
+        window = nil
+        showing = nil
+        previousKeyWindow?.makeKey()
+        showNext()
+    }
+
+    private func showNext() {
+        guard window == nil, !waiting.isEmpty, activeScene() != nil else { return }
+        let next = waiting.removeFirst()
+        _ = show(next.notification, opened: next.opened)
+    }
+
+    private func activeScene() -> UIWindowScene? {
+        let scenes = UIApplication.shared.connectedScenes.compactMap { $0 as? UIWindowScene }
+        return scenes.first { $0.activationState == .foregroundActive } ?? scenes.first { $0.activationState == .foregroundInactive }
+    }
+
+    /// A notification waiting for the app to come to the front shows when it does.
+    private func watchScenes() {
+        guard !watchingScenes else { return }
+        watchingScenes = true
+        _ = NotificationCenter.default.addObserver(forName: UIScene.didActivateNotification, object: nil, queue: .main) { _ in
+            MainActor.assumeIsolated { NotificationScreens.shared.showNext() }
+        }
+    }
+}
+
+/// A notification that arrived with the app in the background (a geofence's): a system notification
+/// carrying it, whose tap opens Bubbl's screen (it comes back as a Bubbl push, `opened`).
+@available(iOS 17, *)
+enum SystemNotifications {
+    static func post(_ notification: BubblNotification) async -> Bool {
+        let center = UNUserNotificationCenter.current()
+        let status = await PermissionFlow.notificationAuthorization()
+        guard status == .authorized || status == .provisional || status == .ephemeral else {
+            BubblLog.warning("A notification wasn't shown: the app is in the background and notifications aren't allowed")
+            return false
+        }
+
+        let content = UNMutableNotificationContent()
+        content.title = notification.headline
+        content.body = notification.body
+        content.sound = .default
+        content.userInfo = [
+            "bubbl": "1",
+            "bubbl_v": PushMessage.version,
+            "campaign_notification_id": notification.campaignNotificationId,
+            "notification": notification.jsonText,
+        ]
+        if let picture = await attachment(notification) { content.attachments = [picture] }
+
+        do {
+            try await center.add(UNNotificationRequest(identifier: "bubbl.\(notification.campaignNotificationId)", content: content, trigger: nil))
+        } catch {
+            BubblLog.warning("A notification couldn't be posted (\(type(of: error)))")
+            return false
+        }
+        BubblLog.debug("Notification posted (the app is in the background)")
+        if let core = EngineHost.shared.current {
+            try? await EngineHost.shared.notificationEvents(core).displayed(notification)
+            EngineHost.shared.submit("events") { await $0.flushEvents() }
+        }
+        return true
+    }
+
+    /// The notification's picture, downloaded for the system notification when it's quick (a
+    /// geofence's event has only seconds); none otherwise.
+    private static func attachment(_ notification: BubblNotification) async -> UNNotificationAttachment? {
+        guard let link = notification.media?.pictureUrl, link.lowercased().hasPrefix("https://"), let url = URL(string: link) else { return nil }
+        let configuration = URLSessionConfiguration.ephemeral
+        configuration.timeoutIntervalForResource = 5
+        let session = URLSession(configuration: configuration)
+        defer { session.finishTasksAndInvalidate() }
+        guard let downloaded = try? await session.download(from: url),
+              let http = downloaded.1 as? HTTPURLResponse, (200...299).contains(http.statusCode)
+        else { return nil }
+        let location = downloaded.0
+        let fileExtension = url.pathExtension.isEmpty ? "jpg" : url.pathExtension
+        let file = FileManager.default.temporaryDirectory.appendingPathComponent(UUID().uuidString).appendingPathExtension(fileExtension)
+        guard (try? FileManager.default.moveItem(at: location, to: file)) != nil else { return nil }
+        return try? UNNotificationAttachment(identifier: "bubbl-image", url: file)
+    }
+}
+#endif

package/ios-sdk/BubblSDK/Permissions/PermissionFlow.swift

@@ -0,0 +1,169 @@
+#if os(iOS)
+import CoreLocation
+import UIKit
+import UserNotifications
+#if !COCOAPODS
+import BubblCore
+#endif
+
+/// Asking for the permissions Bubbl uses, from anywhere in the app: the privacy view first when the
+/// dashboard says so, then the system's prompt, "Always" location in the two steps iOS expects
+/// (PermissionPlanner). Where the device stands is reported to the server with the device.
+@available(iOS 17, *)
+@MainActor
+final class PermissionFlow: NSObject, CLLocationManagerDelegate {
+    static let shared = PermissionFlow()
+
+    private let manager = CLLocationManager()
+    private var asking = false
+
+    override private init() {
+        super.init()
+        manager.delegate = self
+    }
+
+    /// Where the device stands now.
+    func status() async -> PermissionStatus {
+        let notifications: PermissionStatus.Notifications = switch await Self.notificationAuthorization() {
+        case .authorized, .provisional, .ephemeral: .granted
+        case .denied: .denied
+        default: .notDetermined
+        }
+        let location: PermissionStatus.Location = switch manager.authorizationStatus {
+        case .authorizedAlways: .always
+        case .authorizedWhenInUse: .whenInUse
+        case .denied, .restricted: .denied
+        default: .notDetermined
+        }
+        let status = PermissionStatus(notifications: notifications, location: location, preciseLocation: manager.accuracyAuthorization == .fullAccuracy)
+        EngineHost.shared.platform.permissionStatus = status
+        return status
+    }
+
+    /// Asks for `request` as the planner says, one request at a time. "Not now" on the privacy view,
+    /// or a refusal, ends it. Returns where the device stands afterwards.
+    func request(_ request: PermissionRequest) async -> PermissionStatus {
+        guard !asking else { return await status() }
+        asking = true
+        defer { asking = false }
+
+        let memory = PermissionMemory.shared
+        let config = EngineHost.shared.current?.configSync.current
+        let steps = PermissionPlanner.plan(
+            request,
+            status: await status(),
+            notice: config?.privacyNotice ?? "automatic",
+            explained: memory.explained,
+            askedAlways: memory.askedAlways
+        )
+
+        for step in steps {
+            switch step {
+            case .explain(let kind):
+                memory.markExplained(kind)
+                guard await PrivacyView.show(kind: kind, text: config?.privacyText, policy: config?.privacyUrl) else {
+                    return await finished()
+                }
+            case .ask(.notifications):
+                let granted = (try? await UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound, .badge])) ?? false
+                if !granted { return await finished() }
+            case .ask(.locationWhenInUse):
+                await prompt { manager.requestWhenInUseAuthorization() }
+                // Refused: "Always" can't follow.
+                if !(await status()).hasLocation { return await finished() }
+            case .ask(.locationAlways):
+                memory.markAskedAlways()
+                await prompt { manager.requestAlwaysAuthorization() }
+            }
+        }
+        return await finished()
+    }
+
+    /// Whether notifications are allowed (only the status crosses over: the settings object isn't
+    /// Sendable).
+    nonisolated static func notificationAuthorization() async -> UNAuthorizationStatus {
+        await withCheckedContinuation { continuation in
+            UNUserNotificationCenter.current().getNotificationSettings { settings in
+                continuation.resume(returning: settings.authorizationStatus)
+            }
+        }
+    }
+
+    /// Static: opening the app's settings page needs none of the flow's state (no location manager),
+    /// so it can run before `Bubbl.start`.
+    static func openSettings() {
+        guard let url = URL(string: UIApplication.openSettingsURLString) else { return }
+        UIApplication.shared.open(url)
+    }
+
+    /// What asking changed: a device token once notifications are allowed, the server told, and
+    /// geofences checked with the location now allowed.
+    private func finished() async -> PermissionStatus {
+        let now = await status()
+        if now.notifications == .granted { UIApplication.shared.registerForRemoteNotifications() }
+        EngineHost.shared.submit("device") { await $0.syncDevice() }
+        if now.hasLocation { EngineHost.shared.checkGeofences(rewatch: true) }
+        return now
+    }
+
+    /// Shows a system location prompt and waits for its answer. iOS doesn't say when it decides not
+    /// to show one (asked before), so: a prompt makes the app inactive; if that hasn't happened
+    /// within a second, there wasn't one.
+    private func prompt(_ ask: () -> Void) async {
+        ask()
+        var shown = false
+        for _ in 0..<20 {
+            try? await Task.sleep(nanoseconds: 50_000_000)
+            if UIApplication.shared.applicationState != .active {
+                shown = true
+                break
+            }
+        }
+        guard shown else { return }
+        while UIApplication.shared.applicationState != .active {
+            try? await Task.sleep(nanoseconds: 200_000_000)
+        }
+        // The answer reaches CoreLocation just after the app is active again.
+        try? await Task.sleep(nanoseconds: 300_000_000)
+    }
+
+    nonisolated func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
+        Task { @MainActor in _ = await PermissionFlow.shared.status() }
+    }
+}
+
+/// What Bubbl has explained (the privacy view, per kind) and whether it has asked for "Always"
+/// (iOS shows that prompt once), kept between launches.
+@available(iOS 17, *)
+@MainActor
+final class PermissionMemory {
+    static let shared = PermissionMemory()
+
+    private struct Saved: Codable {
+        var explained: [String] = []
+        var askedAlways = false
+    }
+
+    private let store: FileValueStore<Saved>?
+    private var saved: Saved
+
+    private init() {
+        store = EngineHost.directory().map { FileValueStore(url: $0.appendingPathComponent("permissions.json"), writeOptions: EngineHost.writeOptions) }
+        saved = ((try? store?.load()) ?? nil) ?? Saved()
+    }
+
+    var explained: Set<String> { Set(saved.explained) }
+    var askedAlways: Bool { saved.askedAlways }
+
+    func markExplained(_ kind: String) {
+        guard !saved.explained.contains(kind) else { return }
+        saved.explained.append(kind)
+        try? store?.save(saved)
+    }
+
+    func markAskedAlways() {
+        saved.askedAlways = true
+        try? store?.save(saved)
+    }
+}
+#endif

package/ios-sdk/BubblSDK/Permissions/PrivacyView.swift

@@ -0,0 +1,110 @@
+#if os(iOS)
+import SwiftUI
+import UIKit
+#if !COCOAPODS
+import BubblCore
+#endif
+
+/// The privacy view: why Bubbl is about to ask for a permission, shown before the system's prompt
+/// (when the dashboard's notice mode says so), in the dashboard's words when it has set some, with
+/// its privacy policy link. Continue goes on to the prompt; "Not now" ends the request.
+@available(iOS 17, *)
+@MainActor
+enum PrivacyView {
+    private static var window: UIWindow?
+
+    /// True for Continue. With no screen to show it on, it goes straight on to the prompt.
+    static func show(kind: String, text: String?, policy: String?) async -> Bool {
+        let scenes = UIApplication.shared.connectedScenes.compactMap { $0 as? UIWindowScene }
+        guard window == nil, let scene = scenes.first(where: { $0.activationState == .foregroundActive }) else { return true }
+
+        return await withCheckedContinuation { continuation in
+            let previousKey = scene.windows.first { $0.isKeyWindow }
+            let view = PrivacyExplanation(kind: kind, text: text, policy: policy) { accepted in
+                window?.isHidden = true
+                window = nil
+                previousKey?.makeKey()
+                continuation.resume(returning: accepted)
+            }
+            let host = UIHostingController(rootView: view)
+            host.view.backgroundColor = .clear
+            let created = UIWindow(windowScene: scene)
+            created.windowLevel = .alert + 1
+            created.rootViewController = host
+            created.makeKeyAndVisible()
+            window = created
+        }
+    }
+}
+
+@available(iOS 17, *)
+struct PrivacyExplanation: View {
+    let kind: String
+    let text: String?
+    let policy: String?
+    let done: @MainActor (Bool) -> Void
+
+    private var title: String {
+        switch kind {
+        case "notifications": Words.text("bubbl_permission_notifications_title", "Stay in the loop")
+        case "background_location": Words.text("bubbl_permission_background_title", "Offers even when the app is closed")
+        default: Words.text("bubbl_permission_location_title", "Offers near you")
+        }
+    }
+
+    private var message: String {
+        switch kind {
+        case "notifications": Words.text("bubbl_permission_notifications_body", "Allow notifications to hear about offers and updates as they happen.")
+        case "background_location": Words.text("bubbl_permission_background_body", "To hear about places nearby while the app isn't open, choose \"Change to Always Allow\" when asked. You can change this at any time in Settings.")
+        default: Words.text("bubbl_permission_location_body", "Allow your location to get offers and messages when you're near the places they're for.")
+        }
+    }
+
+    var body: some View {
+        ZStack {
+            Look.scrim.ignoresSafeArea()
+            ScrollView {
+                VStack(alignment: .leading, spacing: 0) {
+                    Text(title)
+                        .font(.title3.weight(.bold))
+                        .foregroundStyle(Look.onSurface)
+                        .fixedSize(horizontal: false, vertical: true)
+                        .accessibilityAddTraits(.isHeader)
+                    Text(message)
+                        .font(.subheadline)
+                        .foregroundStyle(Look.onSurfaceMuted)
+                        .padding(.top, 8)
+                        .fixedSize(horizontal: false, vertical: true)
+                    if let text, !text.isEmpty {
+                        Text(text)
+                            .font(.footnote)
+                            .foregroundStyle(Look.onSurfaceMuted)
+                            .padding(.top, 12)
+                            .fixedSize(horizontal: false, vertical: true)
+                    }
+                    if let policy, LinkPolicy.canOpen(policy), let url = URL(string: policy) {
+                        Link(Words.text("bubbl_privacy_policy", "Privacy policy"), destination: url)
+                            .font(.subheadline)
+                            .tint(Look.accent)
+                            .padding(.top, 12)
+                    }
+                    PrimaryButton(title: Words.text("bubbl_continue", "Continue")) { done(true) }
+                        .padding(.top, 20)
+                        .accessibilityIdentifier("bubbl.continue")
+                    SecondaryButton(title: Words.text("bubbl_not_now", "Not now")) { done(false) }
+                        .padding(.top, 4)
+                        .accessibilityIdentifier("bubbl.notNow")
+                }
+                .padding(Look.cardPadding)
+                .background(Look.surface)
+                .clipShape(RoundedRectangle(cornerRadius: Look.cardRadius, style: .continuous))
+                .frame(maxWidth: Look.cardMaxWidth)
+                .padding(.horizontal, 16)
+                .padding(.vertical, 24)
+            }
+            .frame(maxHeight: .infinity)
+        }
+        .accessibilityAddTraits(.isModal)
+    }
+}
+#endif

package/ios-sdk/BubblSDK/Platform/AppleDevicePlatform.swift

@@ -0,0 +1,95 @@
+import Foundation
+#if !COCOAPODS
+import BubblCore
+#endif
+
+/// What the device says about itself (the contract's DeviceAttributes). Permissions and the push
+/// token come with slices 9 and 11; until then the platform can't say.
+@available(iOS 17, *)
+final class AppleDevicePlatform: DevicePlatform, @unchecked Sendable {
+    private let lock = NSLock()
+    private var token: PushToken?
+    private var status: PermissionStatus?
+
+    func attributes() -> [String: JSONValue] {
+        let bundle = Bundle.main
+        let version = ProcessInfo.processInfo.operatingSystemVersion
+        let locale = Locale.current
+        var attributes: [String: JSONValue] = [
+            "platform": "ios",
+            "os_version": .string("\(version.majorVersion).\(version.minorVersion).\(version.patchVersion)"),
+            "device_model": .string(String(Self.modelIdentifier.prefix(100))),
+            "manufacturer": "Apple",
+            "app_id": .string(bundle.bundleIdentifier ?? "unknown"),
+            "locale": .string(String(locale.identifier(.bcp47).prefix(35))),
+            "timezone": .string(TimeZone.current.identifier),
+        ]
+        attributes["app_version"] = (bundle.object(forInfoDictionaryKey: "CFBundleShortVersionString") as? String).map { .string(String($0.prefix(50))) } ?? .null
+        attributes["country"] = locale.region.map { $0.identifier.count == 2 ? .string($0.identifier) : .null } ?? .null
+        return attributes
+    }
+
+    /// As last looked (PermissionFlow); nil until then.
+    func permissions() -> JSONValue? { lock.sync { status?.json } }
+
+    var permissionStatus: PermissionStatus? {
+        get { lock.sync { status } }
+        set { lock.sync { status = newValue } }
+    }
+
+    func pushToken() -> PushToken? { lock.sync { token } }
+
+    func setPushToken(_ token: PushToken?) {
+        lock.sync { self.token = token }
+    }
+
+    /// "iPhone16,2"; on the Simulator, the model it simulates.
+    static var modelIdentifier: String {
+        if let simulated = ProcessInfo.processInfo.environment["SIMULATOR_MODEL_IDENTIFIER"] { return simulated }
+        var system = utsname()
+        uname(&system)
+        return withUnsafeBytes(of: &system.machine) { buffer in
+            String(decoding: buffer.prefix { $0 != 0 }, as: UTF8.self)
+        }
+    }
+}
+
+@available(iOS 17, *)
+extension JSONValue {
+    /// A value an app handed Bubbl (event properties, survey answers) as JSON, or nil when it
+    /// isn't text, a number, true/false, nil, or a list or dictionary of those. True and false
+    /// stay booleans: on Apple platforms they arrive as NSNumber, like numbers do.
+    init?(app value: Any?) {
+        switch value {
+        case nil, is NSNull:
+            self = .null
+        case let text as String:
+            self = .string(text)
+        case let number as NSNumber:
+            if CFGetTypeID(number) == CFBooleanGetTypeID() {
+                self = .bool(number.boolValue)
+            } else if CFNumberIsFloatType(number) {
+                guard number.doubleValue.isFinite else { return nil }
+                self = .double(number.doubleValue)
+            } else {
+                self = .int(number.int64Value)
+            }
+        case let list as [Any?]:
+            var items: [JSONValue] = []
+            for item in list {
+                guard let converted = JSONValue(app: item) else { return nil }
+                items.append(converted)
+            }
+            self = .array(items)
+        case let dictionary as [String: Any?]:
+            var object: [String: JSONValue] = [:]
+            for (key, item) in dictionary {
+                guard let converted = JSONValue(app: item) else { return nil }
+                object[key] = converted
+            }
+            self = .object(object)
+        default:
+            return nil
+        }
+    }
+}

package/ios-sdk/BubblSDK/Platform/KeychainCredentialStore.swift

@@ -0,0 +1,114 @@
+#if canImport(Security)
+import Foundation
+import Security
+#if !COCOAPODS
+import BubblCore
+#endif
+
+/// The install's credential in the Keychain: this device only, readable after the first unlock
+/// (so a region event after a reboot, before the phone is unlocked, finds it locked rather than
+/// missing, and the engine waits instead of registering again).
+@available(iOS 17, *)
+final class KeychainCredentialStore: CredentialStore, @unchecked Sendable {
+    private let service: String
+    private let account = "credential"
+    private let lock = NSLock()
+
+    private struct Stored: Codable {
+        let keyId: String
+        let secret: String
+    }
+
+    init(service: String = "tech.bubbl.sdk") {
+        self.service = service
+    }
+
+    func read() -> CredentialRead {
+        lock.sync {
+            var query = baseQuery
+            query[kSecReturnData as String] = true
+            query[kSecMatchLimit as String] = kSecMatchLimitOne
+
+            var result: CFTypeRef?
+            let status = SecItemCopyMatching(query as CFDictionary, &result)
+            switch status {
+            case errSecSuccess:
+                guard let data = result as? Data, let stored = try? JSONDecoder().decode(Stored.self, from: data) else {
+                    // Unreadable content: as good as none (registering again replaces it).
+                    return .missing
+                }
+                return .present(SigningCredential(keyId: stored.keyId, secret: stored.secret))
+            case errSecItemNotFound:
+                return .missing
+            default:
+                // errSecInteractionNotAllowed before the first unlock, and anything else the
+                // Keychain can't do right now: try again later, never "not registered".
+                report(status, "read")
+                return .unavailable
+            }
+        }
+    }
+
+    private var reportedMissingEntitlement = false
+
+    /// A Keychain failure, logged. Most pass (the device locked since a reboot): a debug line. An app
+    /// that can't use the Keychain at all (errSecMissingEntitlement: not code-signed, or signed with
+    /// no keychain access) never will, and all of Bubbl's work waits on it, so that's an error, once,
+    /// which diagnostics' lastError shows.
+    private func report(_ status: OSStatus, _ operation: String) {
+        guard status == errSecMissingEntitlement else {
+            BubblLog.debug("Keychain \(operation) unavailable (\(status))")
+            return
+        }
+        guard !reportedMissingEntitlement else { return }
+        reportedMissingEntitlement = true
+        BubblLog.error("The app can't use the Keychain (errSecMissingEntitlement): is it code-signed? Bubbl can't keep its credential, so nothing is sent")
+    }
+
+    func save(keyId: String, secret: String) throws {
+        let data = try JSONEncoder().encode(Stored(keyId: keyId, secret: secret))
+        try lock.sync {
+            let update: [String: Any] = [
+                kSecValueData as String: data,
+                kSecAttrAccessible as String: kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly,
+            ]
+            var status = SecItemUpdate(baseQuery as CFDictionary, update as CFDictionary)
+            if status == errSecItemNotFound {
+                var add = baseQuery
+                add.merge(update) { _, new in new }
+                status = SecItemAdd(add as CFDictionary, nil)
+            }
+            guard status == errSecSuccess else {
+                report(status, "save")
+                throw KeychainError(status: status)
+            }
+        }
+    }
+
+    func clear() throws {
+        try lock.sync {
+            let status = SecItemDelete(baseQuery as CFDictionary)
+            guard status == errSecSuccess || status == errSecItemNotFound else {
+                BubblLog.warning("The Keychain couldn't forget the credential (\(status))")
+                throw KeychainError(status: status)
+            }
+        }
+    }
+
+    private var baseQuery: [String: Any] {
+        [
+            kSecClass as String: kSecClassGenericPassword,
+            kSecAttrService as String: service,
+            kSecAttrAccount as String: account,
+            // The data-protection keychain on macOS too, so it behaves as on iOS.
+            kSecUseDataProtectionKeychain as String: true,
+        ]
+    }
+}
+
+@available(iOS 17, *)
+struct KeychainError: Error, CustomStringConvertible {
+    let status: OSStatus
+    var description: String { "Keychain error \(status)" }
+}
+#endif