@craft-native/android 0.0.436 → 0.0.442

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

package/templates/MainActivityNative.kt.template

@@ -4563,6 +4563,11 @@ class MainActivity : AppCompatActivity() {
         val pressUnderlayShowHandlers = mutableMapOf<View, String>()
         val pressUnderlayHideHandlers = mutableMapOf<View, String>()
         val longPressHandlers = mutableMapOf<View, String>()
+        val accessibilityActionHandlers = mutableMapOf<View, String>()
+        // TalkBack actions are added by id, so removing them on a reconcile
+        // needs the ids back; without this a renamed action stacks up beside
+        // the old one every render.
+        val accessibilityActionIds = mutableMapOf<View, List<Int>>()
         val scrollHandlers = mutableMapOf<View, String>()
         val scrollBeginHandlers = mutableMapOf<View, String>()
         val scrollEndHandlers = mutableMapOf<View, String>()
@@ -4596,6 +4601,9 @@ class MainActivity : AppCompatActivity() {
         val capabilityTimeouts = mutableMapOf<String, Runnable>()
         val audio = CraftNativeAudio()
         val sounds = CraftNativeSounds(view.context)
+        var motion: CraftNativeMotion? = null
+        var barometer: CraftNativeBarometer? = null
+        var pedometer: CraftNativePedometer? = null
         val soundRequestCancellers = mutableMapOf<String, () -> Unit>()
         /** Snapshot writes awaiting the writer thread; close rejects them once. */
         val pendingSyncResults = mutableSetOf<String>()
@@ -4617,6 +4625,9 @@ class MainActivity : AppCompatActivity() {
             soundRequestCancellers.values.toList().forEach { it() }
             soundRequestCancellers.clear()
             sounds.close()
+            motion?.close()
+            barometer?.close()
+            pedometer?.close()
             // Evaluation completion does not mean its outbound messages have
             // reached the host. Close only after the ordered channel barrier,
             // so onDestroy's final writes run before navigation continues.
@@ -4688,6 +4699,10 @@ class MainActivity : AppCompatActivity() {
     private var hapticsEnabled = false
     private var clipboardEnabled = false
     private var shakeEnabled = false
+    private var motionSensorsEnabled = false
+    private var barometerEnabled = false
+    private var pedometerEnabled = false
+    private var motionForeground = false
     internal var nativeAppState = "inactive"
         private set
     private var deliveredInitialDeepLink = false
@@ -4761,6 +4776,9 @@ class MainActivity : AppCompatActivity() {
         hapticsEnabled = config.optBoolean("enableHaptics", false)
         clipboardEnabled = config.optBoolean("enableClipboard", false)
         shakeEnabled = config.optBoolean("enableShakeGesture", false)
+        motionSensorsEnabled = config.optBoolean("enableMotionSensors", false)
+        barometerEnabled = config.optBoolean("enableBarometer", false)
+        pedometerEnabled = config.optBoolean("enablePedometer", false)
         // Normally started already by its content provider; this covers a
         // process that skipped providers (instrumentation).
         CraftCrashReporter.start(this)
@@ -5153,6 +5171,30 @@ class MainActivity : AppCompatActivity() {
         activeScreen.view.onLayoutChanged = {
             if (activeScreen.active) emitLayoutEvents(activeScreen)
         }
+        if (motionSensorsEnabled && !headless) {
+            activeScreen.motion = CraftNativeMotion(CraftAndroidMotionSource(this)).apply {
+                emit = { detail ->
+                    if (activeScreen.active && motionForeground) send(activeScreen, "CRAFT_EVENT",
+                        JSONObject().put("event", "craftRawMotionUpdate").put("detail", detail))
+                }
+            }
+        }
+        if (barometerEnabled && !headless) {
+            activeScreen.barometer = CraftNativeBarometer(CraftAndroidMotionSource(this)).apply {
+                emit = { detail ->
+                    if (activeScreen.active) send(activeScreen, "CRAFT_EVENT",
+                        JSONObject().put("event", "craftBarometerUpdate").put("detail", detail))
+                }
+            }
+        }
+        if (pedometerEnabled && !headless) {
+            activeScreen.pedometer = CraftNativePedometer(CraftAndroidMotionSource(this), capabilities::pedometerPermissionGranted).apply {
+                emit = { detail ->
+                    if (activeScreen.active) send(activeScreen, "CRAFT_EVENT",
+                        JSONObject().put("event", "craftPedometerUpdate").put("detail", detail))
+                }
+            }
+        }
         activeScreen.sounds.emit = { payload ->
             if (activeScreen.active) send(activeScreen, "SOUND_EVENT", payload)
         }
@@ -5534,6 +5576,9 @@ class MainActivity : AppCompatActivity() {
     private fun capabilityNames(): JSONArray = capabilities.names().apply {
         services.names().forEach { name -> put(name) }
         put("audio")
+        if (motionSensorsEnabled) put("rawMotionSensors")
+        if (barometerEnabled) put("barometer")
+        if (pedometerEnabled) put("pedometer")
         put("viewFocus")
         put("viewMeasure")
         put("viewScroll")
@@ -6952,6 +6997,7 @@ class MainActivity : AppCompatActivity() {
         CraftNativePointers.configure(control, props, style, control is CraftNativeFlexLayout || control is CraftNativeImageBackgroundView ||
             control is CraftNativeKeyboardAvoidingView || control is CraftNativeScrollView || control is CraftNativeRefreshableFlatList || control is CraftNativeModalView)
         applyAccessibility(control, props, type, explicitKey ?: protocolId ?: path)
+        applyAccessibilityActions(screen, control, props, events, longPressDisabled)
         // One element across an animated change (craft.animation.next).
         control.transitionName = craftNativeOptionalString(props.opt("transitionID"))?.takeIf { it.isNotBlank() }
         val layoutHandler = craftNativeEventName(events, "onLayout")
@@ -7854,6 +7900,54 @@ class MainActivity : AppCompatActivity() {
         field.setSelection(minOf(boundedStart, boundedEnd), maxOf(boundedStart, boundedEnd))
     }
 
+    /**
+     * What a hold offers, published where TalkBack can reach it.
+     *
+     * A long click is invisible to a screen reader: nothing announces that it
+     * is there and nothing can perform it, so an action living only behind a
+     * hold does not exist for anyone driving the screen by assistive
+     * technology. A thread that holds a message for Copy and Report is the
+     * case this was written for; without this the honest mitigation is a
+     * permanently visible button under every message.
+     *
+     * Runs after applyAccessibility, which installs its own delegate and
+     * would drop actions added before it.
+     */
+    private fun applyAccessibilityActions(
+        screen: Screen,
+        control: View,
+        props: JSONObject,
+        events: JSONObject,
+        disabled: Boolean,
+    ) {
+        screen.accessibilityActionIds.remove(control)?.forEach { ViewCompat.removeAccessibilityAction(control, it) }
+        val handler = craftNativeEventName(events, "onAccessibilityAction").takeUnless { disabled } ?: ""
+        val authored = props.optJSONArray("accessibilityActions")
+        if (handler.isBlank() || authored == null || authored.length() == 0) {
+            screen.accessibilityActionHandlers.remove(control)
+            return
+        }
+        screen.accessibilityActionHandlers[control] = handler
+        val ids = mutableListOf<Int>()
+        for (index in 0 until authored.length()) {
+            val entry = authored.optJSONObject(index) ?: continue
+            val name = craftNativeOptionalString(entry.opt("name"))?.takeIf { it.isNotBlank() } ?: continue
+            val label = craftNativeOptionalString(entry.opt("label"))?.takeIf { it.isNotBlank() } ?: name
+            ids += ViewCompat.addAccessibilityAction(control, label) { _, _ ->
+                // Read the handler at firing time: a reconcile can rename it
+                // while the action sits in TalkBack's menu.
+                val current = screen.accessibilityActionHandlers[control]
+                if (current.isNullOrBlank()) {
+                    false
+                } else {
+                    send(screen, "EVENT", JSONObject().put("handlerName", current).put("nativeEvent", JSONObject().put("actionName", name)))
+                    true
+                }
+            }
+        }
+        if (ids.isEmpty()) screen.accessibilityActionHandlers.remove(control) else screen.accessibilityActionIds[control] = ids
+    }
+
     private fun applyAccessibility(view: View, props: JSONObject, type: String, fallbackLabel: String) {
         val testId = craftNativeOptionalString(props.opt("testID"))
         view.tag = testId?.takeIf { it.isNotBlank() } ?: fallbackLabel
@@ -8039,6 +8133,37 @@ class MainActivity : AppCompatActivity() {
         val method = payload.optString("method")
         val perform: ((CraftNativeCapabilityResult) -> Unit) -> Unit = if (module == "View") {
             { completion -> performView(screen, method, args, completion) }
+        } else if (module == "Pedometer") {
+            { completion ->
+                val pedometer = screen.pedometer
+                if (!pedometerEnabled) completion(CraftNativeCapabilityResult(code = "CAPABILITY_DISABLED", message = "Pedometer is disabled"))
+                else if (pedometer == null) completion(CraftNativeCapabilityResult(code = "NEEDS_ACTIVITY", message = "Pedometer needs a visible app"))
+                else if (method in listOf("start", "requestPermission") && !motionForeground) completion(CraftNativeCapabilityResult(code = "APP_INACTIVE", message = "Pedometer needs a foreground app"))
+                else if (method == "requestPermission") capabilities.perform(token, payload.optInt("version", CRAFT_NATIVE_CAPABILITY_PROTOCOL_VERSION), module, method, args, completion)
+                else completion(pedometer.perform(method, args))
+            }
+        } else if (module == "Barometer") {
+            { completion ->
+                val barometer = screen.barometer
+                completion(if (!barometerEnabled) {
+                    CraftNativeCapabilityResult(code = "CAPABILITY_DISABLED", message = "Barometer is disabled")
+                } else if (barometer == null) {
+                    CraftNativeCapabilityResult(code = "NEEDS_ACTIVITY", message = "Barometer needs a visible app")
+                } else if (method == "start" && !motionForeground) {
+                    CraftNativeCapabilityResult(code = "APP_INACTIVE", message = "Barometer needs a foreground app")
+                } else barometer.perform(method, args))
+            }
+        } else if (module == "MotionSensors") {
+            { completion ->
+                val motion = screen.motion
+                completion(if (!motionSensorsEnabled) {
+                    CraftNativeCapabilityResult(code = "CAPABILITY_DISABLED", message = "Motion sensors are disabled")
+                } else if (motion == null) {
+                    CraftNativeCapabilityResult(code = "NEEDS_ACTIVITY", message = "Motion sensors need a visible app")
+                } else if (method == "start" && !motionForeground) {
+                    CraftNativeCapabilityResult(code = "APP_INACTIVE", message = "Motion sensors need a foreground app")
+                } else motion.perform(method, args))
+            }
         } else if (module == "Audio") {
             { completion ->
                 val id = args.optString(0)
@@ -8290,6 +8415,8 @@ class MainActivity : AppCompatActivity() {
     }
 
     override fun onPause() {
+        motionForeground = false
+        allScreens().forEach { it.motion?.stopAll(); it.barometer?.stop("background"); it.pedometer?.stop("background") }
         disarmShakeGesture()
         if (::services.isInitialized) services.pauseVoice()
         nativeAppState = "inactive"
@@ -8350,13 +8477,14 @@ class MainActivity : AppCompatActivity() {
 
     override fun onResume() {
         super.onResume()
+        motionForeground = true
         armShakeGesture()
         if (::services.isInitialized) services.resumed()
     }
 
     override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<out String>, grantResults: IntArray) {
         super.onRequestPermissionsResult(requestCode, permissions, grantResults)
-        if (::capabilities.isInitialized) { capabilities.onBluetoothPermissions(requestCode); capabilities.onNotificationPermissions(requestCode) }
+        if (::capabilities.isInitialized) { capabilities.onBluetoothPermissions(requestCode); capabilities.onNotificationPermissions(requestCode); capabilities.onPedometerPermissions(requestCode) }
         if (::services.isInitialized) services.onRequestPermissionsResult(requestCode)
     }