craft-native 0.0.220 → 0.0.222

package/dist/android/templates/CraftNativeShell.kt.template

@@ -894,6 +894,7 @@ internal class CraftNativeChrome(context: Context, private val tabs: List<CraftN
         accessory.background = GradientDrawable().apply { setColor(surface); cornerRadius = dp(32).toFloat() }
         accessorySpec?.let { accessoryIcon.setImageDrawable(CraftNativeIcons.drawable(context, null, it.optString("symbol"), text)) }
         tabViews.forEachIndexed { index, (icon, label) ->
+            tabBar.getChildAt(index).isSelected = index == selectedTab
             val color = if (index == selectedTab) accent else muted
             val number = tabIconText[tabs[index].id]
             icon.setTextColor(if (number != null) Color.parseColor("#FF2D55") else color)

package/dist/android/templates/MainActivityNative.kt.template

@@ -3780,6 +3780,8 @@ class MainActivity : AppCompatActivity() {
     private var tabSwipeTarget: Screen? = null
     private var tabSwipeTargetIndex = -1
     private var tabSwipeDirection = 0
+    private var tabSwipeGeneration = 0
+    private var tabSwipeSettling = false
     /** The app script's isolate (`nativeApp`), when the app has one. */
     private var appScreen: Screen? = null
     private val urlSchemes = mutableSetOf<String>()
@@ -3960,6 +3962,7 @@ class MainActivity : AppCompatActivity() {
         bars.onAccessory = { path -> navigateOpen(path) }
         bars.onButton = { id -> visibleScreen?.takeIf { it.active }?.let { send(it, "NAV_BUTTON", JSONObject().put("id", id)) } }
         bars.onTab = { index ->
+            interruptTabSwipe()
             haptic()
             if (index == currentTab) popToRoot() else selectTab(index)
         }
@@ -3996,6 +3999,7 @@ class MainActivity : AppCompatActivity() {
     /** A tab chosen: its stack shows, its root screen opened the first time. */
     private fun selectTab(index: Int) {
         if (index !in tabStacks.indices) return
+        interruptTabSwipe()
         currentTab = index
         screens = tabStacks[index]
         chrome?.selectTab(index)
@@ -4017,6 +4021,7 @@ class MainActivity : AppCompatActivity() {
 
     /** Start an interactive horizontal transition to the adjacent tab. */
     private fun beginTabSwipe(dx: Float, x: Float, y: Float): Boolean {
+        if (tabSwipeSettling) interruptTabSwipe()
         if (tabSwipeTarget != null || screens.size != 1 || chrome?.tabSwipeEnabled != true) return false
         val direction = if (dx < 0) 1 else -1
         val targetIndex = currentTab + direction
@@ -4055,16 +4060,23 @@ class MainActivity : AppCompatActivity() {
         val host = chrome?.content ?: return
         val width = host.width.toFloat().coerceAtLeast(1f)
         val complete = !cancelled && kotlin.math.abs(dx) >= width * 0.28f
+        val generation = ++tabSwipeGeneration
+        val targetIndex = tabSwipeTargetIndex
+        tabSwipeSettling = true
         val endOffset = if (complete) {
             if (tabSwipeDirection > 0) -width else width
         } else 0f
         val targetOffset = if (complete) 0f else if (tabSwipeDirection > 0) width else -width
         current.view.animate().translationX(endOffset).setDuration(180).start()
         target.view.animate().translationX(targetOffset).setDuration(180).withEndAction {
+            // A later tab tap or gesture owns the display even if Android
+            // delivers this animator's completion after it was cancelled.
+            if (generation != tabSwipeGeneration || tabSwipeTarget !== target || visibleScreen !== current) return@withEndAction
             target.view.animate().setListener(null)
+            tabSwipeSettling = false
             if (complete) {
                 current.view.translationX = 0f
-                currentTab = tabSwipeTargetIndex
+                currentTab = targetIndex
                 screens = tabStacks[currentTab]
                 tabSwipeTarget = null
                 tabSwipeTargetIndex = -1
@@ -4082,6 +4094,24 @@ class MainActivity : AppCompatActivity() {
         }.start()
     }
 
+    /** Restore the owning stack before a newer navigation action takes over. */
+    private fun interruptTabSwipe() {
+        val target = tabSwipeTarget ?: return
+        ++tabSwipeGeneration
+        tabSwipeTarget = null
+        tabSwipeTargetIndex = -1
+        tabSwipeDirection = 0
+        tabSwipeSettling = false
+        val current = visibleScreen
+        current?.view?.animate()?.withEndAction(null)?.setListener(null)?.cancel()
+        target.view.animate().withEndAction(null).setListener(null).cancel()
+        current?.view?.translationX = 0f
+        target.view.translationX = 0f
+        if (target !== current) (target.view.parent as? ViewGroup)?.removeView(target.view)
+        chrome?.selectTab(currentTab)
+        current?.let(::applyChrome)
+    }
+
     /**
      * Returns true when the exact screen gesture point is over a horizontal
      * child that still has room in the gesture's direction. Screen coordinates
@@ -4172,6 +4202,7 @@ class MainActivity : AppCompatActivity() {
     }
 
     private fun openScreen(route: String?, params: JSONObject = JSONObject(), headless: Boolean = false, showImmediately: Boolean = true): Screen? {
+        if (showImmediately && !headless) interruptTabSwipe()
         val engine = sandbox ?: return null
         val isolate = engine.createIsolate()
         val view = CraftNativeFlexLayout(this).apply {
@@ -6943,6 +6974,7 @@ class MainActivity : AppCompatActivity() {
 
     /** Back to the first screen in one move. */
     private fun popToRoot() {
+        interruptTabSwipe()
         val stack = screens
         val removed = mutableListOf<Screen>()
         while (stack.size > 1) removed.add(stack.removeAt(stack.lastIndex))
@@ -6954,6 +6986,7 @@ class MainActivity : AppCompatActivity() {
 
     /** Back: the screen below in this tab, then the first tab, then out of the app. */
     private fun back() {
+        interruptTabSwipe()
         // A previous back is still draining its screen's teardown messages.
         if (visibleScreen == null) return
         if (screens.size > 1) {
@@ -7281,6 +7314,7 @@ class MainActivity : AppCompatActivity() {
     }
 
     override fun onDestroy() {
+        interruptTabSwipe()
         if (animationScaleObserverRegistered) contentResolver.unregisterContentObserver(animationScaleObserver)
         CraftNativeBackground.foreground = null
         backgroundWaiters.values.forEach { it(false) }

package/dist/cli.js

@@ -3424,7 +3424,7 @@ function pinCraftNativeDependency(packagePath, craftVersion) {
 `);
 }
 // package.json
-var version = "0.0.220";
+var version = "0.0.222";
 
 // bin/cli.ts
 var spawnedFrom = process6.env[CRAFT_CLI_SPAWN_MARKER];

package/dist/index.cjs

@@ -309,7 +309,7 @@ function craftBinaryNotFoundMessage(triedPath) {
 `);
 }
 // package.json
-var version = "0.0.220";
+var version = "0.0.222";
 
 // src/sdk-version.ts
 var SDK_VERSION = version;

package/dist/index.js

@@ -57,7 +57,7 @@ function craftBinaryNotFoundMessage(triedPath) {
 `);
 }
 // package.json
-var version = "0.0.220";
+var version = "0.0.222";
 
 // src/sdk-version.ts
 var SDK_VERSION = version;

package/dist/ios/templates/CraftApp.swift

@@ -1105,23 +1105,58 @@ struct CraftSplashView: View {
 }
 
 // MARK: - Deep Link Manager
+/// Launch intent settles when UIKit delivers its URL or completes activation,
+/// independently of when a page or native screen registers its listeners.
+final class CraftInitialLinkState {
+    private(set) var url: URL?
+    private(set) var settled = false
+    private var readers: [(URL?) -> Void] = []
+
+    func receive(_ url: URL) {
+        guard !settled else { return }
+        self.url = url
+        settle()
+    }
+
+    func settle() {
+        guard !settled else { return }
+        settled = true
+        let waiting = readers
+        readers.removeAll()
+        for reader in waiting { reader(url) }
+    }
+
+    func resolve(_ completion: @escaping (URL?) -> Void) {
+        if settled { completion(url) }
+        else { readers.append(completion) }
+    }
+}
+
 class DeepLinkManager {
     static let shared = DeepLinkManager()
 
-    private var initialURL: URL?
+    private let launch = CraftInitialLinkState()
+    private var initialURL: URL? { launch.url }
+    private var activationObservers: [NSObjectProtocol] = []
     // 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 weak var webView: WKWebView?
     private var isReady = false
-    // Whether a page has ever become ready. A link that arrives before that is
-    // the one the app was opened with; a link that arrives later is not, and
-    // is no answer to getInitialURL.
+    // 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 init() {}
+    private init() {
+        for name in [UIApplication.didBecomeActiveNotification, UIApplication.didEnterBackgroundNotification] {
+            activationObservers.append(NotificationCenter.default.addObserver(forName: name, object: nil, queue: .main) { [weak self] _ in
+                self?.launch.settle()
+            })
+        }
+        if UIApplication.shared.applicationState == .active { launch.settle() }
+    }
 
     func setWebView(_ webView: WKWebView) {
         self.webView = webView
@@ -1146,9 +1181,7 @@ class DeepLinkManager {
     }
 
     func handleURL(_ url: URL) {
-        if initialURL == nil && !hasBeenReady {
-            initialURL = url
-        }
+        launch.receive(url)
 
         // A hybrid app opens a native path's screen itself, and tells the
         // native screens that listen; every other link is the page's. An
@@ -1179,6 +1212,17 @@ class DeepLinkManager {
         return initialURL
     }
 
+    /// A foreground scene can draw before SwiftUI delivers its launch activity.
+    /// A headless background launch has no scene or foreground URL to await.
+    func resolveInitialURL(_ completion: @escaping (URL?) -> Void) {
+        let application = UIApplication.shared
+        if application.applicationState == .active ||
+            (application.applicationState == .background && application.connectedScenes.isEmpty) {
+            launch.settle()
+        }
+        launch.resolve(completion)
+    }
+
     @discardableResult
     func addNativeListener(_ listener: @escaping (URL, Bool) -> Void) -> UUID {
         let token = UUID()

package/dist/ios/templates/CraftHeartRate.swift

@@ -135,6 +135,13 @@ final class CraftHeartRate: NSObject, CBCentralManagerDelegate, CBPeripheralDele
     /// Fourteen hours of one reading a second: more is not one workout.
     static let maxRecordedSamples = 50_000
 
+    private let clock: () -> Date
+
+    init(now: @escaping () -> Date = Date.init) {
+        self.clock = now
+        super.init()
+    }
+
     /// The web view's coordinator, which sends an event to the page and every
     /// native screen. False (or unset, in an app without a web view) and the
     /// event goes to the native screens alone.
@@ -155,6 +162,12 @@ final class CraftHeartRate: NSObject, CBCentralManagerDelegate, CBPeripheralDele
     private var connectDeadline: DispatchWorkItem?
     private var latest: CraftHeartRateMeasurement?
     private var latestAt: Date?
+    // Packet freshness is separate from a valid BPM: a monitor reporting no
+    // skin contact is still delivering notifications and needs no reconnect.
+    private var packetAt: Date?
+    private var subscriptionAt: Date?
+    private var recoveryTimer: Timer?
+    private var hasSubscribed = false
 
     private var recordingId: String?
     private var recordingStartedAt: Double?
@@ -189,7 +202,9 @@ final class CraftHeartRate: NSObject, CBCentralManagerDelegate, CBPeripheralDele
         DispatchQueue.main.async {
             self.restoreRecording()
             switch method {
-            case "getState": completion(.success(self.state()))
+            case "getState":
+                self.recoverQuietBroadcast()
+                completion(.success(self.state()))
             case "requestAuthorization": self.requestAuthorization(completion: completion)
             case "scan": self.scan(seconds: (options["timeout"] as? NSNumber)?.doubleValue, completion: completion)
             case "stopScan":
@@ -255,7 +270,7 @@ final class CraftHeartRate: NSObject, CBCentralManagerDelegate, CBPeripheralDele
     }
 
     func state() -> [String: Any] {
-        let fresh = latestAt.map { Date().timeIntervalSince($0) <= Self.staleAfter } ?? false
+        let fresh = latestAt.map { clock().timeIntervalSince($0) <= Self.staleAfter } ?? false
         let device: Any = deviceId.map { ["id": $0.uuidString, "name": deviceName ?? "Heart rate monitor"] as [String: Any] } ?? NSNull()
         return [
             "available": bluetooth != "unsupported",
@@ -393,8 +408,10 @@ final class CraftHeartRate: NSObject, CBCentralManagerDelegate, CBPeripheralDele
         }
         whenReady {
             if let reason = self.unusable() { return completion(.failure(reason)) }
-            // Already there, or on the way: nothing to start again.
+            // A connected link can lose its notification subscription when a
+            // broadcasting watch restarts. Keep healthy links, repair quiet ones.
             if self.deviceId == uuid && self.wantsConnection {
+                self.recoverQuietBroadcast()
                 if self.connection == "connected" || !wait { return completion(.success(self.state())) }
                 self.connectWaiters.append(completion)
                 self.armConnectDeadline()
@@ -416,6 +433,8 @@ final class CraftHeartRate: NSObject, CBCentralManagerDelegate, CBPeripheralDele
             self.deviceName = name
             self.wantsConnection = true
             self.connection = "connecting"
+            self.subscriptionAt = self.clock()
+            self.startRecoveryWatch()
             self.remember(id: uuid, name: name)
             if wait {
                 self.connectWaiters.append(completion)
@@ -454,6 +473,11 @@ final class CraftHeartRate: NSObject, CBCentralManagerDelegate, CBPeripheralDele
     /// Lets go of the current strap without telling anyone.
     private func release() {
         wantsConnection = false
+        hasSubscribed = false
+        recoveryTimer?.invalidate()
+        recoveryTimer = nil
+        packetAt = nil
+        subscriptionAt = nil
         simulatedTimer?.invalidate()
         simulatedTimer = nil
         if let peripheral, let central, peripheral.state != .disconnected { central.cancelPeripheralConnection(peripheral) }
@@ -474,7 +498,9 @@ final class CraftHeartRate: NSObject, CBCentralManagerDelegate, CBPeripheralDele
     }
 
     func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) {
-        guard peripheral.identifier == deviceId else { return }
+        guard peripheral.identifier == deviceId, wantsConnection else { return }
+        packetAt = nil
+        subscriptionAt = clock()
         peripheral.delegate = self
         peripheral.discoverServices([Self.serviceUUID])
     }
@@ -491,6 +517,8 @@ final class CraftHeartRate: NSObject, CBCentralManagerDelegate, CBPeripheralDele
         guard peripheral.identifier == deviceId else { return }
         latest = nil
         latestAt = nil
+        packetAt = nil
+        subscriptionAt = clock()
         if wantsConnection {
             connection = "reconnecting"
             central.connect(peripheral)
@@ -501,7 +529,10 @@ final class CraftHeartRate: NSObject, CBCentralManagerDelegate, CBPeripheralDele
     }
 
     func peripheral(_ peripheral: CBPeripheral, didDiscoverServices error: Error?) {
+        guard peripheral.identifier == deviceId, wantsConnection else { return }
+        if error != nil { return restartBroadcast() }
         guard let service = peripheral.services?.first(where: { $0.uuid == Self.serviceUUID }) else {
+            if hasSubscribed { return restartBroadcast() }
             notAHeartRateMonitor(peripheral)
             return
         }
@@ -509,7 +540,10 @@ final class CraftHeartRate: NSObject, CBCentralManagerDelegate, CBPeripheralDele
     }
 
     func peripheral(_ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error: Error?) {
+        guard peripheral.identifier == deviceId, wantsConnection, service.uuid == Self.serviceUUID else { return }
+        if error != nil { return restartBroadcast() }
         guard let measurement = service.characteristics?.first(where: { $0.uuid == Self.measurementUUID }) else {
+            if hasSubscribed { return restartBroadcast() }
             notAHeartRateMonitor(peripheral)
             return
         }
@@ -517,36 +551,104 @@ final class CraftHeartRate: NSObject, CBCentralManagerDelegate, CBPeripheralDele
     }
 
     func peripheral(_ peripheral: CBPeripheral, didUpdateNotificationStateFor characteristic: CBCharacteristic, error: Error?) {
-        guard characteristic.uuid == Self.measurementUUID, peripheral.identifier == deviceId else { return }
-        if characteristic.isNotifying {
+        guard characteristic.uuid == Self.measurementUUID, peripheral.identifier == deviceId, wantsConnection else { return }
+        if characteristic.isNotifying && error == nil {
+            hasSubscribed = true
+            subscriptionAt = clock()
             connection = "connected"
             emitState()
             settleConnect(.success(state()))
-        } else if let error {
-            settleConnect(.failure(CraftHeartRateError(message: error.localizedDescription, code: "CONNECT_FAILED")))
+        } else {
+            restartBroadcast()
         }
     }
 
+    // Garmin may invalidate its service when HR broadcast is toggled without
+    // dropping the physical link. Discover and subscribe to the replacement.
+    func peripheral(_ peripheral: CBPeripheral, didModifyServices invalidatedServices: [CBService]) {
+        guard peripheral.identifier == deviceId, wantsConnection,
+              invalidatedServices.contains(where: { $0.uuid == Self.serviceUUID }) else { return }
+        connection = "reconnecting"
+        latest = nil
+        latestAt = nil
+        packetAt = nil
+        subscriptionAt = clock()
+        peripheral.discoverServices([Self.serviceUUID])
+        emitState()
+    }
+
     func peripheral(_ peripheral: CBPeripheral, didUpdateValueFor characteristic: CBCharacteristic, error: Error?) {
-        guard characteristic.uuid == Self.measurementUUID, peripheral.identifier == deviceId, let value = characteristic.value else { return }
+        guard characteristic.uuid == Self.measurementUUID, peripheral.identifier == deviceId, wantsConnection else { return }
+        if error != nil { return restartBroadcast() }
+        guard let value = characteristic.value else { return }
         received([UInt8](value))
     }
 
     private func notAHeartRateMonitor(_ peripheral: CBPeripheral) {
         wantsConnection = false
+        hasSubscribed = false
+        recoveryTimer?.invalidate()
+        recoveryTimer = nil
         central?.cancelPeripheralConnection(peripheral)
         connection = "disconnected"
         settleConnect(.failure(CraftHeartRateError(message: "That device does not send a heart rate", code: "NOT_HEART_RATE_MONITOR")))
         emitState()
     }
 
+    /// Run independently of any player or big-timer screen. A pending radio
+    /// connection stays pending until the watch returns; only a connected link
+    /// with a silent subscription is restarted.
+    private func startRecoveryWatch() {
+        recoveryTimer?.invalidate()
+        recoveryTimer = Timer.scheduledTimer(withTimeInterval: 5, repeats: true) { [weak self] _ in
+            self?.recoverQuietBroadcast()
+        }
+    }
+
+    private func recoverQuietBroadcast() {
+        guard wantsConnection, let since = packetAt ?? subscriptionAt else { return }
+        let quiet = clock().timeIntervalSince(since)
+        if connection == "connected" && quiet > 20 {
+            restartBroadcast()
+        } else if connection != "connected", peripheral?.state == .connected, quiet > 30 {
+            restartBroadcast()
+        }
+    }
+
+    /// Keep the recording and device choice while replacing the subscription.
+    /// CoreBluetooth's disconnect callback starts the next connection once the
+    /// previous one has actually closed.
+    private func restartBroadcast() {
+        guard wantsConnection else { return }
+        connection = "reconnecting"
+        latest = nil
+        latestAt = nil
+        packetAt = nil
+        subscriptionAt = clock()
+        emitState()
+        if simulated {
+            simulatedTimer?.invalidate()
+            simulatedTimer = nil
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.3) { [weak self] in self?.simulatedConnected() }
+        } else if let peripheral, let central, central.state == .poweredOn {
+            if peripheral.state == .disconnected { central.connect(peripheral) }
+            else if peripheral.state != .disconnecting { central.cancelPeripheralConnection(peripheral) }
+        }
+    }
+
     // MARK: Readings
 
     private func received(_ bytes: [UInt8]) {
         // A strap reads 0 between losing the skin and giving up; that is no
         // heart rate, and neither is anything a heart could not do.
-        guard let reading = CraftHeartRateMeasurement.parse(bytes), reading.bpm >= 20, reading.bpm <= 250 else { return }
-        let now = Date()
+        packetAt = clock()
+        guard let reading = CraftHeartRateMeasurement.parse(bytes), reading.sensorContact != false, reading.bpm >= 20, reading.bpm <= 250 else {
+            latest = nil
+            latestAt = nil
+            emitState()
+            return
+        }
+        let now = clock()
         latest = reading
         latestAt = now
         let timestamp = (now.timeIntervalSince1970 * 1000).rounded()
@@ -567,6 +669,7 @@ final class CraftHeartRate: NSObject, CBCentralManagerDelegate, CBPeripheralDele
     private func simulatedConnected() {
         guard simulated, wantsConnection, deviceId == Self.simulatedId else { return }
         connection = "connected"
+        subscriptionAt = clock()
         emitState()
         settleConnect(.success(state()))
         simulatedTimer?.invalidate()
@@ -671,7 +774,7 @@ final class CraftHeartRate: NSObject, CBCentralManagerDelegate, CBPeripheralDele
             return completion(.failure(CraftHeartRateError(message: "Unable to create the heart-rate recording", code: "RECORDING_STORAGE_ERROR")))
         }
         recordingId = UUID().uuidString
-        recordingStartedAt = (Date().timeIntervalSince1970 * 1000).rounded()
+        recordingStartedAt = (clock().timeIntervalSince1970 * 1000).rounded()
         recordingPaused = false
         recordedCount = 0
         persistRecording()

package/dist/ios/templates/CraftNativeActions.swift

@@ -258,7 +258,10 @@ enum CraftNativeActions {
             sync = .success(currentAppState())
         case ("DeepLinks", "getInitialURL"):
             if config.enableDeepLinks {
-                sync = .success(claimInitialDeepLink().map(deepLinkData) ?? NSNull())
+                DeepLinkManager.shared.resolveInitialURL { url in
+                    complete(requestToken, .success(claimInitialDeepLink(url).map(deepLinkData) ?? NSNull()), completion)
+                }
+                return
             } else {
                 sync = failure("CAPABILITY_DISABLED", "Deep links are disabled")
             }
@@ -809,12 +812,12 @@ enum CraftNativeActions {
         else { task.resume() }
     }
 
-    private static func claimInitialDeepLink() -> URL? {
+    private static func claimInitialDeepLink(_ url: URL?) -> URL? {
         cancellationLock.lock()
         defer { cancellationLock.unlock() }
         guard !initialDeepLinkClaimed else { return nil }
         initialDeepLinkClaimed = true
-        return DeepLinkManager.shared.getInitialURL()
+        return url
     }
 
     private static func complete(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "craft-native",
-  "version": "0.0.220",
+  "version": "0.0.222",
   "type": "module",
   "description": "Build desktop apps with web languages - TypeScript SDK for Craft",
   "author": "Chris Breuer <chris@stacksjs.org>",