@craft-native/android 0.0.435 → 0.0.442

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@craft-native/android",
-  "version": "0.0.435",
+  "version": "0.0.442",
   "homepage": "https://github.com/craft-native/craft/tree/main/packages/android#readme",
   "repository": {
     "type": "git",

package/templates/CraftHealthServices.kt.template

@@ -20,9 +20,11 @@ internal class CraftHealthServices(
     private val activityProvider: () -> Activity?,
     private val fallback: ((String, JSONArray, (CraftNativeCapabilityResult) -> Unit) -> Unit)? = null,
 ) {
+    private val passiveSteps by lazy { CraftPassiveSteps(context) }
     private fun failure(code: String, message: String) = CraftNativeCapabilityResult(code = code, message = message)
 
     fun perform(method: String, args: JSONArray, done: (CraftNativeCapabilityResult) -> Unit) {
+        if (method.startsWith("passive:")) { passiveSteps.perform(method.removePrefix("passive:"), done); return }
         when (method) {
             "startWorkout" -> start(args.optJSONObject(0) ?: JSONObject(), done)
             "pauseWorkout" -> command(CraftHealthServicesService.ACTION_PAUSE, done)

package/templates/CraftNativeCapabilities.kt.template

@@ -22,6 +22,7 @@ import android.net.NetworkCapabilities
 import android.provider.MediaStore
 import android.util.Base64
 import androidx.core.content.ContextCompat
+import androidx.core.app.ActivityCompat
 import androidx.biometric.BiometricManager
 import androidx.biometric.BiometricPrompt
 import androidx.fragment.app.FragmentActivity
@@ -50,6 +51,7 @@ private const val CRAFT_NATIVE_FILE_PICK_FIRST = 0x4000
 private const val CRAFT_NATIVE_FILE_PICK_LAST = 0xffff
 private const val CRAFT_NATIVE_FILE_PICK_STATE = "craft.filePicker.nextCode"
 private const val CRAFT_NATIVE_NOTIFICATION_PERMISSION_REQUEST = 4102
+private const val CRAFT_NATIVE_PEDOMETER_PERMISSION_REQUEST = 4358
 private const val CRAFT_NATIVE_FILE_DEFAULT_MAX_PIXELS = 2048
 private const val CRAFT_NATIVE_FILE_LARGEST_MAX_PIXELS = 8192
 private const val CRAFT_NATIVE_FILE_DEFAULT_QUALITY = 0.85
@@ -88,6 +90,8 @@ internal class CraftNativeCapabilities(
             override fun dismiss(requestCode: Int) { host.finishActivity(requestCode) }
         }
     },
+    private val requestPedometerPermission: ((Int) -> Unit)? = null,
+    private val checkPedometerPermission: (() -> Boolean)? = null,
 ) {
     companion object {
         private val pickerCodes = CraftNativePickerCodes()
@@ -127,6 +131,8 @@ internal class CraftNativeCapabilities(
     private val fileRoot by lazy { File(context.cacheDir, "craft-files").apply { mkdirs() } }
     private var pendingFilePick: PendingFilePick? = null
     private var pendingNotificationPermission: ((Boolean) -> Unit)? = null
+    private var pendingPedometerPermission: Pair<String, (CraftNativeCapabilityResult) -> Unit>? = null
+    private var pedometerPermissionInFlight = false
     private var database: SQLiteDatabase? = null
     private val biometricPrompts = ConcurrentHashMap<String, BiometricPrompt>()
 
@@ -214,6 +220,29 @@ internal class CraftNativeCapabilities(
                 if (method == "randomUUID") complete(requestToken, success(UUID.randomUUID().toString()), completion)
                 else complete(requestToken, failure("UNKNOWN_ACTION", "Unsupported Crypto method"), completion)
             }
+            "Pedometer" -> {
+                if (!config.optBoolean("enablePedometer")) complete(requestToken, failure("CAPABILITY_DISABLED", "Pedometer is disabled"), completion)
+                else if (method != "requestPermission") complete(requestToken, failure("UNKNOWN_ACTION", "Unsupported Pedometer permission method"), completion)
+                else onMain {
+                    if (cancelled.remove(requestToken) || closed.get()) return@onMain
+                    val host = activity
+                    if (host == null && requestPedometerPermission == null) complete(requestToken, failure("NEEDS_ACTIVITY", "Pedometer permission needs a screen"), completion)
+                    else if (pedometerPermissionGranted()) complete(requestToken, success("granted"), completion)
+                    else if (pedometerPermissionInFlight) complete(requestToken, failure("PERMISSION_BUSY", "An activity recognition request is already open"), completion)
+                    else {
+                        pendingPedometerPermission = requestToken to completion
+                        pedometerPermissionInFlight = true
+                        try {
+                            if (requestPedometerPermission != null) requestPedometerPermission.invoke(CRAFT_NATIVE_PEDOMETER_PERMISSION_REQUEST)
+                            else ActivityCompat.requestPermissions(requireNotNull(host), arrayOf(Manifest.permission.ACTIVITY_RECOGNITION), CRAFT_NATIVE_PEDOMETER_PERMISSION_REQUEST)
+                        } catch (error: Exception) {
+                            pendingPedometerPermission = null
+                            pedometerPermissionInFlight = false
+                            complete(requestToken, failure("PERMISSION_ERROR", error.message ?: "Permission could not be requested"), completion)
+                        }
+                    }
+                }
+            }
             "Bluetooth" -> {
                 if (!config.optBoolean("enableBluetooth")) complete(requestToken, failure("CAPABILITY_DISABLED", "Bluetooth is disabled"), completion)
                 else bluetooth.perform(method, args) { complete(requestToken, it, completion) }
@@ -268,6 +297,7 @@ internal class CraftNativeCapabilities(
         cancelled.add(requestToken)
         fetchConnections.remove(requestToken)?.disconnect()
         onMain {
+            if (pendingPedometerPermission?.first == requestToken) pendingPedometerPermission = null
             if (pendingFilePick?.requestToken == requestToken) {
                 dismissFilePick()
                 cancelled.remove(requestToken)
@@ -285,13 +315,24 @@ internal class CraftNativeCapabilities(
         networkExecutor.shutdownNow()
         fetchConnections.values.forEach(HttpURLConnection::disconnect)
         fetchConnections.clear()
-        onMain { dismissFilePick() }
+        onMain { dismissFilePick(); pendingPedometerPermission = null; pedometerPermissionInFlight = false }
         database?.close()
         database = null
         biometricPrompts.values.forEach { it.cancelAuthentication() }
         biometricPrompts.clear()
     }
 
+    fun pedometerPermissionGranted(): Boolean = checkPedometerPermission?.invoke() ?: (Build.VERSION.SDK_INT < 29 ||
+        ContextCompat.checkSelfPermission(context, Manifest.permission.ACTIVITY_RECOGNITION) == PackageManager.PERMISSION_GRANTED)
+
+    fun onPedometerPermissions(requestCode: Int) {
+        if (requestCode != CRAFT_NATIVE_PEDOMETER_PERMISSION_REQUEST) return
+        pedometerPermissionInFlight = false
+        val pending = pendingPedometerPermission
+        pendingPedometerPermission = null
+        pending?.let { (token, completion) -> complete(token, success(if (pedometerPermissionGranted()) "granted" else "denied"), completion) }
+    }
+
     private fun onMain(work: () -> Unit) {
         if (android.os.Looper.myLooper() == android.os.Looper.getMainLooper()) work()
         else mainHandler.post { work() }

package/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/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/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()
+        }
+    }
+}