@craft-native/ios 0.0.341 → 0.0.344

package/README.md

@@ -29,6 +29,19 @@ decoration. Resuming does not replay it. Available on both native renderers.
 - **Audio Recording** - AVAudioRecorder with compressed output
 - **Video Recording** - UIImagePickerController video capture
 
+### Native voice capture
+
+With `enableAudioRecording`, the native renderer exposes
+`craft.audioRecording.start(owner, { maxSeconds })`, `stop(owner)` and
+`cancel(owner)`. Use a fresh UUID owner and at most 300 seconds. Stop returns
+an owned temporary M4A descriptor with its MIME type, size and duration for
+`craft.files` multipart uploads. Cancel and backgrounding erase the recording.
+
+Permission is answered on the main thread. Recorder startup, stopping and
+file inspection run on a serial audio queue. Startup has a 15-second deadline
+after permission is granted; cancellation or timeout prevents a delayed encoder
+from publishing a recording. A startup failure leaves the interface responsive.
+
 ### Device Access
 
 - **Camera & Gallery** - Take photos or pick from gallery
@@ -1342,3 +1355,5 @@ when available. `monospace`/`ui-monospace`, `serif`/`ui-serif` and
 `sans-serif`/`ui-sans-serif`/`system-ui` select platform fonts, retaining requested
 weight, italic style and system text scaling. A missing custom face falls through
 to the next family rather than silently replacing a requested mono font with sans.
+
+The simulator driver requires a successful HTTP response from each control-server `exec` hook. A failed or unavailable hook fails XCTest and stops the journey before its next command.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@craft-native/ios",
-  "version": "0.0.341",
+  "version": "0.0.344",
   "homepage": "https://github.com/craft-native/craft/tree/main/packages/ios#readme",
   "repository": {
     "type": "git",

package/templates/CraftHybrid.swift

@@ -1796,12 +1796,18 @@ final class CraftHybridController: UIViewController, UINavigationControllerDeleg
                 hybrid.openOutside(raw)
                 return
             }
-            open(CraftHybridRoutes.appPath(of: url))
+            open(CraftHybridRoutes.appPath(of: url), props: props)
             return
         }
         guard let path = CraftHybridRoutes.normalize(raw) else { return }
         if let tab = hybrid.tabIds.first(where: { CraftHybridRoutes.normalize($0) == path }) {
-            selectTabAsIfTapped(tab)
+            if hybrid.routes.match(raw) != nil, URLComponents(string: raw)?.query != nil || !props.isEmpty {
+                // A checkout/auth return targets the retained tab with new
+                // parameters. Selecting alone would discard that handoff.
+                showNative(path: raw, replace: false, props: props)
+            } else {
+                selectTabAsIfTapped(tab)
+            }
             return
         }
         if hybrid.routes.match(raw) != nil {

package/templates/CraftVoiceRecording.swift

@@ -2,26 +2,80 @@ import AVFoundation
 import Foundation
 import UIKit
 
-/// One owner at a time, including the asynchronous permission prompt. A late
-/// permission answer cannot start recording after its screen/account left.
+protocol CraftVoiceRecorder: AnyObject {
+    func record(forDuration duration: TimeInterval) -> Bool
+    func stop()
+}
+extension AVAudioRecorder: CraftVoiceRecorder {}
+
+/// The main thread owns requests; audio and encoder work belong to one serial
+/// queue. Cancellation invalidates a request immediately, even while AVFoundation
+/// is starting, so a late permission/encoder answer cannot resurrect it.
 final class CraftVoiceRecording {
     static let shared = CraftVoiceRecording()
-    private var owner: String?
-    private var recorder: AVAudioRecorder?
-    private var file: URL?
+    private final class Session {
+        let key: String
+        var file: URL?
+        var recorder: CraftVoiceRecorder? // audio queue only
+        var completion: ((Result<Any, CraftNativeActionError>) -> Void)? // main only
+        var deadline: DispatchWorkItem?
+        private let lock = NSLock()
+        private var cancelled = false
+        init(key: String, completion: @escaping (Result<Any, CraftNativeActionError>) -> Void) {
+            self.key = key
+            self.completion = completion
+        }
+        var isCancelled: Bool { lock.withLock { cancelled } }
+        func invalidate() { lock.withLock { cancelled = true } }
+        func finish(_ result: Result<Any, CraftNativeActionError>) {
+            deadline?.cancel()
+            deadline = nil
+            let done = completion
+            completion = nil
+            done?(result)
+        }
+    }
+    private var current: Session?
+    private let audioQueue: DispatchQueue
+    private let permission: (@escaping (Bool) -> Void) -> Void
+    private let makeRecorder: (URL) throws -> CraftVoiceRecorder
+    private let deactivate: () -> Void
+    private let startupTimeout: TimeInterval
     private var backgroundObserver: NSObjectProtocol?
 
-    private init() {
+    init(audioQueue: DispatchQueue = DispatchQueue(label: "craft.voice-recording", qos: .userInitiated),
+         startupTimeout: TimeInterval = 15,
+         permission: @escaping (@escaping (Bool) -> Void) -> Void = { AVAudioSession.sharedInstance().requestRecordPermission($0) },
+         makeRecorder: @escaping (URL) throws -> CraftVoiceRecorder = { file in
+             let session = AVAudioSession.sharedInstance()
+             try session.setCategory(.record, mode: .measurement)
+             try session.setActive(true)
+             return try AVAudioRecorder(url: file, settings: [AVFormatIDKey: kAudioFormatMPEG4AAC, AVSampleRateKey: 16000, AVNumberOfChannelsKey: 1, AVEncoderBitRateKey: 32000])
+         },
+         deactivate: @escaping () -> Void = { try? AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation) }) {
+        self.audioQueue = audioQueue
+        self.startupTimeout = startupTimeout
+        self.permission = permission
+        self.makeRecorder = makeRecorder
+        self.deactivate = deactivate
         backgroundObserver = NotificationCenter.default.addObserver(forName: UIApplication.didEnterBackgroundNotification, object: nil, queue: .main) { [weak self] _ in self?.clear() }
     }
 
-    private func clear() {
-        owner = nil
-        recorder?.stop()
-        recorder = nil
-        if let file { CraftNativeFiles.remove(file.path) }
-        file = nil
-        try? AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation)
+    deinit { if let backgroundObserver { NotificationCenter.default.removeObserver(backgroundObserver) } }
+
+    private func erase(_ session: Session) {
+        session.recorder?.stop()
+        session.recorder = nil
+        if let file = session.file { CraftNativeFiles.remove(file.path) }
+        deactivate()
+    }
+
+    private func clear(_ error: CraftNativeActionError = CraftNativeActionError(code: "RECORDING_CANCELLED", message: "Recording was cancelled")) {
+        guard let session = current else { return }
+        current = nil
+        session.invalidate()
+        session.finish(.failure(error))
+        audioQueue.async { self.erase(session) }
     }
 
     func perform(method: String, args: [Any], isActive: @escaping () -> Bool = { true }, completion: @escaping (Result<Any, CraftNativeActionError>) -> Void) {
@@ -32,43 +86,84 @@ final class CraftVoiceRecording {
         func fail(_ code: String, _ message: String) { completion(.failure(CraftNativeActionError(code: code, message: message))) }
         guard let key = args.first as? String, UUID(uuidString: key) != nil else { fail("INVALID_ARGUMENT", "A recording owner UUID is required"); return }
         if method == "cancel" {
-            if owner == key { clear() }
+            if current?.key == key { clear() }
             completion(.success(true))
             return
         }
         if method == "stop" {
-            guard owner == key, let file else { fail("RECORDING_NOT_FOUND", "This recording is no longer available"); return }
-            recorder?.stop()
-            recorder = nil
-            try? AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation)
-            guard let audio = try? AVAudioFile(forReading: file), audio.length > 0 else { clear(); fail("EMPTY_RECORDING", "The recording was empty"); return }
-            let duration = Double(audio.length) / audio.processingFormat.sampleRate
-            completion(.success(CraftNativeFiles.describe(file, type: "audio/mp4", extra: ["durationSeconds": duration])))
+            guard let session = current, session.key == key, let file = session.file else { fail("RECORDING_NOT_FOUND", "This recording is no longer available"); return }
+            audioQueue.async {
+                guard !session.isCancelled else { return DispatchQueue.main.async { fail("RECORDING_CANCELLED", "Recording was cancelled") } }
+                session.recorder?.stop()
+                session.recorder = nil
+                self.deactivate()
+                let result: Result<Any, CraftNativeActionError>
+                if let audio = try? AVAudioFile(forReading: file), audio.length > 0 {
+                    let duration = Double(audio.length) / audio.processingFormat.sampleRate
+                    result = .success(CraftNativeFiles.describe(file, type: "audio/mp4", extra: ["durationSeconds": duration]))
+                } else {
+                    result = .failure(CraftNativeActionError(code: "EMPTY_RECORDING", message: "The recording was empty"))
+                }
+                DispatchQueue.main.async {
+                    guard self.current === session, isActive(), !session.isCancelled else {
+                        if self.current === session { self.clear() }
+                        fail("RECORDING_CANCELLED", "Recording was cancelled")
+                        return
+                    }
+                    if case .failure = result { self.clear() }
+                    completion(result)
+                }
+            }
             return
         }
         guard method == "start" else { fail("UNKNOWN_ACTION", "Unknown voice recording action"); return }
         guard isActive() else { fail("RECORDING_CANCELLED", "The requesting screen has closed"); return }
-        guard owner == nil else { fail("RECORDING_BUSY", "Another microphone session is still active"); return }
+        guard current == nil else { fail("RECORDING_BUSY", "Another microphone session is still active"); return }
         let options = args.count > 1 ? args[1] as? [String: Any] ?? [:] : [:]
         let seconds = (options["maxSeconds"] as? NSNumber)?.doubleValue ?? 300
         guard seconds.isFinite, seconds >= 1, seconds <= 300 else { fail("INVALID_ARGUMENT", "Recordings are limited to five minutes"); return }
-        owner = key
-        AVAudioSession.sharedInstance().requestRecordPermission { allowed in
+        let session = Session(key: key, completion: completion)
+        current = session
+        permission { allowed in
             DispatchQueue.main.async {
-                guard self.owner == key, isActive() else { if self.owner == key { self.clear() }; fail("RECORDING_CANCELLED", "Recording was cancelled"); return }
-                guard allowed else { self.clear(); fail("PERMISSION_DENIED", "Microphone permission was refused"); return }
-                do {
-                    let session = AVAudioSession.sharedInstance()
-                    try session.setCategory(.record, mode: .measurement)
-                    try session.setActive(true)
-                    let file = try CraftNativeFiles.newFile(named: "voice-feedback.m4a")
-                    self.file = file
-                    let recorder = try AVAudioRecorder(url: file, settings: [AVFormatIDKey: kAudioFormatMPEG4AAC, AVSampleRateKey: 16000, AVNumberOfChannelsKey: 1, AVEncoderBitRateKey: 32000])
-                    self.recorder = recorder
-                    guard recorder.record(forDuration: max(0.5, seconds - 0.25)) else { throw CraftNativeActionError(code: "RECORDING_FAILED", message: "The microphone could not start") }
-                    completion(.success(true))
+                guard self.current === session, isActive() else {
+                    if self.current === session { self.clear() }
+                    session.finish(.failure(CraftNativeActionError(code: "RECORDING_CANCELLED", message: "Recording was cancelled")))
+                    return
+                }
+                guard allowed else { self.clear(CraftNativeActionError(code: "PERMISSION_DENIED", message: "Microphone permission was refused")); return }
+                do { session.file = try CraftNativeFiles.newFile(named: "voice-feedback.m4a") }
+                catch { self.clear(CraftNativeActionError(code: "RECORDING_FAILED", message: "The recording file could not be created")); return }
+                guard let file = session.file else { return }
+                let deadline = DispatchWorkItem { [weak host = self] in
+                    guard let host, host.current === session else { return }
+                    host.clear(CraftNativeActionError(code: "RECORDING_TIMEOUT", message: "The microphone took too long to start. Please try again."))
+                }
+                session.deadline = deadline
+                DispatchQueue.main.asyncAfter(deadline: .now() + self.startupTimeout, execute: deadline)
+                self.audioQueue.async {
+                    do {
+                        guard !session.isCancelled else { return }
+                        session.recorder = try self.makeRecorder(file)
+                        guard !session.isCancelled else { self.erase(session); return }
+                        guard session.recorder?.record(forDuration: max(0.5, seconds - 0.25)) == true else {
+                            throw CraftNativeActionError(code: "RECORDING_FAILED", message: "The microphone could not start")
+                        }
+                        guard !session.isCancelled else { self.erase(session); return }
+                        DispatchQueue.main.async {
+                            guard self.current === session, isActive() else {
+                                if self.current === session { self.clear() }
+                                return
+                            }
+                            session.finish(.success(true))
+                        }
+                    }
+                    catch {
+                        DispatchQueue.main.async {
+                            if self.current === session { self.clear(CraftNativeActionError(code: "RECORDING_FAILED", message: "The microphone could not start")) }
+                        }
+                    }
                 }
-                catch { self.clear(); fail("RECORDING_FAILED", "The microphone could not start") }
             }
         }
     }

package/templates/testing/DriverTests.swift.template

@@ -64,7 +64,10 @@ final class DriverTests: XCTestCase {
     func get(_ path: String, timeout: Double = 15) -> Data? {
         var result: Data?
         let done = expectation(description: path)
-        URLSession.shared.dataTask(with: URL(string: control + path)!) { data, _, _ in result = data; done.fulfill() }.resume()
+        URLSession.shared.dataTask(with: URL(string: control + path)!) { data, response, error in
+            if error == nil, let response = response as? HTTPURLResponse, (200..<300).contains(response.statusCode) { result = data }
+            done.fulfill()
+        }.resume()
         wait(for: [done], timeout: timeout)
         return result
     }
@@ -332,7 +335,10 @@ final class DriverTests: XCTestCase {
         case "net": _ = get("/\(arg)"); note("net \(arg)")
         case "delay": _ = get("/delay?ms=\(arg)"); note("delay \(arg)ms")
         case "exec":
-            let out = get("/exec?name=\(arg)", timeout: 180).flatMap { String(data: $0, encoding: .utf8) } ?? "no answer"
+            guard let data = get("/exec?name=\(arg)", timeout: 180), let out = String(data: data, encoding: .utf8) else {
+                check(false, "exec \(arg): hook failed or returned no successful response")
+                return
+            }
             note("exec \(arg): \(out.trimmingCharacters(in: .whitespacesAndNewlines))")
         case "openurl":
             if let url = URL(string: arg) {