craft-native 0.0.436 → 0.0.443

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

@@ -0,0 +1,269 @@
+package {{PACKAGE_NAME}}
+
+import android.content.Context
+import android.hardware.Sensor
+import android.hardware.SensorEvent
+import android.hardware.SensorEventListener
+import android.hardware.SensorManager
+import android.os.Handler
+import android.os.Looper
+import org.json.JSONArray
+import org.json.JSONObject
+
+/** Registration owns its listener. Closing an old registration cannot stop a replacement. */
+internal interface CraftMotionRegistration { fun close() }
+internal interface CraftMotionSource {
+    fun available(type: Int): Boolean
+    fun register(type: Int, periodUs: Int, sample: (FloatArray, Long, Int) -> Unit): CraftMotionRegistration?
+}
+
+internal class CraftAndroidMotionSource(context: Context) : CraftMotionSource {
+    private val manager = context.getSystemService(Context.SENSOR_SERVICE) as? SensorManager
+    override fun available(type: Int): Boolean = manager?.getDefaultSensor(type) != null
+    override fun register(type: Int, periodUs: Int, sample: (FloatArray, Long, Int) -> Unit): CraftMotionRegistration? {
+        val manager = manager ?: return null
+        val sensor = manager.getDefaultSensor(type) ?: return null
+        val listener = object : SensorEventListener {
+            override fun onSensorChanged(event: SensorEvent) {
+                sample(event.values.clone(), event.timestamp, event.accuracy)
+            }
+            override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) {}
+        }
+        try {
+            if (!manager.registerListener(listener, sensor, periodUs, Handler(Looper.getMainLooper()))) {
+                manager.unregisterListener(listener)
+                return null
+            }
+        } catch (error: Exception) {
+            manager.unregisterListener(listener)
+            throw error
+        }
+        return object : CraftMotionRegistration {
+            override fun close() { manager.unregisterListener(listener) }
+        }
+    }
+}
+
+/** Foreground, route-owned raw readings; deliberately distinct from iOS CMDeviceMotion. */
+internal class CraftNativeMotion(private val source: CraftMotionSource) {
+    private data class Kind(val type: Int, val unit: String)
+    private val kinds = linkedMapOf(
+        "accelerometer" to Kind(Sensor.TYPE_ACCELEROMETER, "m/s²"),
+        "gyroscope" to Kind(Sensor.TYPE_GYROSCOPE, "rad/s"),
+        "magnetometer" to Kind(Sensor.TYPE_MAGNETIC_FIELD, "µT"),
+        "rotationVector" to Kind(Sensor.TYPE_ROTATION_VECTOR, "quaternion"),
+    )
+    private class Stream { var registration: CraftMotionRegistration? = null }
+    private val streams = mutableMapOf<String, Stream>()
+    private var closed = false
+    var emit: (JSONObject) -> Unit = {}
+
+    fun perform(method: String, args: JSONArray): CraftNativeCapabilityResult {
+        if (closed) return failure("HOST_CLOSED", "Motion host is closed")
+        return when (method) {
+            "getAvailability" -> CraftNativeCapabilityResult(data = JSONObject().apply {
+                kinds.forEach { (name, kind) -> put(name, source.available(kind.type)) }
+            })
+            "start" -> start(args.optJSONObject(0))
+            "stop" -> {
+                val name = args.opt(0) as? String
+                if (name !in kinds) failure("INVALID_ARGUMENT", "Unknown motion sensor")
+                else CraftNativeCapabilityResult(data = stop(name!!))
+            }
+            "stopAll" -> { stopAll(); CraftNativeCapabilityResult(data = true) }
+            else -> failure("UNKNOWN_ACTION", "Unsupported MotionSensors method")
+        }
+    }
+
+    private fun start(options: JSONObject?): CraftNativeCapabilityResult {
+        val name = options?.opt("sensor") as? String
+        val kind = kinds[name] ?: return failure("INVALID_ARGUMENT", "Unknown motion sensor")
+        val rawInterval = if (options?.has("intervalMs") == true) options.opt("intervalMs") else 100
+        val interval = (rawInterval as? Number)?.toDouble() ?: Double.NaN
+        // Do not silently opt an app into Android's high sampling-rate permission.
+        if (!interval.isFinite() || interval < 5 || interval > 60_000 || interval % 1 != 0.0) {
+            return failure("INVALID_ARGUMENT", "intervalMs must be an integer from 5 through 60000")
+        }
+        if (!source.available(kind.type)) return failure("UNAVAILABLE", "Sensor is not present: $name")
+        val stream = Stream()
+        val registration = try {
+            source.register(kind.type, (interval * 1000).toInt()) { values, timestamp, accuracy ->
+                // Android can still deliver a queued sample after unregisterListener.
+                if (!closed && streams[name] === stream && values.size >= 3) {
+                    val reading = if (kind.type == Sensor.TYPE_ROTATION_VECTOR) {
+                        val quaternion = FloatArray(4)
+                        SensorManager.getQuaternionFromVector(quaternion, values)
+                        JSONObject().put("w", quaternion[0]).put("x", quaternion[1])
+                            .put("y", quaternion[2]).put("z", quaternion[3])
+                    } else JSONObject().put("x", values[0]).put("y", values[1]).put("z", values[2])
+                    emit(JSONObject().put("sensor", name).put("values", reading).put("unit", kind.unit)
+                        .put("timestampMs", timestamp / 1_000_000.0).put("accuracy", accuracy))
+                }
+            }
+        } catch (error: Exception) {
+            return failure("SENSOR_ERROR", error.message ?: "Sensor registration failed")
+        } ?: return failure("UNAVAILABLE", "Sensor registration was rejected: $name")
+        stream.registration = registration
+        // Validate and acquire the replacement before retiring a working stream.
+        val previous = streams.put(name!!, stream)
+        previous?.registration?.close()
+        return CraftNativeCapabilityResult(data = true)
+    }
+
+    private fun failure(code: String, message: String) = CraftNativeCapabilityResult(code = code, message = message)
+    private fun stop(name: String): Boolean {
+        val stream = streams.remove(name) ?: return false
+        stream.registration?.close()
+        return true
+    }
+    fun stopAll() { streams.keys.toList().forEach(::stop) }
+    fun close() { closed = true; stopAll(); emit = {} }
+}
+
+/** A pressure-only stream with a new reference on each successful start. */
+internal class CraftNativeBarometer(private val source: CraftMotionSource) {
+    private class Stream {
+        var registration: CraftMotionRegistration? = null
+        var reference: Float? = null
+    }
+    private var stream: Stream? = null
+    private var closed = false
+    var emit: (JSONObject) -> Unit = {}
+
+    fun perform(method: String, args: JSONArray): CraftNativeCapabilityResult {
+        if (closed) return failure("HOST_CLOSED", "Barometer host is closed")
+        return when (method) {
+            "getAvailability" -> CraftNativeCapabilityResult(data = JSONObject()
+                .put("relativeAltitude", source.available(Sensor.TYPE_PRESSURE))
+                .put("absoluteAltitude", false).put("background", false))
+            "start" -> start(args.optJSONObject(0), args.length() != 0)
+            "stop" -> CraftNativeCapabilityResult(data = stop("requested"))
+            else -> failure("UNKNOWN_ACTION", "Unsupported Barometer method")
+        }
+    }
+
+    private fun start(options: JSONObject?, supplied: Boolean): CraftNativeCapabilityResult {
+        if (supplied && options == null) return failure("INVALID_ARGUMENT", "Barometer.start needs an options object")
+        if (options?.has("background") == true && options.opt("background") !is Boolean)
+            return failure("INVALID_ARGUMENT", "background must be boolean")
+        if (options?.optBoolean("background", false) == true)
+            return failure("UNSUPPORTED", "Background barometer recording is not supported")
+        val raw = if (options?.has("intervalMs") == true) options.opt("intervalMs") else 100
+        val interval = (raw as? Number)?.toDouble() ?: Double.NaN
+        if (!interval.isFinite() || interval < 5 || interval > 60_000 || interval % 1 != 0.0)
+            return failure("INVALID_ARGUMENT", "intervalMs must be an integer from 5 through 60000")
+        if (!source.available(Sensor.TYPE_PRESSURE)) return failure("UNAVAILABLE", "Barometer is not present")
+        val next = Stream()
+        val registration = try {
+            source.register(Sensor.TYPE_PRESSURE, (interval * 1000).toInt()) { values, timestamp, _ ->
+                if (!closed && stream === next) {
+                    val pressure = values.firstOrNull()
+                    if (pressure == null || !pressure.isFinite() || pressure <= 0) {
+                        stop("sensorError")
+                    } else {
+                        val reference = next.reference ?: pressure.also { next.reference = it }
+                        val altitude = SensorManager.getAltitude(reference, pressure)
+                        if (!altitude.isFinite()) stop("sensorError")
+                        else emit(JSONObject().put("state", "sample").put("pressureHpa", pressure)
+                            .put("relativeAltitudeMeters", altitude).put("referencePressureHpa", reference)
+                            .put("timestampMs", timestamp / 1_000_000.0))
+                    }
+                }
+            }
+        } catch (error: Exception) {
+            return failure("SENSOR_ERROR", error.message ?: "Barometer registration failed")
+        } ?: return failure("UNAVAILABLE", "Barometer registration was rejected")
+        next.registration = registration
+        val previous = stream
+        stream = next
+        previous?.registration?.close()
+        return CraftNativeCapabilityResult(data = true)
+    }
+
+    fun stop(reason: String): Boolean {
+        val previous = stream ?: return false
+        stream = null
+        previous.registration?.close()
+        emit(JSONObject().put("state", "stopped").put("reason", reason))
+        return true
+    }
+    fun close() { closed = true; stop("disposed"); emit = {} }
+    private fun failure(code: String, message: String) = CraftNativeCapabilityResult(code = code, message = message)
+}
+
+/** Android counter and detector semantics stay distinct from interval totals. */
+internal class CraftNativePedometer(private val source: CraftMotionSource, private val hasPermission: () -> Boolean) {
+    private class Stream { var registration: CraftMotionRegistration? = null }
+    private var stream: Stream? = null
+    private var closed = false
+    var emit: (JSONObject) -> Unit = {}
+
+    fun perform(method: String, args: JSONArray): CraftNativeCapabilityResult {
+        if (closed) return failure("HOST_CLOSED", "Pedometer host is closed")
+        return when (method) {
+            "getAvailability" -> CraftNativeCapabilityResult(data = JSONObject()
+                .put("counter", source.available(Sensor.TYPE_STEP_COUNTER))
+                .put("detector", source.available(Sensor.TYPE_STEP_DETECTOR))
+                .put("history", false).put("background", false).put("cadence", false).put("floors", false))
+            "getPermissionStatus" -> CraftNativeCapabilityResult(data = if (hasPermission()) "granted" else "denied")
+            "start" -> start(args.optJSONObject(0), args.length() != 0)
+            "stop" -> CraftNativeCapabilityResult(data = stop("requested"))
+            "query" -> failure("UNSUPPORTED", "Android's step sensor does not provide interval history")
+            else -> failure("UNKNOWN_ACTION", "Unsupported Pedometer method")
+        }
+    }
+
+    private fun start(options: JSONObject?, supplied: Boolean): CraftNativeCapabilityResult {
+        if (supplied && options == null) return failure("INVALID_ARGUMENT", "Pedometer.start needs an options object")
+        if (options?.has("background") == true && options.opt("background") !is Boolean)
+            return failure("INVALID_ARGUMENT", "background must be boolean")
+        if (options?.optBoolean("background", false) == true)
+            return failure("UNSUPPORTED", "Background step streaming is not supported by this sensor adapter")
+        val name = if (options?.has("sensor") == true) options.opt("sensor") as? String else "counter"
+        val type = when (name) {
+            "counter" -> Sensor.TYPE_STEP_COUNTER
+            "detector" -> Sensor.TYPE_STEP_DETECTOR
+            else -> return failure("INVALID_ARGUMENT", "sensor must be counter or detector")
+        }
+        if (options?.has("startDate") == true || options?.has("endDate") == true)
+            return failure("UNSUPPORTED", "Android steps are not counts for a requested interval")
+        if (!source.available(type)) return failure("UNAVAILABLE", "Requested step sensor is not present")
+        if (!hasPermission()) return failure("PERMISSION_DENIED", "Activity recognition permission is required")
+        val next = Stream()
+        val registration = try {
+            source.register(type, 200_000) { values, timestamp, _ ->
+                if (!closed && stream === next) {
+                    val value = values.firstOrNull()
+                    if (!hasPermission()) stop("permissionDenied")
+                    else if (value == null || !value.isFinite() || value < 0 || value % 1f != 0f || (name == "detector" && value != 1f)) stop("sensorError")
+                    else {
+                        val payload = JSONObject().put("state", "sample").put("kind", if (name == "counter") "counter" else "step")
+                            .put("timestampMs", timestamp / 1_000_000.0)
+                        if (name == "counter") payload.put("stepsSinceBoot", value.toDouble())
+                        else payload.put("count", 1)
+                        emit(payload)
+                    }
+                }
+            }
+        } catch (error: SecurityException) {
+            return failure("PERMISSION_DENIED", "Activity recognition permission is required")
+        } catch (error: Exception) {
+            return failure("SENSOR_ERROR", error.message ?: "Step sensor registration failed")
+        } ?: return failure("UNAVAILABLE", "Step sensor registration was rejected")
+        next.registration = registration
+        val previous = stream
+        stream = next
+        previous?.registration?.close()
+        return CraftNativeCapabilityResult(data = true)
+    }
+
+    fun stop(reason: String): Boolean {
+        val previous = stream ?: return false
+        stream = null
+        previous.registration?.close()
+        emit(JSONObject().put("state", "stopped").put("reason", reason))
+        return true
+    }
+    fun close() { closed = true; stop("disposed"); emit = {} }
+    private fun failure(code: String, message: String) = CraftNativeCapabilityResult(code = code, message = message)
+}

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

@@ -129,10 +129,12 @@ internal class CraftNativeServices(
             add("healthAvailability")
         }
         if (healthServices != null) add("healthServices")
+        if (healthServices != null && config.optBoolean("enablePedometer")) add("pedometerPassive")
         if (config.optBoolean("enableWallet")) add("wallet")
         if (config.optBoolean("enableKeepAwake")) add("keepAwake")
         if (config.optBoolean("enableGeolocation") || config.optBoolean("enableBackgroundLocation")) {
             add("geolocation")
+            if (config.optBoolean("enableBarometer") && config.optBoolean("enableBackgroundLocation")) add("locationRecordingBarometer")
             if (CraftNative.supportsRecordingOwnership()) add("locationRecordingOwnership")
             if (CraftNative.supportsRecordingIntentIdentity()) add("locationRecordingIntentIdentity")
             if (CraftNative.supportsRecordingPowerMode()) add("locationRecordingPowerMode")
@@ -146,7 +148,7 @@ internal class CraftNativeServices(
     }
 
     fun handles(module: String): Boolean = module in setOf(
-        "Dialog", "Browser", "Linking", "Share", "Push", "Health", "KeepAwake", "Brightness", "StatusBar", "Speech", "Background",
+        "Dialog", "Browser", "Linking", "Share", "Push", "Health", "PedometerPassive", "KeepAwake", "Brightness", "StatusBar", "Speech", "Background",
         "Location", "Media", "CrashReporter", "HeartRate", "AudioRecording",
         "Wallet",
     )
@@ -165,6 +167,9 @@ internal class CraftNativeServices(
                 "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"))
+                "PedometerPassive" -> if (config.optBoolean("enablePedometer") && healthServices != null) {
+                    healthServices.perform("passive:$method", args, done)
+                } else done(failure("CAPABILITY_DISABLED", "Passive steps require pedometer and Health Services"))
                 "Wallet" -> wallet(method, args, done)
                 "KeepAwake" -> keepAwake(args.optBoolean(0, true), done)
                 "Brightness" -> brightness(method, args, done)

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

@@ -0,0 +1,159 @@
+package {{PACKAGE_NAME}}
+
+import android.Manifest
+import android.content.Context
+import android.content.BroadcastReceiver
+import android.content.Intent
+import androidx.work.Worker
+import androidx.work.WorkerParameters
+import androidx.work.WorkManager
+import androidx.work.OneTimeWorkRequestBuilder
+import androidx.work.ExistingWorkPolicy
+import android.content.pm.PackageManager
+import android.os.SystemClock
+import androidx.core.content.ContextCompat
+import androidx.health.services.client.HealthServices
+import androidx.health.services.client.PassiveListenerService
+import androidx.health.services.client.data.DataPointContainer
+import androidx.health.services.client.data.DataType
+import androidx.health.services.client.data.PassiveListenerConfig
+import org.json.JSONArray
+import org.json.JSONObject
+import java.time.Instant
+import java.time.ZoneId
+import java.util.concurrent.TimeUnit
+
+/** Daily Health Services totals are not the raw counter since boot. */
+internal class CraftPassiveStepStore(context: Context) {
+    private val prefs = context.getSharedPreferences("craft-passive-steps", Context.MODE_PRIVATE)
+    companion object { private val lock = Any() }
+    fun enabled(): Boolean = synchronized(lock) { prefs.getBoolean("enabled", false) }
+    fun setEnabled(value: Boolean): Boolean = synchronized(lock) { prefs.edit().putBoolean("enabled", value).commit() }
+    fun history(): JSONArray = synchronized(lock) { JSONArray(prefs.getString("days", "[]")) }
+    fun save(steps: Long, start: Long, end: Long, zone: String): Boolean = synchronized(lock) {
+        if (!enabled() || steps < 0 || start > end) return@synchronized false
+        // Attribute a completed interval ending at midnight to its start day.
+        val day = Instant.ofEpochMilli(start).atZone(ZoneId.of(zone)).toLocalDate().toString()
+        val rows = history()
+        val values = (0 until rows.length()).map { rows.getJSONObject(it) }.toMutableList()
+        val previous = values.firstOrNull { it.optString("day") == day && it.optString("timeZone") == zone }
+        if (previous != null && previous.optLong("endDate") > end) return@synchronized false
+        values.removeAll { it.optString("day") == day && it.optString("timeZone") == zone }
+        values.add(JSONObject().put("kind", "daily").put("source", "healthServices").put("day", day).put("timeZone", zone)
+            .put("startDate", start).put("endDate", end).put("steps", steps))
+        val retained = JSONArray(values.sortedBy { it.getLong("endDate") }.takeLast(8))
+        prefs.edit().putString("days", retained.toString()).commit()
+    }
+}
+
+/** Health Services binds this service even when no Craft screen is alive. */
+class CraftPassiveStepsService : PassiveListenerService() {
+    override fun onNewDataPointsReceived(dataPoints: DataPointContainer) {
+        val storage = CraftPassiveStepStore(this)
+        val boot = Instant.ofEpochMilli(System.currentTimeMillis() - SystemClock.elapsedRealtime())
+        for (point in dataPoints.getData(DataType.STEPS_DAILY)) {
+            storage.save(point.value, point.getStartInstant(boot).toEpochMilli(), point.getEndInstant(boot).toEpochMilli(), ZoneId.systemDefault().id)
+        }
+    }
+    override fun onPermissionLost() { CraftPassiveStepStore(this).setEnabled(false) }
+}
+
+internal interface CraftPassiveStepProvider {
+    fun supported(): Boolean
+    fun start()
+    fun stop()
+    fun discardRegistration() { stop() }
+}
+
+private class CraftHealthPassiveProvider(context: Context) : CraftPassiveStepProvider {
+    private val client = HealthServices.getClient(context).passiveMonitoringClient
+    override fun supported(): Boolean = DataType.STEPS_DAILY in client.getCapabilitiesAsync().get(10, TimeUnit.SECONDS).supportedDataTypesPassiveMonitoring
+    override fun start() {
+        client.setPassiveListenerServiceAsync(CraftPassiveStepsService::class.java,
+            PassiveListenerConfig.builder().setDataTypes(setOf(DataType.STEPS_DAILY)).build()).get(10, TimeUnit.SECONDS)
+    }
+    override fun stop() { client.clearPassiveListenerServiceAsync().get(10, TimeUnit.SECONDS) }
+    override fun discardRegistration() { client.clearPassiveListenerServiceAsync() }
+}
+
+internal class CraftPassiveSteps(
+    private val context: Context,
+    private val provider: CraftPassiveStepProvider = CraftHealthPassiveProvider(context),
+    private val permission: () -> Boolean = { ContextCompat.checkSelfPermission(context, Manifest.permission.ACTIVITY_RECOGNITION) == PackageManager.PERMISSION_GRANTED },
+) {
+    private val storage = CraftPassiveStepStore(context)
+    private fun failure(code: String, message: String) = CraftNativeCapabilityResult(code = code, message = message)
+
+    fun perform(method: String, done: (CraftNativeCapabilityResult) -> Unit) {
+        // These bounded provider calls run on a worker: no main-thread binder wait.
+        executor.execute {
+            val result = try {
+                when (method) {
+                    "history" -> CraftNativeCapabilityResult(data = storage.history())
+                    "availability" -> CraftNativeCapabilityResult(data = JSONObject()
+                        .put("supported", provider.supported())
+                        .put("enabled", storage.enabled()).put("permissionGranted", permission()))
+                    "start", "restore" -> {
+                        if (method == "restore" && !storage.enabled()) CraftNativeCapabilityResult(data = false)
+                        else if (!permission()) failure("PERMISSION_DENIED", "Activity recognition access is required")
+                        else if (!provider.supported())
+                            failure("UNAVAILABLE", "This device has no passive daily steps provider")
+                        else {
+                            // Persist intent before binding; the service may receive data immediately.
+                            if (!storage.setEnabled(true)) failure("STORAGE_ERROR", "Passive registration intent could not be saved")
+                            else {
+                                try {
+                                    provider.start()
+                                    CraftNativeCapabilityResult(data = true)
+                                } catch (error: Exception) {
+                                    if (method == "start") storage.setEnabled(false)
+                                    runCatching { provider.discardRegistration() }
+                                    throw error
+                                }
+                            }
+                        }
+                    }
+                    "stop" -> {
+                        if (!storage.setEnabled(false)) failure("STORAGE_ERROR", "Passive registration intent could not be cleared")
+                        else {
+                            provider.stop()
+                            CraftNativeCapabilityResult(data = true)
+                        }
+                    }
+                    else -> failure("UNKNOWN_ACTION", "Unknown passive pedometer action")
+                }
+            } catch (error: Exception) {
+                failure("UNAVAILABLE", error.cause?.message ?: error.message ?: "Health Services is unavailable")
+            }
+            ContextCompat.getMainExecutor(context).execute { done(result) }
+        }
+    }
+    companion object {
+        // Serialize app-wide start/stop commands, including commands from different routes.
+        private val executor = java.util.concurrent.Executors.newSingleThreadExecutor()
+    }
+}
+
+/** Registrations do not survive a reboot. Restore only explicit saved opt-in. */
+class CraftPassiveStepsBootReceiver : BroadcastReceiver() {
+    override fun onReceive(context: Context, intent: Intent) {
+        if (intent.action != Intent.ACTION_BOOT_COMPLETED || !CraftPassiveStepStore(context).enabled()) return
+        WorkManager.getInstance(context).enqueueUniqueWork("craft-passive-steps-restore", ExistingWorkPolicy.KEEP,
+            OneTimeWorkRequestBuilder<CraftPassiveStepsRestoreWorker>().build())
+    }
+}
+
+class CraftPassiveStepsRestoreWorker(context: Context, params: WorkerParameters) : Worker(context, params) {
+    override fun doWork(): Result {
+        if (!CraftPassiveStepStore(applicationContext).enabled()) return Result.success()
+        val finished = java.util.concurrent.CountDownLatch(1)
+        var answer: CraftNativeCapabilityResult? = null
+        CraftPassiveSteps(applicationContext).perform("restore") { answer = it; finished.countDown() }
+        if (!finished.await(25, TimeUnit.SECONDS)) return Result.retry()
+        return when (answer?.code) {
+            null -> Result.success()
+            "PERMISSION_DENIED" -> { CraftPassiveStepStore(applicationContext).setEnabled(false); Result.failure() }
+            else -> if (runAttemptCount < 3) Result.retry() else Result.failure()
+        }
+    }
+}

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

@@ -0,0 +1,156 @@
+package com.craft.runtime
+
+import android.content.Context
+import android.hardware.Sensor
+import android.hardware.SensorEvent
+import android.hardware.SensorEventListener
+import android.hardware.SensorManager
+import android.os.Handler
+import android.os.Looper
+import android.os.PowerManager
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.File
+import java.util.UUID
+
+/** Native-only journal: JS suspension cannot drop pressure readings from a route. */
+object CraftRecordingPressure {
+    private fun file(context: Context, id: String): File {
+        val digest = java.security.MessageDigest.getInstance("SHA-256").digest(id.toByteArray(Charsets.UTF_8))
+        return File(context.filesDir, "craft-pressure-${digest.joinToString("") { "%02x".format(it) }}.jsonl")
+    }
+    fun requireAvailable(context: Context) {
+        val config = context.assets.open("craft.config.json").bufferedReader().use { JSONObject(it.readText()) }
+        if (!config.optBoolean("enableBarometer") || !config.optBoolean("enableBackgroundLocation"))
+            throw CraftRecordingException("CAPABILITY_DISABLED", "Recording pressure requires enableBarometer and enableBackgroundLocation")
+        val manager = context.getSystemService(SensorManager::class.java)
+        if (manager?.getDefaultSensor(Sensor.TYPE_PRESSURE, true) == null && manager?.getDefaultSensor(Sensor.TYPE_PRESSURE) == null)
+            throw CraftRecordingException("UNAVAILABLE", "Barometer is not present")
+    }
+    // Callers also hold the recording-store lock to serialize owner/ACK changes.
+    fun append(context: Context, id: String, event: JSONObject) {
+        val bytes = (event.put("recordingId", id).toString() + "\n").toByteArray(Charsets.UTF_8)
+        java.io.FileOutputStream(file(context, id), true).use { it.write(bytes); it.fd.sync() }
+    }
+    fun read(context: Context, id: String): JSONArray {
+        val result = JSONArray()
+        val source = file(context, id)
+        if (id.isEmpty() || !source.exists()) return result
+        source.forEachLine { line ->
+            if (line.isNotBlank()) {
+                val event = JSONObject(line)
+                check(event.getString("recordingId") == id) { "Invalid pressure recording owner" }
+                result.put(event)
+            }
+        }
+        return result
+    }
+    fun delete(context: Context, id: String) {
+        val source = file(context, id)
+        if (source.exists() && !source.delete()) throw CraftRecordingException("RECORDING_STORAGE_ERROR", "Unable to remove acknowledged pressure recording")
+    }
+}
+
+internal interface CraftRecordingPressureSource {
+    fun open(sample: (Float, Long) -> Unit): AutoCloseable
+}
+
+private class AndroidRecordingPressureSource(private val context: Context) : CraftRecordingPressureSource {
+    override fun open(sample: (Float, Long) -> Unit): AutoCloseable {
+        CraftRecordingPressure.requireAvailable(context)
+        val manager = context.getSystemService(SensorManager::class.java)
+            ?: throw IllegalStateException("Sensor manager unavailable")
+        val sensor = manager.getDefaultSensor(Sensor.TYPE_PRESSURE, true)
+            ?: manager.getDefaultSensor(Sensor.TYPE_PRESSURE)
+            ?: throw IllegalStateException("Barometer unavailable")
+        // A non-wake-up sensor cannot deliver continuously during CPU suspend.
+        // Only the explicitly requested, unpaused foreground recording owns this lock.
+        val wake = if (!sensor.isWakeUpSensor) context.getSystemService(PowerManager::class.java)
+            .newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "craft:recording-pressure").apply { setReferenceCounted(false) } else null
+        val listener = object : SensorEventListener {
+            override fun onSensorChanged(event: SensorEvent) { sample(event.values.firstOrNull() ?: Float.NaN, event.timestamp) }
+            override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) {}
+        }
+        try {
+            wake?.acquire()
+            check(manager.registerListener(listener, sensor, 1_000_000, Handler(Looper.getMainLooper()))) { "Pressure registration rejected" }
+        } catch (error: Exception) {
+            manager.unregisterListener(listener)
+            if (wake?.isHeld == true) wake.release()
+            throw error
+        }
+        return AutoCloseable {
+            try { manager.unregisterListener(listener) }
+            finally { if (wake?.isHeld == true) wake.release() }
+        }
+    }
+}
+
+/** One service-owned segment, independent of native screen and WebView lifetimes. */
+internal class CraftRecordingPressureSession(
+    private val context: Context,
+    val id: String,
+    private val source: CraftRecordingPressureSource = AndroidRecordingPressureSource(context),
+) {
+    val epoch = CraftLocationRecordingStore.pressureEpoch
+    private var registration: AutoCloseable? = null
+    private var closed = false
+    private var started = false
+    private var reference: Float? = null
+    private var lastTimestamp: Long? = null
+    private var segment = UUID.randomUUID().toString()
+
+    private fun ownsRecording() = epoch == CraftLocationRecordingStore.pressureEpoch && CraftLocationRecordingStore.recordingId(context) == id &&
+        CraftLocationRecordingStore.isActive(context) && !CraftLocationRecordingStore.isPaused(context) &&
+        CraftLocationRecordingStore.pressureEnabled(context)
+
+    fun start() = synchronized(CraftLocationRecordingStore) {
+        if (closed || started || !ownsRecording()) return@synchronized
+        started = true
+        try {
+            write(JSONObject().put("state", "segment").put("reason", "startedOrRecovered"))
+            val acquired = source.open(::sample)
+            if (closed) acquired.close() else registration = acquired
+        } catch (error: Exception) { fail(error) }
+    }
+
+    private fun write(event: JSONObject) {
+        CraftRecordingPressure.append(context, id, event.put("segmentId", segment).put("timestamp", System.currentTimeMillis()))
+    }
+
+    private fun sample(pressure: Float, timestamp: Long) = synchronized(CraftLocationRecordingStore) {
+        if (closed || !ownsRecording()) return@synchronized
+        try {
+            require(pressure.isFinite() && pressure > 0 && timestamp >= 0) { "Invalid pressure sample" }
+            val previous = lastTimestamp
+            if (previous != null && timestamp <= previous) return@synchronized
+            if (previous != null && timestamp - previous < 1_000_000_000L) return@synchronized
+            if (previous != null && timestamp - previous > 3_000_000_000L) {
+                segment = UUID.randomUUID().toString()
+                reference = null
+                write(JSONObject().put("state", "segment").put("reason", "sampleGap").put("timestampMs", timestamp / 1_000_000.0))
+            }
+            val baseline = reference ?: pressure.also { reference = it }
+            val altitude = SensorManager.getAltitude(baseline, pressure)
+            require(altitude.isFinite()) { "Invalid pressure altitude" }
+            write(JSONObject().put("state", "sample").put("pressureHpa", pressure)
+                .put("referencePressureHpa", baseline).put("relativeAltitudeMeters", altitude)
+                .put("timestampMs", timestamp / 1_000_000.0))
+            lastTimestamp = timestamp
+        } catch (error: Exception) { fail(error) }
+    }
+
+    private fun fail(error: Exception) {
+        close()
+        runCatching { write(JSONObject().put("state", "stopped").put("reason", "sensorOrStorageError")) }
+        CraftLocationRecordingStore.failPressure(context, id, error.message ?: "Pressure recording failed")
+    }
+
+    fun close() {
+        if (closed) return
+        closed = true
+        runCatching { registration?.close() }
+            .onFailure { android.util.Log.e("CraftLocation", "Unable to unregister pressure listener", it) }
+        registration = null
+    }
+}