craft-native 0.0.238 → 0.0.242

package/dist/ios/src/testing.d.ts

@@ -66,15 +66,27 @@ export type SimulatorStep = {
     index: number;
     text: string;
 } | {
-    command: 'typeid' | 'labelid';
+    command: 'typeid' | 'labelid' | 'valueid';
     id: string;
     text: string;
+}
+/** Adjust an actual native UISlider by identifier, using its normalized range. */
+ | {
+    command: 'sliderid';
+    id: string;
+    position: number;
+}
+/** Assert a handoff reached the foreground application without launching it. */
+ | {
+    command: 'expectapp';
+    text: string;
+    seconds?: number;
 } | {
     command: 'expect' | 'expectexact' | 'expectid' | 'systemexpect';
     text: string;
     seconds?: number;
 } | {
-    command: 'tap' | 'tapif' | 'tapid' | 'tapexact' | 'type' | 'absent' | 'absentid' | 'selected' | 'tab' | 'scrollto' | 'dismiss' | 'log' | 'systemtap' | 'systemabsent';
+    command: 'tap' | 'tapif' | 'tapid' | 'longpressid' | 'tapexact' | 'type' | 'absent' | 'absentid' | 'selected' | 'tab' | 'scrollto' | 'dismiss' | 'log' | 'systemtap' | 'systemabsent';
     text: string;
 } | {
     command: 'shot' | 'tree' | 'audit' | 'exec' | 'systemtree';

package/dist/ios/templates/CraftApp.swift

@@ -251,6 +251,17 @@ final class CraftAppDelegate: NSObject, UIApplicationDelegate, UNUserNotificatio
         CraftEventManager.shared.sendToWeb("craftSilentPush", data: ["id": id, "payload": CraftEventManager.pageData(userInfo)])
     }
 
+    /// iOS relaunched the app because `craft.media.keep`'s background
+    /// transfers finished (CraftNativeMediaTransfers): their session takes
+    /// the events, stores the files, then says it is done.
+    func application(_ application: UIApplication, handleEventsForBackgroundURLSession identifier: String, completionHandler: @escaping () -> Void) {
+        guard identifier == CraftNativeMediaTransfers.identifier else {
+            completionHandler()
+            return
+        }
+        CraftNativeMediaTransfers.shared.backgroundCompletion = completionHandler
+    }
+
     func application(_ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data) {
         let token = deviceToken.map { String(format: "%02x", $0) }.joined()
         NotificationCenter.default.post(name: .craftPushToken, object: token)
@@ -679,6 +690,9 @@ final class CraftChrome: ObservableObject {
     private var splashDeadline: DispatchWorkItem?
     private var tabSwipePrevious: String?
     private var tabSwipeTarget: String?
+    /// One generator for every tab change. A new one per tick started the
+    /// Taptic Engine cold each time, on the main thread, late.
+    private let selectionFeedback = UISelectionFeedbackGenerator()
     /// The keyboard is up and covers the tab bar, so the page need not leave
     /// room for it: the web view ends at the keyboard (CraftHybrid's webHost).
     private var keyboardUp = false
@@ -866,7 +880,7 @@ final class CraftChrome: ObservableObject {
     func swipe(to id: String) {
         guard id != selected, tabs.contains(where: { $0.id == id }) else { return }
         withAnimation(Self.motion(.spring(response: 0.32, dampingFraction: 0.86))) { selected = id }
-        UISelectionFeedbackGenerator().selectionChanged()
+        selectionFeedback.selectionChanged()
         guard CraftHybrid.shared.tabTapped(id, reselect: false) else { return }
         emit("craftTabSelect", ["id": id])
     }
@@ -875,13 +889,19 @@ final class CraftChrome: ObservableObject {
     /// controller commits or restores this preview when the finger lifts.
     func beginTabSwipe(to id: String, from previous: String) {
         guard id != previous, tabs.contains(where: { $0.id == id }) else { return }
+        // The tick comes as the swipe commits; wake the Taptic Engine now, as
+        // UIFeedbackGenerator asks, so it is on time rather than late.
+        selectionFeedback.prepare()
         // A page's pending selection report may disagree with the native
         // stack. Cancellation belongs to the stack the finger left.
         tabSwipePrevious = previous
         tabSwipeTarget = id
+        // Only the indicator moves now. The highlight follows it across the
+        // midpoint (updateTabSwipe), as iOS's own tab bar lens does; turning
+        // it at once rebuilt every tab in the swipe's first frame, which is
+        // also when UIKit puts the incoming screen on screen.
         withAnimation(nil) {
             tabSwipePosition = tabs.firstIndex(where: { $0.id == previous }).map { CGFloat($0) }
-            selected = id
         }
     }
 
@@ -893,11 +913,14 @@ final class CraftChrome: ObservableObject {
               let to = tabs.firstIndex(where: { $0.id == target }) else { return }
         let position = CGFloat(from) + CGFloat(to - from) * min(1, max(0, progress))
         if tabSwipePosition != position { withAnimation(nil) { tabSwipePosition = position } }
+        let lit = progress >= 0.5 ? target : previous
+        if selected != lit { withAnimation(nil) { selected = lit } }
     }
 
     func settleTabSwipe(completed: Bool, duration: TimeInterval) {
         guard let id = completed ? tabSwipeTarget : tabSwipePrevious,
               let index = tabs.firstIndex(where: { $0.id == id }) else { return }
+        if selected != id { withAnimation(nil) { selected = id } }
         withAnimation(Self.motion(.easeOut(duration: duration))) { tabSwipePosition = CGFloat(index) }
     }
 
@@ -917,7 +940,7 @@ final class CraftChrome: ObservableObject {
         withAnimation(nil) { tabSwipePosition = nil }
         guard tabs.contains(where: { $0.id == id }) else { return }
         withAnimation(nil) { selected = id }
-        UISelectionFeedbackGenerator().selectionChanged()
+        selectionFeedback.selectionChanged()
         guard CraftHybrid.shared.tabTapped(id, reselect: false) else { return }
         emit("craftTabSelect", ["id": id])
     }
@@ -1183,9 +1206,20 @@ struct CraftTabBarView: View {
 
     /// The filled variant for the current tab, when the symbol has one.
     private func symbol(_ name: String, selected: Bool) -> String {
-        guard selected, !name.hasSuffix(".fill"), UIImage(systemName: "\(name).fill") != nil else { return name }
+        guard selected, !name.hasSuffix(".fill"), Self.hasFilledSymbol(name) else { return name }
         return "\(name).fill"
     }
+
+    /// Whether `<name>.fill` exists, asked of the symbol catalog once per
+    /// name: the bar's body runs again for every selection change and asked
+    /// it for every tab each time.
+    private static var filledSymbols: [String: Bool] = [:]
+    private static func hasFilledSymbol(_ name: String) -> Bool {
+        if let known = filledSymbols[name] { return known }
+        let exists = UIImage(systemName: "\(name).fill") != nil
+        filledSymbols[name] = exists
+        return exists
+    }
 }
 
 private struct CraftTabSelectionIndicator: View {
@@ -1267,13 +1301,14 @@ class DeepLinkManager {
     // Every link that arrived while no page could receive it, in order. This
     // was a single slot, so a second link before the bridge was ready replaced
     // the first; on a cold start, that could be the link that launched the app.
-    private var pendingURLs: [URL] = []
+    private var pendingURLs: [(url: URL, initial: Bool)] = []
+    private var replayingNativeLinks = false
     private weak var webView: WKWebView?
     private var isReady = false
     // Replay bookkeeping only. A native screen can become ready before UIKit
     // delivers the launch URL; listener readiness cannot classify that URL.
     private var hasBeenReady = false
-    private var nativeListeners: [UUID: (URL, Bool) -> Void] = [:]
+    private var nativeListeners: [UUID: (canReceive: () -> Bool, receive: (URL, Bool) -> Void)] = [:]
 
     private init() {
         for name in [UIApplication.didBecomeActiveNotification, UIApplication.didEnterBackgroundNotification] {
@@ -1297,12 +1332,11 @@ class DeepLinkManager {
 
     func setReady() {
         isReady = true
-        let firstPage = !hasBeenReady
         hasBeenReady = true
         let urls = pendingURLs
         pendingURLs.removeAll()
-        for url in urls {
-            dispatchDeepLink(url, initial: firstPage && url == initialURL)
+        for link in urls {
+            dispatchDeepLink(link.url, initial: link.initial)
         }
     }
 
@@ -1316,21 +1350,21 @@ class DeepLinkManager {
             if CraftHybrid.shared.handleDeepLink(url) {
                 dispatchNative(url, initial: false)
             } else if !CraftHybrid.shared.hasWeb {
-                if nativeListeners.isEmpty { pendingURLs.append(url) } else { dispatchNative(url, initial: false) }
+                enqueueNative(url)
             } else if isReady && webView != nil {
                 dispatchDeepLink(url, initial: false)
             } else {
-                pendingURLs.append(url)
+                pendingURLs.append((url, !hasBeenReady && url == initialURL))
             }
             return
         }
 
         if !nativeListeners.isEmpty {
-            dispatchNative(url, initial: false)
+            enqueueNative(url)
         } else if isReady && webView != nil {
             dispatchDeepLink(url, initial: false)
         } else {
-            pendingURLs.append(url)
+            pendingURLs.append((url, !hasBeenReady && url == initialURL))
         }
     }
 
@@ -1350,20 +1384,14 @@ class DeepLinkManager {
     }
 
     @discardableResult
-    func addNativeListener(_ listener: @escaping (URL, Bool) -> Void) -> UUID {
+    func addNativeListener(canReceive: @escaping () -> Bool = { true }, _ listener: @escaping (URL, Bool) -> Void) -> UUID {
         let token = UUID()
-        nativeListeners[token] = listener
+        nativeListeners[token] = (canReceive, listener)
         // In a hybrid app the page is the one waiting for the links that
         // arrived early; a native screen hears only native ones, as they come.
         // An all-native app has no page, so its first screen hears them.
         if CraftHybrid.shared.isEnabled && CraftHybrid.shared.hasWeb { return token }
-        let firstNativeScreen = !hasBeenReady
-        hasBeenReady = true
-        let urls = pendingURLs
-        pendingURLs.removeAll()
-        for url in urls {
-            listener(url, firstNativeScreen && url == initialURL)
-        }
+        replayNativeLinks()
         return token
     }
 
@@ -1371,8 +1399,31 @@ class DeepLinkManager {
         nativeListeners.removeValue(forKey: token)
     }
 
+    private func enqueueNative(_ url: URL) {
+        pendingURLs.append((url, !hasBeenReady && url == initialURL))
+        replayNativeLinks()
+    }
+
+    /// Registration can happen while a controller is being prewarmed. Keep
+    /// links until a screen is visible, including across a tab switch.
+    func replayNativeLinks() {
+        guard !(CraftHybrid.shared.isEnabled && CraftHybrid.shared.hasWeb), !replayingNativeLinks else { return }
+        replayingNativeLinks = true
+        defer { replayingNativeLinks = false }
+        while let link = pendingURLs.first {
+            let receivers = nativeListeners.values.filter { $0.canReceive() }
+            guard !receivers.isEmpty else { return }
+            pendingURLs.removeFirst()
+            hasBeenReady = true
+            for receiver in receivers { receiver.receive(link.url, link.initial) }
+        }
+    }
+
     private func dispatchNative(_ url: URL, initial: Bool) {
-        for listener in nativeListeners.values { listener(url, initial) }
+        // The hybrid shell already opened this route; notify visible screens
+        // without queuing a second navigation for its future destination.
+        let receivers = nativeListeners.values.filter { $0.canReceive() }
+        for receiver in receivers { receiver.receive(url, initial) }
     }
 
     private func dispatchDeepLink(_ url: URL, initial: Bool) {
@@ -1991,6 +2042,9 @@ struct CraftWebView: UIViewRepresentable {
         private var locationManager: CLLocationManager?
         private var singleLocationCallbackId: String?
         private var singleLocationTimeoutWorkItem: DispatchWorkItem?
+        private var singleLocationTimeoutMilliseconds: Double = 30_000
+        private var singleLocationAcquisitionStarted = false
+        private var singleLocationAuthorizationRequested = false
         private var locationPermissionCallbackId: String?
         private var locationPermissionRequiresAlways = false
         private var isWatchingLocation = false
@@ -2065,7 +2119,7 @@ struct CraftWebView: UIViewRepresentable {
         // SQLite database
         private var db: OpaquePointer?
 
-        init(config: CraftConfig, recordingDirectory: URL? = nil) {
+        init(config: CraftConfig, locationManager suppliedLocationManager: CLLocationManager? = nil, recordingDirectory: URL? = nil) {
             self.recordingDirectory = recordingDirectory
             self.config = config
             super.init()
@@ -2073,7 +2127,7 @@ struct CraftWebView: UIViewRepresentable {
                 speechRecognizer = SFSpeechRecognizer(locale: Locale(identifier: "en-US"))
             }
             if config.enableGeolocation {
-                locationManager = CLLocationManager()
+                locationManager = suppliedLocationManager ?? CLLocationManager()
                 locationManager?.desiredAccuracy = kCLLocationAccuracyBest
                 locationManager?.activityType = .fitness
                 locationManager?.pausesLocationUpdatesAutomatically = false
@@ -6400,7 +6454,7 @@ struct CraftWebView: UIViewRepresentable {
             }
             singleLocationCallbackId = callbackId
             let maximumAge = max(0, (body["maximumAge"] as? NSNumber)?.doubleValue ?? 0)
-            if maximumAge > 0,
+            if (manager.authorizationStatus == .authorizedAlways || manager.authorizationStatus == .authorizedWhenInUse), maximumAge > 0,
                let cachedLocation = manager.location,
                max(0, Date().timeIntervalSince(cachedLocation.timestamp) * 1000) <= maximumAge {
                 finishSingleLocationRequest()
@@ -6408,7 +6462,35 @@ struct CraftWebView: UIViewRepresentable {
                 return
             }
 
-            let timeoutMs = max(0, (body["timeout"] as? NSNumber)?.doubleValue ?? 30_000)
+            singleLocationTimeoutMilliseconds = max(0, (body["timeout"] as? NSNumber)?.doubleValue ?? 30_000)
+            continueSingleLocationRequest(manager)
+        }
+
+        private func continueSingleLocationRequest(_ manager: CLLocationManager) {
+            guard let callbackId = singleLocationCallbackId else { return }
+            switch manager.authorizationStatus {
+            case .notDetermined:
+                if !singleLocationAuthorizationRequested {
+                    singleLocationAuthorizationRequested = true
+                    manager.requestWhenInUseAuthorization()
+                }
+                return
+            case .denied, .restricted:
+                finishSingleLocationRequest()
+                rejectCallback(callbackId, error: "Location permission was denied.", code: "PERMISSION_DENIED")
+                return
+            case .authorizedAlways, .authorizedWhenInUse:
+                break
+            @unknown default:
+                finishSingleLocationRequest()
+                rejectCallback(callbackId, error: "Location authorization is unavailable.", code: "PERMISSION_DENIED")
+                return
+            }
+            guard !singleLocationAcquisitionStarted else { return }
+            singleLocationAcquisitionStarted = true
+            // The acquisition timeout starts after the person decides. A
+            // permission sheet is not a failed or timed-out GPS fix.
+            let timeoutMs = singleLocationTimeoutMilliseconds
             let timeoutWorkItem = DispatchWorkItem { [weak self] in
                 guard let self, self.singleLocationCallbackId == callbackId else { return }
                 self.finishSingleLocationRequest()
@@ -6416,7 +6498,6 @@ struct CraftWebView: UIViewRepresentable {
             }
             singleLocationTimeoutWorkItem = timeoutWorkItem
             DispatchQueue.main.asyncAfter(deadline: .now() + .milliseconds(Int(min(timeoutMs + 100, Double(Int.max)))), execute: timeoutWorkItem)
-            requestLocationAuthorization()
             manager.requestLocation()
         }
 
@@ -6424,6 +6505,8 @@ struct CraftWebView: UIViewRepresentable {
             singleLocationTimeoutWorkItem?.cancel()
             singleLocationTimeoutWorkItem = nil
             singleLocationCallbackId = nil
+            singleLocationAcquisitionStarted = false
+            singleLocationAuthorizationRequested = false
             locationManager?.desiredAccuracy = kCLLocationAccuracyBest
         }
 
@@ -6753,6 +6836,10 @@ struct CraftWebView: UIViewRepresentable {
 
         func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
             let nativeError = error as NSError
+            if nativeError.domain == kCLErrorDomain, nativeError.code == CLError.Code.denied.rawValue,
+               manager.authorizationStatus == .notDetermined, singleLocationCallbackId != nil, !singleLocationAcquisitionStarted {
+                return
+            }
             // kCLErrorLocationUnknown is Core Location saying it has no fix
             // *yet*, not that it failed. requestLocation gives up on it, so a
             // one-shot asks again shortly instead of failing a caller whose
@@ -6761,7 +6848,7 @@ struct CraftWebView: UIViewRepresentable {
             if nativeError.domain == kCLErrorDomain && nativeError.code == CLError.Code.locationUnknown.rawValue {
                 if let waiting = singleLocationCallbackId {
                     DispatchQueue.main.asyncAfter(deadline: .now() + .seconds(1)) { [weak self] in
-                        guard let self, self.singleLocationCallbackId == waiting else { return }
+                        guard let self, self.singleLocationCallbackId == waiting, self.singleLocationAcquisitionStarted else { return }
                         self.locationManager?.requestLocation()
                     }
                 }
@@ -6777,6 +6864,7 @@ struct CraftWebView: UIViewRepresentable {
         }
 
         func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
+            if singleLocationCallbackId != nil { continueSingleLocationRequest(manager) }
             guard let callbackId = locationPermissionCallbackId else { return }
             let status = manager.authorizationStatus
             if status == .notDetermined { return }