@craft-native/ios 0.0.237 → 0.0.241

package/templates/CraftHeartRate.swift

@@ -136,9 +136,12 @@ final class CraftHeartRate: NSObject, CBCentralManagerDelegate, CBPeripheralDele
     static let maxRecordedSamples = 50_000
 
     private let clock: () -> Date
+    private let recordingDirectory: URL?
 
-    init(now: @escaping () -> Date = Date.init) {
+    init(now: @escaping () -> Date = Date.init, recordingDirectory: URL? = nil, archiveWriter: @escaping CraftRecordingArchive.Writer = CraftRecordingArchive.writeAtomically) {
         self.clock = now
+        self.recordingDirectory = recordingDirectory
+        self.archiveWriter = archiveWriter
         super.init()
     }
 
@@ -169,6 +172,8 @@ final class CraftHeartRate: NSObject, CBCentralManagerDelegate, CBPeripheralDele
     private var recoveryTimer: Timer?
     private var hasSubscribed = false
 
+    private var archiveWriter: CraftRecordingArchive.Writer = CraftRecordingArchive.writeAtomically
+    private var recordingActive = false
     private var recordingId: String?
     private var recordingStartedAt: Double?
     private var recordingPaused = false
@@ -199,8 +204,53 @@ final class CraftHeartRate: NSObject, CBCentralManagerDelegate, CBPeripheralDele
     /// One call from a page or a native screen, by method name.
     func perform(method: String, args: [Any], completion: @escaping Completion) {
         let options = args.first as? [String: Any] ?? [:]
+        if method == "acknowledgeRecording" && !options.keys.contains("expectedId") {
+            return completion(.failure(CraftHeartRateError(message: "Acknowledgement needs expectedId", code: "INVALID_ARGUMENT")))
+        }
         DispatchQueue.main.async {
-            self.restoreRecording()
+            do { try self.restoreRecording() }
+            catch { return completion(.failure(CraftHeartRateError(message: error.localizedDescription, code: "RECORDING_STORAGE_ERROR"))) }
+            if ["getRecordingState", "readRecording", "stopRecording", "acknowledgeRecording"].contains(method),
+               options.keys.contains("expectedId") {
+                guard let id = options["expectedId"] as? String, !id.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
+                    return completion(.failure(CraftHeartRateError(message: "expectedId must be a nonempty recording ID", code: "INVALID_ARGUMENT")))
+                }
+                do {
+                    if method == "acknowledgeRecording" {
+                        guard self.recordingId != id || !self.recordingActive else {
+                            return completion(.failure(CraftHeartRateError(message: "The recording is still active", code: "RECORDING_ALREADY_ACTIVE")))
+                        }
+                        var known = try self.recordingId == id || CraftRecordingArchive.isAcknowledged(self.directory, "heart-rate", id)
+                        if !known { known = try CraftRecordingArchive.read(self.directory, "heart-rate", id) != nil }
+                        guard known else { return completion(.failure(CraftHeartRateError(message: "Unknown recording ID", code: "RECORDING_CONFLICT"))) }
+                        try CraftRecordingArchive.acknowledge(self.directory, "heart-rate", id)
+                        if self.recordingId == id {
+                            if FileManager.default.fileExists(atPath: self.samplesURL.path) { try FileManager.default.removeItem(at: self.samplesURL) }
+                            self.recordingId = nil
+                            self.recordingStartedAt = nil
+                            self.recordedCount = 0
+                            try self.persistRecording()
+                        }
+                        return completion(.success(true))
+                    }
+                    if var archived = try CraftRecordingArchive.read(self.directory, "heart-rate", id) {
+                        if method == "readRecording" {
+                            let since = (options["since"] as? NSNumber)?.doubleValue
+                            let samples = archived["samples"] as? [[String: Any]] ?? []
+                            return completion(.success(samples.filter { since == nil || (($0["timestamp"] as? NSNumber)?.doubleValue ?? 0) > since! }))
+                        }
+                        if method == "getRecordingState" { archived.removeValue(forKey: "samples") }
+                        return completion(.success(archived))
+                    }
+                    if let error = self.recordingIdentityError(options) { return completion(.failure(error)) }
+                } catch let error as CraftNativeActionError {
+                    return completion(.failure(CraftHeartRateError(message: error.message, code: error.code)))
+                } catch { return completion(.failure(CraftHeartRateError(message: "Unable to persist the recording", code: "RECORDING_STORAGE_ERROR"))) }
+            }
+            if ["pauseRecording", "resumeRecording", "stopRecording", "readRecording"].contains(method),
+               let error = self.recordingIdentityError(options) {
+                return completion(.failure(error))
+            }
             switch method {
             case "getState":
                 self.recoverQuietBroadcast()
@@ -214,12 +264,14 @@ final class CraftHeartRate: NSObject, CBCentralManagerDelegate, CBPeripheralDele
             case "connect": self.connect(id: options["id"] as? String, wait: true, completion: completion)
             case "reconnect": self.connect(id: nil, wait: false, completion: completion)
             case "disconnect": self.disconnect(forget: options["forget"] as? Bool ?? false, completion: completion)
-            case "startRecording": self.startRecording(completion: completion)
+            case "startRecording": self.startRecording(options: options, completion: completion)
             case "pauseRecording": self.setRecordingPaused(true, completion: completion)
             case "resumeRecording": self.setRecordingPaused(false, completion: completion)
             case "stopRecording": self.stopRecording(completion: completion)
             case "getRecordingState": completion(.success(self.recordingSummary(count: true)))
-            case "readRecording": completion(.success(self.loadSamples(since: (options["since"] as? NSNumber)?.doubleValue)))
+            case "readRecording":
+                do { completion(.success(try self.persistedSamples(since: (options["since"] as? NSNumber)?.doubleValue))) }
+                catch { completion(.failure(CraftHeartRateError(message: "Unable to read the recording", code: "RECORDING_STORAGE_ERROR"))) }
             default: completion(.failure(CraftHeartRateError(message: "Unsupported HeartRate method", code: "UNKNOWN_ACTION")))
             }
         }
@@ -712,38 +764,46 @@ final class CraftHeartRate: NSObject, CBCentralManagerDelegate, CBPeripheralDele
     // MARK: Recording
 
     private var directory: URL {
-        FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask)[0]
+        recordingDirectory ?? FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask)[0]
     }
     private var stateURL: URL { directory.appendingPathComponent("craft-heart-rate-recording-state.json") }
     private var samplesURL: URL { directory.appendingPathComponent("craft-heart-rate-recording.jsonl") }
 
     /// A recording that was running when the app last closed carries on.
-    private func restoreRecording() {
+    private func restoreRecording() throws {
         guard !restored else { return }
-        restored = true
-        guard let data = try? Data(contentsOf: stateURL),
-              let saved = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
-              saved["active"] as? Bool == true else { return }
+        guard FileManager.default.fileExists(atPath: stateURL.path) else {
+            if FileManager.default.fileExists(atPath: samplesURL.path), !(try Data(contentsOf: samplesURL)).isEmpty {
+                throw CraftNativeActionError(code: "RECORDING_STORAGE_ERROR", message: "Recording metadata is missing")
+            }
+            restored = true
+            return
+        }
+        let data = try Data(contentsOf: stateURL)
+        guard let saved = try JSONSerialization.jsonObject(with: data) as? [String: Any],
+              let active = saved["active"] as? Bool else {
+            throw CraftNativeActionError(code: "RECORDING_STORAGE_ERROR", message: "Invalid recording metadata")
+        }
+        recordingActive = active
         recordingId = saved["id"] as? String
         recordingStartedAt = saved["startedAt"] as? Double
         recordingPaused = saved["paused"] as? Bool ?? false
-        recordedCount = loadSamples(since: nil).count
+        if let id = recordingId, try CraftRecordingArchive.isAcknowledged(directory, "heart-rate", id) {
+            try CraftRecordingArchive.acknowledge(directory, "heart-rate", id)
+            if FileManager.default.fileExists(atPath: samplesURL.path) { try FileManager.default.removeItem(at: samplesURL) }
+            recordingId = nil
+            recordingStartedAt = nil
+            recordingActive = false
+            recordingPaused = false
+            try persistRecording()
+        }
+        recordedCount = try persistedSamples(since: nil).count
+        restored = true
     }
 
-    private func persistRecording() {
-        let saved: [String: Any] = [
-            "active": recordingId != nil,
-            "paused": recordingPaused,
-            "id": recordingId ?? NSNull(),
-            "startedAt": recordingStartedAt ?? NSNull(),
-        ]
-        do {
-            try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
-            try JSONSerialization.data(withJSONObject: saved).write(to: stateURL, options: .atomic)
-            protect(stateURL)
-        } catch {
-            print("Unable to persist the heart-rate recording state: \(error)")
-        }
+    private func persistRecording() throws {
+        let saved: [String: Any] = ["active": recordingActive, "paused": recordingPaused, "id": recordingId ?? NSNull(), "startedAt": recordingStartedAt ?? NSNull()]
+        try CraftRecordingArchive.writeAtomically(JSONSerialization.data(withJSONObject: saved), stateURL)
     }
 
     private func protect(_ url: URL) {
@@ -757,7 +817,7 @@ final class CraftHeartRate: NSObject, CBCentralManagerDelegate, CBPeripheralDele
     private func recordingSummary(count: Bool) -> [String: Any] {
         var summary: [String: Any] = [
             "id": recordingId ?? NSNull(),
-            "active": recordingId != nil,
+            "active": recordingActive,
             "paused": recordingPaused,
             "startedAt": recordingStartedAt ?? NSNull(),
         ]
@@ -765,46 +825,80 @@ final class CraftHeartRate: NSObject, CBCentralManagerDelegate, CBPeripheralDele
         return summary
     }
 
-    private func startRecording(completion: @escaping Completion) {
+    private func startRecording(options: [String: Any], completion: @escaping Completion) {
+        guard !recordingActive else {
+            return completion(.failure(CraftHeartRateError(message: "A heart-rate recording is already active", code: "RECORDING_ALREADY_ACTIVE")))
+        }
+        let id: String
         do {
+            id = try CraftRecordingArchive.startId(options, directory: directory, kind: "heart-rate", currentId: recordingId)
+            try CraftRecordingArchive.save(directory, "heart-rate", recordingSummary(count: true), samples: try persistedSamples(since: nil), writer: archiveWriter)
             try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
             try Data().write(to: samplesURL, options: .atomic)
             protect(samplesURL)
+        } catch let error as CraftNativeActionError {
+            return completion(.failure(CraftHeartRateError(message: error.message, code: error.code)))
         } catch {
             return completion(.failure(CraftHeartRateError(message: "Unable to create the heart-rate recording", code: "RECORDING_STORAGE_ERROR")))
         }
-        recordingId = UUID().uuidString
+        let previous = (recordingActive, recordingId, recordingStartedAt, recordingPaused, recordedCount)
+        recordingActive = true
+        recordingId = id
         recordingStartedAt = (clock().timeIntervalSince1970 * 1000).rounded()
         recordingPaused = false
         recordedCount = 0
-        persistRecording()
+        do { try persistRecording() }
+        catch {
+            (recordingActive, recordingId, recordingStartedAt, recordingPaused, recordedCount) = previous
+            return completion(.failure(CraftHeartRateError(message: "Unable to persist the recording", code: "RECORDING_STORAGE_ERROR")))
+        }
         completion(.success(recordingSummary(count: true)))
     }
 
+    /// Runs on the same main-queue turn as the read or mutation it guards.
+    private func recordingIdentityError(_ options: [String: Any]) -> CraftHeartRateError? {
+        guard options.keys.contains("expectedId") else { return nil }
+        guard let expected = options["expectedId"] as? String,
+              !expected.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
+            return CraftHeartRateError(message: "expectedId must be a nonempty recording ID", code: "INVALID_ARGUMENT")
+        }
+        guard recordingId == expected else {
+            return CraftHeartRateError(message: "The active heart-rate recording has changed", code: "RECORDING_CONFLICT")
+        }
+        return nil
+    }
+
     private func setRecordingPaused(_ paused: Bool, completion: @escaping Completion) {
-        guard recordingId != nil else {
+        guard recordingActive else {
             return completion(.failure(CraftHeartRateError(message: "No active heart-rate recording", code: "NO_ACTIVE_RECORDING")))
         }
+        let previous = recordingPaused
         recordingPaused = paused
-        persistRecording()
+        do { try persistRecording() }
+        catch {
+            recordingPaused = previous
+            return completion(.failure(CraftHeartRateError(message: "Unable to persist the recording", code: "RECORDING_STORAGE_ERROR")))
+        }
         completion(.success(recordingSummary(count: true)))
     }
 
     private func stopRecording(completion: @escaping Completion) {
-        var summary = recordingSummary(count: true)
-        summary["active"] = false
-        summary["samples"] = loadSamples(since: nil)
-        recordingId = nil
-        recordingStartedAt = nil
-        recordingPaused = false
-        recordedCount = 0
-        persistRecording()
-        try? FileManager.default.removeItem(at: samplesURL)
-        completion(.success(summary))
+        do {
+            let samples = try persistedSamples(since: nil)
+            let wasActive = recordingActive
+            let wasPaused = recordingPaused
+            recordingActive = false
+            recordingPaused = false
+            do { try persistRecording() }
+            catch { recordingActive = wasActive; recordingPaused = wasPaused; throw error }
+            var summary = recordingSummary(count: true)
+            summary["samples"] = samples
+            completion(.success(summary))
+        } catch { completion(.failure(CraftHeartRateError(message: "Unable to persist the recording", code: "RECORDING_STORAGE_ERROR"))) }
     }
 
     private func appendSample(_ sample: [String: Any]) {
-        guard recordingId != nil, !recordingPaused, recordedCount < Self.maxRecordedSamples,
+        guard recordingActive, !recordingPaused, recordedCount < Self.maxRecordedSamples,
               let json = try? JSONSerialization.data(withJSONObject: sample) else { return }
         var line = json
         line.append(0x0A)
@@ -820,8 +914,11 @@ final class CraftHeartRate: NSObject, CBCentralManagerDelegate, CBPeripheralDele
     }
 
     /// The recording's samples, oldest first; only those after `since` (ms) when given.
-    private func loadSamples(since: Double?) -> [[String: Any]] {
-        guard let text = try? String(contentsOf: samplesURL, encoding: .utf8) else { return [] }
+    private func loadSamples(since: Double?) -> [[String: Any]] { (try? persistedSamples(since: since)) ?? [] }
+
+    private func persistedSamples(since: Double?) throws -> [[String: Any]] {
+        if recordingId == nil { return [] }
+        let text = try String(contentsOf: samplesURL, encoding: .utf8)
         return text.split(separator: "\n").compactMap { line in
             guard let data = line.data(using: .utf8),
                   let sample = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else { return nil }

package/templates/CraftNativeActions.swift

@@ -42,6 +42,9 @@ enum CraftNativeActions {
         // `speech`, `audio` (background sound) and `eventStream` (a fetch read
         // as it arrives) need nothing the app has to declare.
         var values = ["device", "clipboard", "haptics", "storage", "lifecycle", "fetch", "dialog", "speech", "audio", "eventStream", "linking", "badge", "animation"]
+        values.append("storageCompareAndSet")
+        values.append("storageSetIfAbsent")
+        values.append("crypto")
         if config.enableBiometric { values.append("biometric") }
         if config.enableSecureStorage { values.append("secureStorage") }
         if config.enableLocalDatabase { values.append("database") }
@@ -62,7 +65,11 @@ enum CraftNativeActions {
         // GPS and the route recording are the web view's coordinator's
         // (CraftWebServices); an app with no web view has the coordinator
         // all the same (CraftHybrid.configure).
-        if config.enableGeolocation { values.append("geolocation") }
+        if config.enableGeolocation {
+            values.append("geolocation")
+            if CraftZigRuntime.supportsRecordingOwnership { values.append("locationRecordingOwnership") }
+            if CraftZigRuntime.supportsRecordingIntentIdentity { values.append("locationRecordingIntentIdentity") }
+        }
         // The Music app's song and transport are the coordinator's too.
         if config.enableAppleMusic { values.append("music") }
         // `craft.background.complete(ok, id)`: the answer to a silent push or
@@ -70,7 +77,7 @@ enum CraftNativeActions {
         if config.backgroundRefresh?.enabled == true || config.enablePushNotifications { values.append("background") }
         // A heart-rate strap is the app's own service (CraftHeartRate.swift),
         // so it needs no web view.
-        if config.enableHeartRate { values.append("heartRate") }
+        if config.enableHeartRate { values.append(contentsOf: ["heartRate", "heartRateRecordingOwnership", "heartRateRecordingIntentIdentity"]) }
         if config.enableBluetooth { values.append("bluetooth") }
         // Workouts on the paired Apple Watch (CraftScheduledWorkouts.swift),
         // also the app's own service.
@@ -92,6 +99,8 @@ enum CraftNativeActions {
     /// Nil means this small shared router does not own the action.
     static func perform(action: String, body: [String: Any], config: CraftConfig) -> Result<Any, CraftNativeActionError>? {
         switch action {
+        case "cryptoRandomUUID":
+            return .success(UUID().uuidString.lowercased())
         case "getDeviceInfo":
             return .success(deviceInfo())
         case "haptic":
@@ -162,6 +171,8 @@ enum CraftNativeActions {
 
         let sync: Result<Any, CraftNativeActionError>?
         switch (module, method) {
+        case ("Crypto", "randomUUID"):
+            sync = .success(UUID().uuidString.lowercased())
         case ("Device", "getInfo"):
             sync = perform(action: "getDeviceInfo", body: [:], config: config)
         case ("CrashReporter", "capture"):
@@ -187,7 +198,8 @@ enum CraftNativeActions {
         case ("Clipboard", "read"):
             sync = perform(action: "clipboardRead", body: [:], config: config)
         case ("Storage", _):
-            sync = storage(method: method, args: args)
+            DispatchQueue.main.async { complete(requestToken, storage(method: method, args: args), completion) }
+            return
         case ("SecureStorage", _):
             guard config.enableSecureStorage else {
                 complete(requestToken, failure("CAPABILITY_DISABLED", "Secure storage is disabled"), completion)
@@ -398,6 +410,7 @@ enum CraftNativeActions {
                 "startRecording": "startLocationRecording", "pauseRecording": "pauseLocationRecording",
                 "resumeRecording": "resumeLocationRecording", "stopRecording": "stopLocationRecording",
                 "getRecordingState": "getLocationRecordingState", "readRecording": "readLocationRecording",
+                "acknowledgeRecording": "acknowledgeLocationRecording",
             ]
             guard let action = actions[method] else {
                 complete(requestToken, failure("UNKNOWN_ACTION", "Unsupported Location method"), completion)
@@ -840,44 +853,32 @@ enum CraftNativeActions {
     }
 
     private static func storage(method: String, args: [Any]) -> Result<Any, CraftNativeActionError> {
-        if method == "clear" {
-            for key in UserDefaults.standard.dictionaryRepresentation().keys where key.hasPrefix(storagePrefix) {
-                UserDefaults.standard.removeObject(forKey: key)
-            }
-            return .success(true)
-        }
-        if method == "keys" {
-            let keys = UserDefaults.standard.dictionaryRepresentation().keys
-                .filter { $0.hasPrefix(storagePrefix) }
-                .map { String($0.dropFirst(storagePrefix.count)) }
-                .sorted()
-            return .success(keys)
-        }
-        guard let key = validKey(args.first) else { return failure("INVALID_ARGUMENT", "Storage needs a non-empty key") }
-        let defaultsKey = storagePrefix + key
-        switch method {
-        case "get":
-            guard let data = UserDefaults.standard.data(forKey: defaultsKey) else { return .success(NSNull()) }
-            do {
-                return .success(try JSONSerialization.jsonObject(with: data, options: [.fragmentsAllowed]))
-            } catch {
-                return failure("STORAGE_CORRUPT", "Stored value is not valid JSON")
-            }
-        case "set":
-            guard args.count == 2 else { return failure("INVALID_ARGUMENT", "Storage.set needs a key and value") }
-            do {
-                let data = try JSONSerialization.data(withJSONObject: args[1], options: [.fragmentsAllowed])
-                UserDefaults.standard.set(data, forKey: defaultsKey)
+        do {
+            if method == "clear" { try CraftPersistentStorage.clear(prefix: storagePrefix); return .success(true) }
+            if method == "keys" { return .success(try CraftPersistentStorage.keys(prefix: storagePrefix)) }
+            guard let key = validKey(args.first) else { return failure("INVALID_ARGUMENT", "Storage needs a non-empty key") }
+            switch method {
+            case "get":
+                guard let data = try CraftPersistentStorage.get(key, prefix: storagePrefix) else { return .success(NSNull()) }
+                return .success(try JSONSerialization.jsonObject(with: data, options: .fragmentsAllowed))
+            case "set":
+                guard args.count == 2 else { return failure("INVALID_ARGUMENT", "Storage.set needs a key and value") }
+                let data = try JSONSerialization.data(withJSONObject: args[1], options: .fragmentsAllowed)
+                try CraftPersistentStorage.set(key, data: data, prefix: storagePrefix)
                 return .success(true)
-            } catch {
-                return failure("INVALID_ARGUMENT", "Storage values must be JSON serializable")
+            case "compareAndSet":
+                guard args.count == 3 else { return failure("INVALID_ARGUMENT", "Storage.compareAndSet needs a key, expected value and next value") }
+                return .success(try CraftPersistentStorage.compareAndSet(key, expected: args[1], value: args[2], prefix: storagePrefix))
+            case "setIfAbsent":
+                guard args.count == 2 else { return failure("INVALID_ARGUMENT", "Storage.setIfAbsent needs a key and value") }
+                return .success(try CraftPersistentStorage.setIfAbsent(key, value: args[1], prefix: storagePrefix))
+            case "remove":
+                try CraftPersistentStorage.set(key, data: nil, prefix: storagePrefix)
+                return .success(true)
+            default: return failure("UNKNOWN_ACTION", "Unsupported Storage method")
             }
-        case "remove":
-            UserDefaults.standard.removeObject(forKey: defaultsKey)
-            return .success(true)
-        default:
-            return failure("UNKNOWN_ACTION", "Unsupported Storage method")
-        }
+        } catch let error as CraftNativeActionError { return .failure(error) }
+        catch { return failure("STORAGE_ERROR", "Storage could not persist or read its value") }
     }
 
     private static func secureStorage(method: String, args: [Any]) -> Result<Any, CraftNativeActionError> {
@@ -1389,8 +1390,9 @@ final class CraftNativePasskeys: NSObject, ASAuthorizationControllerDelegate, AS
 extension CraftNativeActions {
     /// The JSON text `craft.storage` keeps under `key`, or nil. The same store
     /// as the asynchronous Storage module, read without a bridge round trip.
-    static func storageJSON(forKey key: String) -> String? {
-        guard let key = validKey(key), let data = UserDefaults.standard.data(forKey: storagePrefix + key) else { return nil }
+    static func storageJSON(forKey key: String) throws -> String? {
+        guard let key = validKey(key) else { return nil }
+        guard let data = try CraftPersistentStorage.get(key, prefix: storagePrefix) else { return nil }
         return String(decoding: data, as: UTF8.self)
     }
 
@@ -1399,14 +1401,10 @@ extension CraftNativeActions {
     @discardableResult
     static func setStorageJSON(_ json: String?, forKey key: String) -> Bool {
         guard let key = validKey(key) else { return false }
-        guard let json else {
-            UserDefaults.standard.removeObject(forKey: storagePrefix + key)
+        do {
+            try CraftPersistentStorage.set(key, data: json.map { Data($0.utf8) }, prefix: storagePrefix)
             return true
-        }
-        let data = Data(json.utf8)
-        guard (try? JSONSerialization.jsonObject(with: data, options: [.fragmentsAllowed])) != nil else { return false }
-        UserDefaults.standard.set(data, forKey: storagePrefix + key)
-        return true
+        } catch { return false }
     }
 
     /// The Keychain item the web page's `craft.secureStorage` wrote under