craft-native 0.0.254 → 0.0.272

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

@@ -56,6 +56,7 @@ import java.time.LocalDateTime
 import java.time.Period
 import java.time.ZoneId
 import java.util.TreeMap
+import java.util.UUID
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.atomic.AtomicBoolean
 import java.util.concurrent.atomic.AtomicReference
@@ -89,10 +90,22 @@ internal class CraftNativeHealth(
     /** Ask for READ_HEALTH_DATA_IN_BACKGROUND / READ_HEALTH_DATA_HISTORY with the read types when the feature is available (the manifest declares them only when these are true). */
     private val backgroundReads: Boolean,
     private val historyReads: Boolean,
+    /** Lifecycle events are broadcast to native screens and the web host. */
+    private val workoutSink: ((JSONObject) -> Unit)? = null,
 ) {
     /** A read or write that did not happen: the bridge's error code and the message a page sees. */
     private class HealthFailure(val code: String, message: String) : Exception(message)
 
+    private data class LiveWorkout(
+        val id: String,
+        val type: String,
+        val start: Instant,
+        val location: String?,
+        var pausedAt: Instant? = null,
+        var pausedMillis: Long = 0,
+        var state: String = "running",
+    )
+
     private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
     private val mainHandler = Handler(Looper.getMainLooper())
     private val closed = AtomicBoolean(false)
@@ -108,6 +121,8 @@ internal class CraftNativeHealth(
     private var cachedClient: HealthConnectClient? = null
 
     private val ownOrigin = DataOrigin(context.packageName)
+    private val workoutLock = Any()
+    private val liveWorkout = AtomicReference<LiveWorkout?>(null)
 
     /** A native screen's call (`Health` in CraftNativeActions), by method and arguments as the bridge sends them. */
     fun perform(method: String, args: JSONArray, completion: (CraftNativeCapabilityResult) -> Unit) {
@@ -150,6 +165,10 @@ internal class CraftNativeHealth(
             "getSleepIntervals" -> answer(completion) { getSleepIntervals(options(0)) }
             "saveMindfulSession" -> answer(completion) { saveMindfulSession(options(0)) }
             "getMindfulSessions" -> answer(completion) { getMindfulSessions(options(0)) }
+            "startWorkout" -> answer(completion) { startWorkout(options(0)) }
+            "pauseWorkout" -> answer(completion) { pauseWorkout() }
+            "resumeWorkout" -> answer(completion) { resumeWorkout() }
+            "endWorkout" -> answer(completion) { endWorkout() }
             else -> deliver(completion, CraftNativeCapabilityResult(code = "UNKNOWN_ACTION", message = "Unsupported Health method: $method"))
         }
     }
@@ -165,6 +184,7 @@ internal class CraftNativeHealth(
 
     fun close() {
         closed.set(true)
+        liveWorkout.getAndSet(null)?.let { emitWorkoutState(it, "stopped") }
         pendingPermission.getAndSet(null)?.cancel()
         scope.cancel()
     }
@@ -213,6 +233,101 @@ internal class CraftNativeHealth(
 
     private fun invalid(message: String) = HealthFailure("INVALID_ARGUMENT", message)
 
+    // MARK: - Live workout lifecycle
+
+    /**
+     * Android Health Connect stores the finished ExerciseSessionRecord. The
+     * lifecycle is kept in the foreground host until the Health Services
+     * foreground-session adapter is available; no post-hoc save is implied by
+     * this API, and every transition is still observable by the page.
+     */
+    private suspend fun startWorkout(body: JSONObject): Any {
+        val type = body.optString("type").takeIf { it.isNotBlank() }
+            ?: throw invalid("startWorkout needs a workout type")
+        if (EXERCISE_TYPES[type] == null) throw invalid("Unsupported workout type: $type")
+        if (activityProvider() == null) throw HealthFailure("NEEDS_ACTIVITY", "Live workouts require a foreground activity")
+        val now = Instant.now()
+        val workout = synchronized(workoutLock) {
+            if (liveWorkout.get() != null) throw HealthFailure("BUSY", "A live workout is already running")
+            LiveWorkout("live-${UUID.randomUUID()}", type, now, body.optString("location").takeIf { it.isNotBlank() }).also(liveWorkout::set)
+        }
+        emitWorkoutState(workout, "running", now)
+        return JSONObject()
+            .put("id", workout.id)
+            .put("type", workout.type)
+            .put("startDate", workout.start.ms())
+    }
+
+    private suspend fun pauseWorkout(): Any {
+        val now = Instant.now()
+        val workout = synchronized(workoutLock) {
+            val current = liveWorkout.get() ?: throw HealthFailure("NO_WORKOUT", "No live workout is running")
+            if (current.state != "running") throw HealthFailure("INVALID_STATE", "The live workout is not running")
+            current.pausedAt = now
+            current.state = "paused"
+            current
+        }
+        emitWorkoutState(workout, "paused", now)
+        return true
+    }
+
+    private suspend fun resumeWorkout(): Any {
+        val now = Instant.now()
+        val workout = synchronized(workoutLock) {
+            val current = liveWorkout.get() ?: throw HealthFailure("NO_WORKOUT", "No live workout is running")
+            val pausedAt = current.pausedAt ?: throw HealthFailure("INVALID_STATE", "The live workout is not paused")
+            current.pausedMillis += Duration.between(pausedAt, now).toMillis().coerceAtLeast(0)
+            current.pausedAt = null
+            current.state = "running"
+            current
+        }
+        emitWorkoutState(workout, "running", now)
+        return true
+    }
+
+    private suspend fun endWorkout(): Any {
+        val now = Instant.now()
+        val workout = synchronized(workoutLock) {
+            val current = liveWorkout.getAndSet(null) ?: throw HealthFailure("NO_WORKOUT", "No live workout is running")
+            current.pausedAt?.let { current.pausedMillis += Duration.between(it, now).toMillis().coerceAtLeast(0) }
+            current.pausedAt = null
+            current.state = "ended"
+            current
+        }
+        val body = JSONObject()
+            .put("activityId", workout.id)
+            .put("type", workout.type)
+            .put("startDate", workout.start.ms())
+            .put("endDate", now.ms())
+        val saved = try {
+            saveWorkout(body) as JSONObject
+        } catch (error: CancellationException) {
+            throw error
+        } catch (error: Throwable) {
+            emitWorkoutError(workout, error.message ?: "Live workout could not be saved")
+            throw error
+        }
+        val duration = (Duration.between(workout.start, now).toMillis() - workout.pausedMillis).coerceAtLeast(0) / 1000.0
+        emitWorkoutState(workout, "ended", now)
+        return JSONObject()
+            .put("id", workout.id)
+            .put("workoutId", saved.optString("id", workout.id))
+            .put("endDate", now.ms())
+            .put("durationSeconds", duration)
+    }
+
+    private fun emitWorkoutState(workout: LiveWorkout, state: String, date: Instant = Instant.now()) {
+        mainHandler.post {
+            workoutSink?.invoke(JSONObject().put("id", workout.id).put("event", "state").put("state", state).put("date", date.ms()))
+        }
+    }
+
+    private fun emitWorkoutError(workout: LiveWorkout, message: String) {
+        mainHandler.post {
+            workoutSink?.invoke(JSONObject().put("id", workout.id).put("event", "error").put("message", message))
+        }
+    }
+
     // MARK: - Health Connect itself
 
     private fun sdkStatus(): Int = HealthConnectClient.getSdkStatus(context, PROVIDER_PACKAGE)

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

@@ -15,6 +15,7 @@ internal class CraftNativeHealth(
     @Suppress("UNUSED_PARAMETER") activityProvider: () -> Activity?,
     @Suppress("UNUSED_PARAMETER") backgroundReads: Boolean,
     @Suppress("UNUSED_PARAMETER") historyReads: Boolean,
+    @Suppress("UNUSED_PARAMETER") workoutSink: ((org.json.JSONObject) -> Unit)? = null,
 ) {
     fun perform(method: String, args: JSONArray, completion: (CraftNativeCapabilityResult) -> Unit) {
         completion(CraftNativeCapabilityResult(code = "CAPABILITY_DISABLED", message = "Health Connect is not enabled for this app ($method, ${args.length()} arguments)"))

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

@@ -309,6 +309,8 @@ class CraftNativeMutationDocument {
             "View", "SafeAreaView", "ScrollView", "KeyboardAvoidingView", "Modal", "Pressable",
             "TouchableOpacity", "TouchableHighlight", "ImageBackground", "FlatList", "SectionList",
             "Fragment", "Svg", "G", "Map",
+            // A shape holds its `Animate`: SMIL keyframes.
+            "Path", "Line", "Rect", "Circle", "Ellipse", "Polyline", "Polygon",
         )
     }
 

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

@@ -30,6 +30,7 @@ import java.io.File
 import java.util.Locale
 import java.util.UUID
 {{NATIVE_PUSH_IMPORTS}}
+{{NATIVE_WALLET_IMPORTS}}
 
 private fun craftLocationFix(location: android.location.Location): JSONObject = JSONObject()
     .put("latitude", location.latitude)
@@ -61,7 +62,16 @@ internal class CraftNativeServices(
     private val main = Handler(Looper.getMainLooper())
     private val heartRateEnabled = config.optBoolean("enableHeartRate")
     private val health: CraftNativeHealth? = if (config.optBoolean("enableHealthConnect")) {
-        CraftNativeHealth(context, activity, config.optBoolean("enableHealthConnectBackground"), config.optBoolean("enableHealthConnectHistory"))
+        CraftNativeHealth(context, activity, config.optBoolean("enableHealthConnectBackground"), config.optBoolean("enableHealthConnectHistory")) { detail ->
+            CraftNativeHub.broadcast("CRAFT_EVENT", JSONObject().put("event", "craftHealthWorkout").put("detail", detail))
+        }
+    } else null
+    private val healthServices: CraftHealthServices? = if (config.optBoolean("enableHealthServices")) {
+        CraftHealthServices(context, activity, health?.let { healthApi ->
+            { method: String, args: JSONArray, completion: (CraftNativeCapabilityResult) -> Unit ->
+                healthApi.perform(method, args, completion)
+            }
+        })
     } else null
     private var pendingPushPermission: ((CraftNativeCapabilityResult) -> Unit)? = null
     private var pendingBrowser: Pair<String?, (CraftNativeCapabilityResult) -> Unit>? = null
@@ -70,6 +80,7 @@ internal class CraftNativeServices(
     private var speechReady = false
     private val speechQueue = mutableListOf<() -> Unit>()
     private val speeches = mutableMapOf<String, (CraftNativeCapabilityResult) -> Unit>()
+{{NATIVE_WALLET_FIELDS}}
 
     init {
         if (config.optBoolean("enableGeolocation") || config.optBoolean("enableBackgroundLocation")) {
@@ -106,13 +117,14 @@ internal class CraftNativeServices(
         add("media")
         if (config.optBoolean("enableShare")) add("share")
         if (config.optBoolean("enablePushNotifications")) add("push")
-        if (health != null) {
+        if (health != null || healthServices != null) {
             add("health")
             // Health Connect may need installing or updating, and its grants
             // are managed in its own screen: `health.availability()`,
             // `health.grantedTypes()` and `health.openSettings()`.
             add("healthAvailability")
         }
+        if (healthServices != null) add("healthServices")
         if (config.optBoolean("enableWallet")) add("wallet")
         if (config.optBoolean("enableKeepAwake")) add("keepAwake")
         if (config.optBoolean("enableGeolocation") || config.optBoolean("enableBackgroundLocation")) {
@@ -145,7 +157,9 @@ internal class CraftNativeServices(
                 "Linking" -> linking(method, args.optString(0), done)
                 "Share" -> share(args.optJSONObject(0) ?: JSONObject(), done)
                 "Push" -> push(method, done)
-                "Health" -> health?.perform(method, args, done) ?: done(failure("CAPABILITY_DISABLED", "Health Connect is not enabled for this app"))
+                "Health" -> if (healthServices != null && method in setOf("startWorkout", "pauseWorkout", "resumeWorkout", "endWorkout")) {
+                    healthServices.perform(method, args, done)
+                } else health?.perform(method, args, done) ?: done(failure("CAPABILITY_DISABLED", "Health is not enabled for this app"))
                 "Wallet" -> wallet(method, args, done)
                 "KeepAwake" -> keepAwake(args.optBoolean(0, true), done)
                 "Brightness" -> brightness(method, args, done)
@@ -182,11 +196,17 @@ internal class CraftNativeServices(
     private fun wallet(method: String, args: JSONArray, done: (CraftNativeCapabilityResult) -> Unit) {
         if (!config.optBoolean("enableWallet")) return done(failure("CAPABILITY_DISABLED", "Wallet is disabled"))
         when (method) {
-            "isAvailable" -> done(success(runCatching {
-                context.packageManager.getLaunchIntentForPackage("com.google.android.apps.walletnfcrel") != null
-            }.getOrDefault(false)))
+            "isAvailable" -> {
+{{NATIVE_WALLET_AVAILABILITY}}
+            }
             "add" -> {
                 val source = args.optJSONObject(0) ?: return done(failure("INVALID_ARGUMENT", "Wallet.add needs a source object"))
+                val jwt = source.optString("jwt").trim()
+                if (jwt.isNotEmpty()) {
+                    val host = activity() ?: return done(failure("NEEDS_ACTIVITY", "No screen is showing to open Wallet"))
+{{NATIVE_WALLET_JWT_ADD}}
+                    return
+                }
                 val address = source.optString("url").trim()
                 if (!address.startsWith("https://")) return done(failure("INVALID_ARGUMENT", "Android Wallet.add needs an HTTPS save URL"))
                 val host = activity() ?: return done(failure("NEEDS_ACTIVITY", "No screen is showing to open Wallet"))
@@ -200,6 +220,7 @@ internal class CraftNativeServices(
             else -> done(failure("UNKNOWN_ACTION", "Unsupported Wallet method"))
         }
     }
+{{NATIVE_WALLET_HELPER}}
 
     // MARK: Dialogs
 
@@ -542,8 +563,10 @@ internal class CraftNativeServices(
 
     // MARK: Health Connect
 
-    fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?): Boolean =
-        health?.onActivityResult(requestCode, resultCode, data) == true
+    fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?): Boolean {
+{{NATIVE_WALLET_RESULT}}
+        return health?.onActivityResult(requestCode, resultCode, data) == true
+    }
 
     // MARK: The screen
 

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

@@ -907,6 +907,11 @@ internal class CraftNativeChrome(context: Context, private val tabs: List<CraftN
                 if (kotlin.math.abs(dx) > swipeSlop && kotlin.math.abs(dx) > kotlin.math.abs(dy)) {
                     swipeTracking = false
                     swipeIntercepted = onTabSwipeStart?.invoke(dx, event.x, event.y) == true
+                    // Android cancels the child's touch target for this move;
+                    // it does not replay the move through our onTouchEvent.
+                    // Apply it now so a paused or coalesced drag still previews
+                    // the incoming tab before another input event arrives.
+                    if (swipeIntercepted) onTabSwipeMove?.invoke(dx)
                     return swipeIntercepted
                 }
             }