craft-native 0.0.436 → 0.0.442

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
+    }
+}

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

@@ -110,20 +110,21 @@ object CraftLocationRecordingStore {
         if (!acknowledged(context, id)) return
         val saved = archive(context, id)
         if (saved.exists() && !saved.delete()) throw CraftRecordingException("RECORDING_STORAGE_ERROR", "Unable to remove acknowledged recording")
+        CraftRecordingPressure.delete(context, id)
         if (file(context).exists() && !file(context).delete()) throw CraftRecordingException("RECORDING_STORAGE_ERROR", "Unable to remove acknowledged samples")
-        edit(context) { it.remove("id").remove("startedAt").putBoolean("active", false).putBoolean("paused", false) }
+        edit(context) { it.remove("id").remove("startedAt").remove("barometer").remove("barometerError").putBoolean("active", false).putBoolean("paused", false) }
         listener = null
     }
 
     @Synchronized
-    fun start(context: Context, id: String, startedAt: Long, powerMode: String = "default") {
+    fun start(context: Context, id: String, startedAt: Long, powerMode: String = "default", barometer: Boolean = false) {
         recover(context)
         if (isActive(context)) throw CraftRecordingException("RECORDING_ALREADY_ACTIVE", "A location recording is already active")
         if (id == recordingId(context) || archive(context, id).exists() || acknowledged(context, id))
             throw CraftRecordingException("RECORDING_CONFLICT", "Recording IDs cannot be reused")
         archiveCompleted(context)
         file(context).writeText("")
-        edit(context) { it.putString("id", id).putBoolean("active", true).putBoolean("paused", false).putLong("startedAt", startedAt).putString("powerMode", powerMode).remove("powerSaver") }
+        edit(context) { it.putString("id", id).putBoolean("barometer", barometer).remove("barometerError").putBoolean("active", true).putBoolean("paused", false).putLong("startedAt", startedAt).putString("powerMode", powerMode).remove("powerSaver") }
     }
 
     private val POWER_MODES = setOf("default", "saver", "auto")
@@ -187,7 +188,10 @@ object CraftLocationRecordingStore {
     fun updatePause(context: Context, paused: Boolean, options: JSONObject?): JSONObject {
         requireOwner(context, options)
         if (!isActive(context)) throw CraftRecordingException("NO_ACTIVE_RECORDING", "No active location recording")
+        if (paused && !isPaused(context)) pressureEvent(context, "paused")
         commit(context, true, paused)
+        pressureEpoch += 1
+        changed?.invoke()
         return state(context)
     }
     @Synchronized fun setPaused(context: Context, paused: Boolean) { updatePause(context, paused, null) }
@@ -196,8 +200,10 @@ object CraftLocationRecordingStore {
     fun finish(context: Context, options: JSONObject?): JSONObject {
         completed(context, expected(options))?.let { return it }
         requireOwner(context, options)
+        if (isActive(context)) pressureEvent(context, "stopped")
         val stopped = state(context, includeLocations = true)
         commit(context, false, false)
+        changed?.invoke()
         listener = null
         return stopped.put("active", false).put("paused", false).put("effectivePowerMode", "default")
     }
@@ -213,9 +219,10 @@ object CraftLocationRecordingStore {
         val marker = File(saved.path.replace("-completed-", "-ack-"))
         if (!marker.exists()) writeAtomic(marker, id)
         if (saved.exists() && !saved.delete()) throw CraftRecordingException("RECORDING_STORAGE_ERROR", "Unable to remove completed recording")
+        CraftRecordingPressure.delete(context, id)
         if (current) {
             if (file(context).exists() && !file(context).delete()) throw CraftRecordingException("RECORDING_STORAGE_ERROR", "Unable to remove recording samples")
-            edit(context) { it.remove("id").remove("startedAt").putBoolean("active", false).putBoolean("paused", false) }
+            edit(context) { it.remove("id").remove("startedAt").remove("barometer").remove("barometerError").putBoolean("active", false).putBoolean("paused", false) }
             listener = null
         }
         return true
@@ -236,7 +243,11 @@ object CraftLocationRecordingStore {
                         if (requested !is String || requested.isBlank()) throw CraftRecordingException("INVALID_ARGUMENT", "recordingId must be a nonempty recording ID")
                         requested
                     } else java.util.UUID.randomUUID().toString()
-                    start(context, id, System.currentTimeMillis(), requestedPowerMode(options, "default"))
+                    if (options.has("barometer") && options.opt("barometer") !is Boolean)
+                        throw CraftRecordingException("INVALID_ARGUMENT", "barometer must be boolean")
+                    val pressure = options.optBoolean("barometer", false)
+                    if (pressure) CraftRecordingPressure.requireAvailable(context)
+                    start(context, id, System.currentTimeMillis(), requestedPowerMode(options, "default"), pressure)
                     try { ContextCompat.startForegroundService(context, Intent(context, LocationRecordingService::class.java).setAction(LocationRecordingService.ACTION_START).putExtra("recordingId", id)) }
                     catch (error: Exception) { finish(context, JSONObject().put("expectedId", id)); throw error }
                     state(context)
@@ -267,7 +278,16 @@ object CraftLocationRecordingStore {
                         context.startService(Intent(context, LocationRecordingService::class.java).setAction(LocationRecordingService.ACTION_STOP).putExtra("recordingId", stopped.optString("id")))
                     stopped
                 }
-                "getRecordingState" -> state(context, options = options)
+                "getRecordingState" -> {
+                    if (options.has("includeBarometerSamples") && options.opt("includeBarometerSamples") !is Boolean)
+                        throw CraftRecordingException("INVALID_ARGUMENT", "includeBarometerSamples must be boolean")
+                    state(context, options = options).also { result ->
+                        if (options.optBoolean("includeBarometerSamples")) {
+                            val id = result.optString("id")
+                            result.put("barometerEvents", CraftRecordingPressure.read(context, id))
+                        }
+                    }
+                }
                 "readRecording" -> read(context, options)
                 "acknowledgeRecording" -> acknowledge(context, options)
                 else -> throw CraftRecordingException("UNKNOWN_ACTION", "Unsupported Location method")
@@ -281,6 +301,19 @@ object CraftLocationRecordingStore {
     @Synchronized fun isActive(context: Context) = prefs(context).getBoolean("active", false)
     @Synchronized fun isPaused(context: Context) = prefs(context).getBoolean("paused", false)
     @Synchronized fun recordingId(context: Context): String? = prefs(context).getString("id", null)
+    @Volatile internal var pressureEpoch = 0L
+    @Volatile internal var changed: (() -> Unit)? = null
+    @Synchronized internal fun pressureEnabled(context: Context) = prefs(context).getBoolean("barometer", false)
+    @Synchronized internal fun failPressure(context: Context, id: String, message: String) {
+        if (recordingId(context) != id || !isActive(context)) return
+        edit(context) { it.putBoolean("active", false).putBoolean("paused", false).putString("barometerError", message) }
+        changed?.invoke()
+    }
+    private fun pressureEvent(context: Context, reason: String) {
+        val id = recordingId(context) ?: return
+        if (pressureEnabled(context)) CraftRecordingPressure.append(context, id,
+            JSONObject().put("state", "stopped").put("reason", reason).put("timestamp", System.currentTimeMillis()))
+    }
     @Volatile var listener: ((android.location.Location, String) -> Unit)? = null
     @Volatile var nativeListener: ((android.location.Location, String) -> Unit)? = null
 
@@ -329,7 +362,7 @@ object CraftLocationRecordingStore {
     @Synchronized
     fun state(context: Context, includeLocations: Boolean = false, options: JSONObject? = null): JSONObject {
         completed(context, expected(options))?.let {
-            if (!includeLocations) it.remove("locations")
+            if (!includeLocations) { it.remove("locations"); it.remove("barometerEvents") }
             return it
         }
         requireOwner(context, options)
@@ -343,7 +376,12 @@ object CraftLocationRecordingStore {
             put("sampleCount", locations.length())
             put("powerMode", powerMode(context))
             put("effectivePowerMode", if (isPowerSaver(context)) "saver" else "default")
-            if (includeLocations) put("locations", locations)
+            put("barometer", pressureEnabled(context))
+            values.getString("barometerError", null)?.let { put("barometerError", it) }
+            if (includeLocations) {
+                put("locations", locations)
+                if (pressureEnabled(context)) put("barometerEvents", CraftRecordingPressure.read(context, recordingId(context) ?: ""))
+            }
         }
     }
 }
@@ -355,9 +393,33 @@ class LocationRecordingService : Service() {
     private var callbackSaver = false
     private var serviceStartId = 0
     private var powerReceiver: BroadcastReceiver? = null
+    private var pressure: CraftRecordingPressureSession? = null
+    private val mainHandler = android.os.Handler(Looper.getMainLooper())
+    private val pressureChanged: () -> Unit = {
+        mainHandler.post {
+            if (!CraftLocationRecordingStore.isActive(this)) { stopUpdates(); stopSelfResult(serviceStartId) }
+            else syncPressure()
+        }
+        Unit
+    }
+
+    private fun syncPressure() = synchronized(CraftLocationRecordingStore) {
+        val id = CraftLocationRecordingStore.recordingId(this)
+        val wanted = id != null && CraftLocationRecordingStore.isActive(this) &&
+            !CraftLocationRecordingStore.isPaused(this) && CraftLocationRecordingStore.pressureEnabled(this)
+        if (wanted && pressure?.id == id && pressure?.epoch == CraftLocationRecordingStore.pressureEpoch) return@synchronized
+        pressure?.close()
+        pressure = null
+        if (wanted) {
+            val next = CraftRecordingPressureSession(this, id!!)
+            pressure = next
+            next.start()
+        }
+    }
 
     override fun onCreate() {
         super.onCreate()
+        CraftLocationRecordingStore.changed = pressureChanged
         val manager = getSystemService(NotificationManager::class.java)
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
             manager.createNotificationChannel(NotificationChannel(CHANNEL, "Activity recording", NotificationManager.IMPORTANCE_LOW))
@@ -417,6 +479,7 @@ class LocationRecordingService : Service() {
         val saver = CraftLocationRecordingStore.isPowerSaver(this)
         if (callback != null && callbackRecordingId == id && callbackSaver == saver) {
             syncPowerReceiver()
+            syncPressure()
             return true
         }
         stopUpdates()
@@ -446,6 +509,7 @@ class LocationRecordingService : Service() {
         callbackRecordingId = id
         callbackSaver = saver
         syncPowerReceiver()
+        syncPressure()
         return try {
             client.requestLocationUpdates(request, nextCallback, Looper.getMainLooper())
                 .addOnFailureListener {
@@ -460,13 +524,15 @@ class LocationRecordingService : Service() {
                 }
             true
         } catch (error: Exception) {
-            callback = null
+            stopUpdates()
             runCatching { CraftLocationRecordingStore.finish(this, JSONObject().put("expectedId", id)) }
             false
         }
     }
 
     private fun stopUpdates() {
+        pressure?.close()
+        pressure = null
         callback?.let { client.removeLocationUpdates(it) }
         callback = null
         callbackRecordingId = null
@@ -504,6 +570,8 @@ class LocationRecordingService : Service() {
     }
 
     override fun onDestroy() {
+        if (CraftLocationRecordingStore.changed === pressureChanged) CraftLocationRecordingStore.changed = null
+        mainHandler.removeCallbacksAndMessages(null)
         stopUpdates()
         super.onDestroy()
     }