craft-native 0.0.395 → 0.0.408

package/README.md

@@ -598,6 +598,13 @@ precommitted ID without adopting an unknown recording. The asynchronous Crypto
 service uses the platform's secure UUID generator; an unsupported native host
 rejects with `CRYPTO_UNSUPPORTED` without falling back to JavaScript entropy.
 
+To save battery on a long effort, start with `powerMode: 'saver'`, or `'auto'` to
+save only while iOS Low Power Mode or Android Battery Saver is on or the battery
+is low. Change a running recording with
+`location.setRecordingPowerMode({ expectedId: id, powerMode })` after checking
+`location.supportsRecordingPowerMode()`; recording states report `powerMode` and
+`effectivePowerMode` (see `docs/api/mobile/location.md`).
+
 Pass `{ expectedId: id }` to pause, resume, stop, read and get-state calls. Heart-rate reads also accept
 `since`. A supplied empty, whitespace or non-string ID rejects with
 `INVALID_ARGUMENT`. Starting while another session is active rejects with

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

@@ -323,6 +323,7 @@ class CraftBridge(
                     crypto: true,
                     locationRecordingOwnership: {{ENABLE_GEOLOCATION}} && ${CraftNative.supportsRecordingOwnership()},
                     locationRecordingIntentIdentity: {{ENABLE_GEOLOCATION}} && ${CraftNative.supportsRecordingIntentIdentity()},
+                    locationRecordingPowerMode: {{ENABLE_GEOLOCATION}} && ${CraftNative.supportsRecordingPowerMode()},
                     backgroundLocation: {{ENABLE_BACKGROUND_LOCATION}},
                     clipboard: false,
                     deviceInfo: true,
@@ -1714,6 +1715,7 @@ class CraftBridge(
                     watchPosition: craft.watchPosition,
                     clearWatch: craft.clearWatch,
                     startRecording: function(options) { return recordingCall('startRecording', options); },
+                    setRecordingPowerMode: function(options) { return recordingCall('setRecordingPowerMode', options); },
                     pauseRecording: function(options) { return recordingCall('pauseRecording', options); },
                     resumeRecording: function(options) { return recordingCall('resumeRecording', options); },
                     stopRecording: function(options) { return recordingCall('stopRecording', options); },

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

@@ -1954,6 +1954,13 @@ object CraftNative {
         return try { nativeRecordingOwnershipVersion() >= 1 } catch (_: UnsatisfiedLinkError) { false }
     }
 
+    /**
+     * `setRecordingPowerMode` and `powerMode: 'auto'`. The Kotlin store serves
+     * any method it is handed, so a linked runtime that passes recorder calls
+     * through (version 1 and up) supports it exactly as it supports ownership.
+     */
+    fun supportsRecordingPowerMode(): Boolean = supportsRecordingOwnership()
+
     fun supportsRecordingIntentIdentity(): Boolean {
         if (!isAvailable) return true
         return try { nativeRecordingOwnershipVersion() >= 2 } catch (_: UnsatisfiedLinkError) { false }

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

@@ -1,6 +1,7 @@
 package {{PACKAGE_NAME}}
 
 import android.content.Context
+import android.view.MotionEvent
 import android.view.View
 import android.view.ViewGroup
 import android.widget.FrameLayout
@@ -18,6 +19,9 @@ internal typealias CraftNativeRenderItem = (node: JSONObject, identity: String,
 
 /** A stable-key RecyclerView host for stx native FlatList nodes. */
 internal class CraftNativeFlatList(context: Context) : RecyclerView(context) {
+    override fun dispatchTouchEvent(event: MotionEvent): Boolean =
+        CraftNativePointers.dispatch(this, event) { super.dispatchTouchEvent(it) }
+
     private data class Item(
         val identity: String,
         val node: JSONObject,
@@ -227,11 +231,13 @@ internal class CraftNativeFlatList(context: Context) : RecyclerView(context) {
             .map { it.second }
 
     override fun onInterceptTouchEvent(event: android.view.MotionEvent): Boolean {
+        if (event.actionMasked != MotionEvent.ACTION_CANCEL && !CraftNativePointers.ownsTouch(this)) return false
         if (!scrollEnabled) return false
         return super.onInterceptTouchEvent(event)
     }
 
     override fun onTouchEvent(event: android.view.MotionEvent): Boolean {
+        if (event.actionMasked != MotionEvent.ACTION_CANCEL && !CraftNativePointers.ownsTouch(this)) return false
         if (!scrollEnabled) return false
         return super.onTouchEvent(event)
     }
@@ -304,6 +310,7 @@ internal class CraftNativeFlatList(context: Context) : RecyclerView(context) {
         }
         var dismissed = false
         setOnTouchListener { _, event ->
+            if (!CraftNativePointers.ownsTouch(this) && event.actionMasked != MotionEvent.ACTION_CANCEL) return@setOnTouchListener false
             when (event.actionMasked) {
                 android.view.MotionEvent.ACTION_DOWN -> dismissed = false
                 android.view.MotionEvent.ACTION_MOVE -> if (!dismissed) {

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

@@ -1,5 +1,8 @@
 /** The Android host for the small, host-neutral native trail map contract. */
 private class CraftNativeMapView(context: Context) : FrameLayout(context), OnMapReadyCallback {
+    override fun dispatchTouchEvent(event: MotionEvent): Boolean =
+        CraftNativePointers.dispatch(this, event) { super.dispatchTouchEvent(it) }
+
     private data class PolygonValue(val points: List<LatLng>, val fillColor: Int, val strokeColor: Int, val strokeWidth: Float)
     private val mapView = MapView(context)
     private val scaleView = LinearLayout(context).apply {

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

@@ -1,5 +1,8 @@
 /** A key-free native Android map. STX geometry never enters a WebView. */
 internal class CraftNativeMapView(context: Context) : FrameLayout(context), OnMapReadyCallback {
+    override fun dispatchTouchEvent(event: MotionEvent): Boolean =
+        CraftNativePointers.dispatch(this, event) { super.dispatchTouchEvent(it) }
+
     private val mapView: MapView
     private var map: MapLibreMap? = null
     private var destroyed = false

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

@@ -1,11 +1,20 @@
 package {{PACKAGE_NAME}}
 
 import android.content.Context
+import android.view.MotionEvent
 import org.json.JSONObject
 import androidx.swiperefreshlayout.widget.SwipeRefreshLayout
 
 /** Swipe-to-refresh host for a native FlatList. */
 internal class CraftNativeRefreshableFlatList(context: Context) : SwipeRefreshLayout(context) {
+    override fun dispatchTouchEvent(event: MotionEvent): Boolean =
+        CraftNativePointers.dispatch(this, event) { super.dispatchTouchEvent(it) }
+
+    override fun onInterceptTouchEvent(event: MotionEvent): Boolean =
+        CraftNativePointers.ownsTouch(this) && super.onInterceptTouchEvent(event)
+    override fun onTouchEvent(event: MotionEvent): Boolean =
+        (event.actionMasked == MotionEvent.ACTION_CANCEL || CraftNativePointers.ownsTouch(this)) && super.onTouchEvent(event)
+
     val list = CraftNativeFlatList(context)
     private var refreshHandler: (() -> Unit)? = null
 

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

@@ -135,6 +135,7 @@ internal class CraftNativeServices(
             add("geolocation")
             if (CraftNative.supportsRecordingOwnership()) add("locationRecordingOwnership")
             if (CraftNative.supportsRecordingIntentIdentity()) add("locationRecordingIntentIdentity")
+            if (CraftNative.supportsRecordingPowerMode()) add("locationRecordingPowerMode")
         }
         if (config.optJSONObject("backgroundRefresh")?.optBoolean("enabled") == true || config.optBoolean("enablePushNotifications")) add("background")
         // A Bluetooth heart-rate strap (CraftHeartRate.kt), the app's own
@@ -513,7 +514,7 @@ internal class CraftNativeServices(
                 watchCallback = null
                 done(success(true))
             }
-            "startRecording", "pauseRecording", "resumeRecording", "stopRecording", "getRecordingState", "readRecording", "acknowledgeRecording" -> {
+            "startRecording", "setRecordingPowerMode", "pauseRecording", "resumeRecording", "stopRecording", "getRecordingState", "readRecording", "acknowledgeRecording" -> {
                 val invoke = {
                     val answer = JSONObject(store.perform(context, method, (args.optJSONObject(0) ?: JSONObject()).toString()))
                     if (answer.optBoolean("ok")) {

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

@@ -93,6 +93,9 @@ internal data class CraftNativeTabBarAppearance(
 
 internal data class CraftTabIconAppearance(val symbol: String, val tint: Int?, val pulse: Boolean)
 
+/** The app's faces for the chrome (`fontFamily`, `headingFontFamily`); null keeps the system face. */
+internal data class CraftNativeChromeFonts(val body: Typeface? = null, val heading: Typeface? = null)
+
 /** The app's paths (`nativeScreens`), its tabs and its site. */
 internal class CraftNativeRoutes(config: JSONObject) {
     private data class Route(val segments: List<String>, val screen: String)
@@ -137,6 +140,10 @@ internal class CraftNativeRoutes(config: JSONObject) {
         }
         ?: CraftNativeTabBarAppearance()
 
+    /** CSS stacks for the chrome's labels and titles, as the app configured them. */
+    val fontFamily: String? = config.optString("fontFamily").takeUnless { config.isNull("fontFamily") || it.isBlank() }
+    val headingFontFamily: String? = config.optString("headingFontFamily").takeUnless { config.isNull("headingFontFamily") || it.isBlank() }
+
     /** The app's site (`devServerURL`): its origin answers paths no screen draws. */
     val site: Uri? = config.optString("devServerURL").takeIf { it.isNotBlank() }?.let(Uri::parse)
     val siteOrigin: String? = site?.let { uri ->
@@ -789,6 +796,7 @@ internal class CraftNativeChrome(
     context: Context,
     private val tabs: List<CraftNativeTab>,
     private val tabBarAppearance: CraftNativeTabBarAppearance = CraftNativeTabBarAppearance(),
+    private val fonts: CraftNativeChromeFonts = CraftNativeChromeFonts(),
 ) : LinearLayout(context) {
     val content = FrameLayout(context)
     private val bar = LinearLayout(context)
@@ -858,7 +866,7 @@ internal class CraftNativeChrome(
         leadingButtons.gravity = Gravity.CENTER_VERTICAL
         bar.addView(leadingButtons, LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, dp(56)))
         titleView.textSize = 20f
-        titleView.typeface = Typeface.create("sans-serif-medium", Typeface.NORMAL)
+        titleView.typeface = fonts.heading?.let { Typeface.create(it, Typeface.BOLD) } ?: Typeface.create("sans-serif-medium", Typeface.NORMAL)
         titleView.isSingleLine = true
         titleView.ellipsize = TextUtils.TruncateAt.END
         titleView.setPadding(dp(12), 0, dp(8), 0)
@@ -868,7 +876,7 @@ internal class CraftNativeChrome(
         bar.addView(buttons, LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, dp(56)))
         addView(bar, LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, dp(56)))
         largeTitleView.textSize = 32f
-        largeTitleView.typeface = Typeface.create("sans-serif", Typeface.BOLD)
+        largeTitleView.typeface = Typeface.create(fonts.heading ?: Typeface.create("sans-serif", Typeface.NORMAL), Typeface.BOLD)
         largeTitleView.isSingleLine = true
         largeTitleView.ellipsize = TextUtils.TruncateAt.END
         largeTitleView.setPadding(dp(16), 0, dp(16), dp(8))
@@ -907,6 +915,7 @@ internal class CraftNativeChrome(
             label.importantForAccessibility = View.IMPORTANT_FOR_ACCESSIBILITY_NO
             label.text = tab.title
             label.textSize = 12f
+            fonts.body?.let { label.typeface = it }
             label.fontFeatureSettings = "tnum"
             label.gravity = Gravity.CENTER
             label.isSingleLine = true
@@ -1199,6 +1208,7 @@ internal class CraftNativeChrome(
         val vector = if (symbol.isNotBlank()) CraftNativeIcons.drawable(context, null, symbol, tint) else null
         view.text = if (vector != null) "" else if (symbol.isNotBlank()) CraftNativeSymbols.glyph(symbol) else title
         view.textSize = if (symbol.isNotBlank()) 22f else 16f
+        if (symbol.isBlank()) fonts.body?.let { view.typeface = it }
         if (vector != null) {
             view.foreground = android.graphics.drawable.InsetDrawable(vector, dp(10), dp(15), dp(10), dp(15))
             view.minWidth = dp(46)

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

@@ -4,12 +4,16 @@ import android.Manifest
 import android.app.NotificationChannel
 import android.app.NotificationManager
 import android.app.Service
+import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
+import android.content.IntentFilter
 import android.content.pm.PackageManager
+import android.os.BatteryManager
 import android.os.Build
 import android.os.IBinder
 import android.os.Looper
+import android.os.PowerManager
 import androidx.core.app.NotificationCompat
 import androidx.core.content.ContextCompat
 import {{PACKAGE_NAME}}.R
@@ -112,14 +116,71 @@ object CraftLocationRecordingStore {
     }
 
     @Synchronized
-    fun start(context: Context, id: String, startedAt: Long) {
+    fun start(context: Context, id: String, startedAt: Long, powerMode: String = "default") {
         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) }
+        edit(context) { it.putString("id", id).putBoolean("active", true).putBoolean("paused", false).putLong("startedAt", startedAt).putString("powerMode", powerMode).remove("powerSaver") }
+    }
+
+    private val POWER_MODES = setOf("default", "saver", "auto")
+
+    /** A mode the page may ask for; `fallback` when the option is absent or null. */
+    private fun requestedPowerMode(options: JSONObject?, fallback: String?): String {
+        if (options == null || !options.has("powerMode") || options.isNull("powerMode"))
+            return fallback ?: throw CraftRecordingException("INVALID_ARGUMENT", "powerMode must be 'default', 'saver' or 'auto'")
+        val mode = options.opt("powerMode")
+        if (mode !is String || mode !in POWER_MODES) throw CraftRecordingException("INVALID_ARGUMENT", "powerMode must be 'default', 'saver' or 'auto'")
+        return mode
+    }
+
+    /**
+     * The mode the recording was asked for (`default`, `saver` or `auto`):
+     * `startRecording({ powerMode })`, changed by `setRecordingPowerMode`.
+     * A recording stored by an older build kept a `powerSaver` flag instead.
+     */
+    @Synchronized
+    fun powerMode(context: Context): String {
+        val values = prefs(context)
+        return values.getString("powerMode", null)?.takeIf { it in POWER_MODES }
+            ?: if (values.getBoolean("powerSaver", false)) "saver" else "default"
+    }
+
+    /**
+     * What the recorder uses right now: `saver` spaces fixes out and batches
+     * them, and `auto` is a saver while the device is saving power (Battery
+     * Saver on, or under 20% charge and not plugged in). Never outside a recording.
+     */
+    @Synchronized
+    fun isPowerSaver(context: Context): Boolean {
+        if (!isActive(context)) return false
+        return when (powerMode(context)) {
+            "saver" -> true
+            "auto" -> deviceIsSavingPower(context)
+            else -> false
+        }
+    }
+
+    fun deviceIsSavingPower(context: Context): Boolean {
+        if (context.getSystemService(PowerManager::class.java)?.isPowerSaveMode == true) return true
+        // ACTION_BATTERY_CHANGED is sticky: a null receiver reads it right now.
+        val battery = context.registerReceiver(null, IntentFilter(Intent.ACTION_BATTERY_CHANGED)) ?: return false
+        val level = battery.getIntExtra(BatteryManager.EXTRA_LEVEL, -1)
+        val scale = battery.getIntExtra(BatteryManager.EXTRA_SCALE, -1)
+        val pluggedIn = battery.getIntExtra(BatteryManager.EXTRA_PLUGGED, 0) != 0
+        return level >= 0 && scale > 0 && !pluggedIn && level * 100 < scale * 20
+    }
+
+    @Synchronized
+    fun updatePowerMode(context: Context, options: JSONObject?): JSONObject {
+        requireOwner(context, options)
+        val mode = requestedPowerMode(options, null)
+        if (!isActive(context)) throw CraftRecordingException("NO_ACTIVE_RECORDING", "No active location recording")
+        edit(context) { it.putString("powerMode", mode).remove("powerSaver") }
+        return state(context)
     }
 
     @Synchronized
@@ -138,7 +199,7 @@ object CraftLocationRecordingStore {
         val stopped = state(context, includeLocations = true)
         commit(context, false, false)
         listener = null
-        return stopped.put("active", false).put("paused", false)
+        return stopped.put("active", false).put("paused", false).put("effectivePowerMode", "default")
     }
     @Synchronized fun stop(context: Context) { finish(context, null) }
     @Synchronized
@@ -175,11 +236,21 @@ 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())
+                    start(context, id, System.currentTimeMillis(), requestedPowerMode(options, "default"))
                     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)
                 }
+                "setRecordingPowerMode" -> {
+                    val previous = powerMode(context)
+                    val updated = updatePowerMode(context, options)
+                    // The running service re-requests its updates for the new spacing.
+                    // If Android refuses to start it from the background, the stored
+                    // mode is still what the service takes up on its next start.
+                    runCatching { ContextCompat.startForegroundService(context, Intent(context, LocationRecordingService::class.java).setAction(LocationRecordingService.ACTION_START).putExtra("recordingId", recordingId(context))) }
+                        .onFailure { android.util.Log.w("CraftLocation", "Power mode $previous -> ${powerMode(context)} waits for the service", it) }
+                    updated
+                }
                 "pauseRecording" -> updatePause(context, true, options)
                 "resumeRecording" -> {
                     val permitted = ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED || ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_COARSE_LOCATION) == PackageManager.PERMISSION_GRANTED
@@ -270,6 +341,8 @@ object CraftLocationRecordingStore {
             put("paused", values.getBoolean("paused", false))
             put("startedAt", values.getLong("startedAt", 0).takeIf { it > 0 } ?: JSONObject.NULL)
             put("sampleCount", locations.length())
+            put("powerMode", powerMode(context))
+            put("effectivePowerMode", if (isPowerSaver(context)) "saver" else "default")
             if (includeLocations) put("locations", locations)
         }
     }
@@ -279,7 +352,9 @@ class LocationRecordingService : Service() {
     private val client by lazy { LocationServices.getFusedLocationProviderClient(this) }
     private var callback: LocationCallback? = null
     private var callbackRecordingId: String? = null
+    private var callbackSaver = false
     private var serviceStartId = 0
+    private var powerReceiver: BroadcastReceiver? = null
 
     override fun onCreate() {
         super.onCreate()
@@ -337,7 +412,13 @@ class LocationRecordingService : Service() {
 
     private fun startUpdates(): Boolean {
         val id = CraftLocationRecordingStore.recordingId(this) ?: return false
-        if (callback != null && callbackRecordingId == id) return true
+        // `auto` can change what the recorder should do without a call: the
+        // request is only rebuilt when the mode in use is not the one it was made for.
+        val saver = CraftLocationRecordingStore.isPowerSaver(this)
+        if (callback != null && callbackRecordingId == id && callbackSaver == saver) {
+            syncPowerReceiver()
+            return true
+        }
         stopUpdates()
         if (!CraftLocationRecordingStore.isActive(this)) return false
         val hasForegroundLocation =
@@ -347,9 +428,14 @@ class LocationRecordingService : Service() {
             runCatching { CraftLocationRecordingStore.finish(this, JSONObject().put("expectedId", id)) }
             return false
         }
+        // Saving power (an ultra): fixes at least 5 m apart and delivered in
+        // batches of up to 20 s, each keeping its own time. 5 m stays under
+        // the route's 30 s pause gap at any speed that counts as moving
+        // (0.2 m/s), so distance and moving time come out as at full rate.
         val request = LocationRequest.Builder(Priority.PRIORITY_HIGH_ACCURACY, 5_000)
             .setMinUpdateIntervalMillis(2_000)
-            .setMaxUpdateDelayMillis(10_000)
+            .setMaxUpdateDelayMillis(if (saver) 20_000 else 10_000)
+            .apply { if (saver) setMinUpdateDistanceMeters(5f) }
             .build()
         val nextCallback = object : LocationCallback() {
             override fun onLocationResult(result: LocationResult) {
@@ -358,6 +444,8 @@ class LocationRecordingService : Service() {
         }
         callback = nextCallback
         callbackRecordingId = id
+        callbackSaver = saver
+        syncPowerReceiver()
         return try {
             client.requestLocationUpdates(request, nextCallback, Looper.getMainLooper())
                 .addOnFailureListener {
@@ -382,6 +470,37 @@ class LocationRecordingService : Service() {
         callback?.let { client.removeLocationUpdates(it) }
         callback = null
         callbackRecordingId = null
+        callbackSaver = false
+        powerReceiver?.let { runCatching { unregisterReceiver(it) } }
+        powerReceiver = null
+    }
+
+    /**
+     * `powerMode: 'auto'` follows Battery Saver and the charge, so the service
+     * listens for the platform's changes while a recording runs in that mode,
+     * and for no other recording.
+     */
+    private fun syncPowerReceiver() {
+        val wanted = CraftLocationRecordingStore.powerMode(this) == "auto"
+        if (!wanted) {
+            powerReceiver?.let { runCatching { unregisterReceiver(it) } }
+            powerReceiver = null
+            return
+        }
+        if (powerReceiver != null) return
+        val receiver = object : BroadcastReceiver() {
+            override fun onReceive(context: Context?, intent: Intent?) {
+                synchronized(CraftLocationRecordingStore) {
+                    if (callback != null && CraftLocationRecordingStore.isPowerSaver(this@LocationRecordingService) != callbackSaver) startUpdates()
+                }
+            }
+        }
+        powerReceiver = receiver
+        val filter = IntentFilter().apply {
+            addAction(PowerManager.ACTION_POWER_SAVE_MODE_CHANGED)
+            addAction(Intent.ACTION_BATTERY_CHANGED)
+        }
+        ContextCompat.registerReceiver(this, receiver, filter, ContextCompat.RECEIVER_NOT_EXPORTED)
     }
 
     override fun onDestroy() {