craft-native 0.0.251 → 0.0.262

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

@@ -56,6 +56,7 @@ import java.time.LocalDateTime
 import java.time.Period
 import java.time.ZoneId
 import java.util.TreeMap
+import java.util.UUID
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.atomic.AtomicBoolean
 import java.util.concurrent.atomic.AtomicReference
@@ -89,10 +90,22 @@ internal class CraftNativeHealth(
     /** Ask for READ_HEALTH_DATA_IN_BACKGROUND / READ_HEALTH_DATA_HISTORY with the read types when the feature is available (the manifest declares them only when these are true). */
     private val backgroundReads: Boolean,
     private val historyReads: Boolean,
+    /** Lifecycle events are broadcast to native screens and the web host. */
+    private val workoutSink: ((JSONObject) -> Unit)? = null,
 ) {
     /** A read or write that did not happen: the bridge's error code and the message a page sees. */
     private class HealthFailure(val code: String, message: String) : Exception(message)
 
+    private data class LiveWorkout(
+        val id: String,
+        val type: String,
+        val start: Instant,
+        val location: String?,
+        var pausedAt: Instant? = null,
+        var pausedMillis: Long = 0,
+        var state: String = "running",
+    )
+
     private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
     private val mainHandler = Handler(Looper.getMainLooper())
     private val closed = AtomicBoolean(false)
@@ -108,6 +121,8 @@ internal class CraftNativeHealth(
     private var cachedClient: HealthConnectClient? = null
 
     private val ownOrigin = DataOrigin(context.packageName)
+    private val workoutLock = Any()
+    private val liveWorkout = AtomicReference<LiveWorkout?>(null)
 
     /** A native screen's call (`Health` in CraftNativeActions), by method and arguments as the bridge sends them. */
     fun perform(method: String, args: JSONArray, completion: (CraftNativeCapabilityResult) -> Unit) {
@@ -150,6 +165,10 @@ internal class CraftNativeHealth(
             "getSleepIntervals" -> answer(completion) { getSleepIntervals(options(0)) }
             "saveMindfulSession" -> answer(completion) { saveMindfulSession(options(0)) }
             "getMindfulSessions" -> answer(completion) { getMindfulSessions(options(0)) }
+            "startWorkout" -> answer(completion) { startWorkout(options(0)) }
+            "pauseWorkout" -> answer(completion) { pauseWorkout() }
+            "resumeWorkout" -> answer(completion) { resumeWorkout() }
+            "endWorkout" -> answer(completion) { endWorkout() }
             else -> deliver(completion, CraftNativeCapabilityResult(code = "UNKNOWN_ACTION", message = "Unsupported Health method: $method"))
         }
     }
@@ -165,6 +184,7 @@ internal class CraftNativeHealth(
 
     fun close() {
         closed.set(true)
+        liveWorkout.getAndSet(null)?.let { emitWorkoutState(it, "stopped") }
         pendingPermission.getAndSet(null)?.cancel()
         scope.cancel()
     }
@@ -213,6 +233,101 @@ internal class CraftNativeHealth(
 
     private fun invalid(message: String) = HealthFailure("INVALID_ARGUMENT", message)
 
+    // MARK: - Live workout lifecycle
+
+    /**
+     * Android Health Connect stores the finished ExerciseSessionRecord. The
+     * lifecycle is kept in the foreground host until the Health Services
+     * foreground-session adapter is available; no post-hoc save is implied by
+     * this API, and every transition is still observable by the page.
+     */
+    private suspend fun startWorkout(body: JSONObject): Any {
+        val type = body.optString("type").takeIf { it.isNotBlank() }
+            ?: throw invalid("startWorkout needs a workout type")
+        if (EXERCISE_TYPES[type] == null) throw invalid("Unsupported workout type: $type")
+        if (activityProvider() == null) throw HealthFailure("NEEDS_ACTIVITY", "Live workouts require a foreground activity")
+        val now = Instant.now()
+        val workout = synchronized(workoutLock) {
+            if (liveWorkout.get() != null) throw HealthFailure("BUSY", "A live workout is already running")
+            LiveWorkout("live-${UUID.randomUUID()}", type, now, body.optString("location").takeIf { it.isNotBlank() }).also(liveWorkout::set)
+        }
+        emitWorkoutState(workout, "running", now)
+        return JSONObject()
+            .put("id", workout.id)
+            .put("type", workout.type)
+            .put("startDate", workout.start.ms())
+    }
+
+    private suspend fun pauseWorkout(): Any {
+        val now = Instant.now()
+        val workout = synchronized(workoutLock) {
+            val current = liveWorkout.get() ?: throw HealthFailure("NO_WORKOUT", "No live workout is running")
+            if (current.state != "running") throw HealthFailure("INVALID_STATE", "The live workout is not running")
+            current.pausedAt = now
+            current.state = "paused"
+            current
+        }
+        emitWorkoutState(workout, "paused", now)
+        return true
+    }
+
+    private suspend fun resumeWorkout(): Any {
+        val now = Instant.now()
+        val workout = synchronized(workoutLock) {
+            val current = liveWorkout.get() ?: throw HealthFailure("NO_WORKOUT", "No live workout is running")
+            val pausedAt = current.pausedAt ?: throw HealthFailure("INVALID_STATE", "The live workout is not paused")
+            current.pausedMillis += Duration.between(pausedAt, now).toMillis().coerceAtLeast(0)
+            current.pausedAt = null
+            current.state = "running"
+            current
+        }
+        emitWorkoutState(workout, "running", now)
+        return true
+    }
+
+    private suspend fun endWorkout(): Any {
+        val now = Instant.now()
+        val workout = synchronized(workoutLock) {
+            val current = liveWorkout.getAndSet(null) ?: throw HealthFailure("NO_WORKOUT", "No live workout is running")
+            current.pausedAt?.let { current.pausedMillis += Duration.between(it, now).toMillis().coerceAtLeast(0) }
+            current.pausedAt = null
+            current.state = "ended"
+            current
+        }
+        val body = JSONObject()
+            .put("activityId", workout.id)
+            .put("type", workout.type)
+            .put("startDate", workout.start.ms())
+            .put("endDate", now.ms())
+        val saved = try {
+            saveWorkout(body) as JSONObject
+        } catch (error: CancellationException) {
+            throw error
+        } catch (error: Throwable) {
+            emitWorkoutError(workout, error.message ?: "Live workout could not be saved")
+            throw error
+        }
+        val duration = (Duration.between(workout.start, now).toMillis() - workout.pausedMillis).coerceAtLeast(0) / 1000.0
+        emitWorkoutState(workout, "ended", now)
+        return JSONObject()
+            .put("id", workout.id)
+            .put("workoutId", saved.optString("id", workout.id))
+            .put("endDate", now.ms())
+            .put("durationSeconds", duration)
+    }
+
+    private fun emitWorkoutState(workout: LiveWorkout, state: String, date: Instant = Instant.now()) {
+        mainHandler.post {
+            workoutSink?.invoke(JSONObject().put("id", workout.id).put("event", "state").put("state", state).put("date", date.ms()))
+        }
+    }
+
+    private fun emitWorkoutError(workout: LiveWorkout, message: String) {
+        mainHandler.post {
+            workoutSink?.invoke(JSONObject().put("id", workout.id).put("event", "error").put("message", message))
+        }
+    }
+
     // MARK: - Health Connect itself
 
     private fun sdkStatus(): Int = HealthConnectClient.getSdkStatus(context, PROVIDER_PACKAGE)

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

@@ -15,6 +15,7 @@ internal class CraftNativeHealth(
     @Suppress("UNUSED_PARAMETER") activityProvider: () -> Activity?,
     @Suppress("UNUSED_PARAMETER") backgroundReads: Boolean,
     @Suppress("UNUSED_PARAMETER") historyReads: Boolean,
+    @Suppress("UNUSED_PARAMETER") workoutSink: ((org.json.JSONObject) -> Unit)? = null,
 ) {
     fun perform(method: String, args: JSONArray, completion: (CraftNativeCapabilityResult) -> Unit) {
         completion(CraftNativeCapabilityResult(code = "CAPABILITY_DISABLED", message = "Health Connect is not enabled for this app ($method, ${args.length()} arguments)"))

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

@@ -413,7 +413,6 @@ private class CraftNativeMapView(context: Context) : FrameLayout(context), OnMap
         markers.values.forEach { builder.include(it.position); count++ }
         polylines.values.flatMap { it.points }.forEach { builder.include(it); count++ }
         polygons.values.flatMap { it.points }.forEach { builder.include(it); count++ }
-        polygons.values.flatMap { it.points }.forEach { builder.include(it); count++ }
         if (count == 0) return false
         post {
             if (width > 0 && height > 0) {

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

@@ -30,6 +30,7 @@ import java.io.File
 import java.util.Locale
 import java.util.UUID
 {{NATIVE_PUSH_IMPORTS}}
+{{NATIVE_WALLET_IMPORTS}}
 
 private fun craftLocationFix(location: android.location.Location): JSONObject = JSONObject()
     .put("latitude", location.latitude)
@@ -61,7 +62,16 @@ internal class CraftNativeServices(
     private val main = Handler(Looper.getMainLooper())
     private val heartRateEnabled = config.optBoolean("enableHeartRate")
     private val health: CraftNativeHealth? = if (config.optBoolean("enableHealthConnect")) {
-        CraftNativeHealth(context, activity, config.optBoolean("enableHealthConnectBackground"), config.optBoolean("enableHealthConnectHistory"))
+        CraftNativeHealth(context, activity, config.optBoolean("enableHealthConnectBackground"), config.optBoolean("enableHealthConnectHistory")) { detail ->
+            CraftNativeHub.broadcast("CRAFT_EVENT", JSONObject().put("event", "craftHealthWorkout").put("detail", detail))
+        }
+    } else null
+    private val healthServices: CraftHealthServices? = if (config.optBoolean("enableHealthServices")) {
+        CraftHealthServices(context, activity, health?.let { healthApi ->
+            { method: String, args: JSONArray, completion: (CraftNativeCapabilityResult) -> Unit ->
+                healthApi.perform(method, args, completion)
+            }
+        })
     } else null
     private var pendingPushPermission: ((CraftNativeCapabilityResult) -> Unit)? = null
     private var pendingBrowser: Pair<String?, (CraftNativeCapabilityResult) -> Unit>? = null
@@ -70,6 +80,7 @@ internal class CraftNativeServices(
     private var speechReady = false
     private val speechQueue = mutableListOf<() -> Unit>()
     private val speeches = mutableMapOf<String, (CraftNativeCapabilityResult) -> Unit>()
+{{NATIVE_WALLET_FIELDS}}
 
     init {
         if (config.optBoolean("enableGeolocation") || config.optBoolean("enableBackgroundLocation")) {
@@ -106,13 +117,14 @@ internal class CraftNativeServices(
         add("media")
         if (config.optBoolean("enableShare")) add("share")
         if (config.optBoolean("enablePushNotifications")) add("push")
-        if (health != null) {
+        if (health != null || healthServices != null) {
             add("health")
             // Health Connect may need installing or updating, and its grants
             // are managed in its own screen: `health.availability()`,
             // `health.grantedTypes()` and `health.openSettings()`.
             add("healthAvailability")
         }
+        if (healthServices != null) add("healthServices")
         if (config.optBoolean("enableWallet")) add("wallet")
         if (config.optBoolean("enableKeepAwake")) add("keepAwake")
         if (config.optBoolean("enableGeolocation") || config.optBoolean("enableBackgroundLocation")) {
@@ -145,7 +157,9 @@ internal class CraftNativeServices(
                 "Linking" -> linking(method, args.optString(0), done)
                 "Share" -> share(args.optJSONObject(0) ?: JSONObject(), done)
                 "Push" -> push(method, done)
-                "Health" -> health?.perform(method, args, done) ?: done(failure("CAPABILITY_DISABLED", "Health Connect is not enabled for this app"))
+                "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"))
                 "Wallet" -> wallet(method, args, done)
                 "KeepAwake" -> keepAwake(args.optBoolean(0, true), done)
                 "Brightness" -> brightness(method, args, done)
@@ -182,11 +196,17 @@ internal class CraftNativeServices(
     private fun wallet(method: String, args: JSONArray, done: (CraftNativeCapabilityResult) -> Unit) {
         if (!config.optBoolean("enableWallet")) return done(failure("CAPABILITY_DISABLED", "Wallet is disabled"))
         when (method) {
-            "isAvailable" -> done(success(runCatching {
-                context.packageManager.getLaunchIntentForPackage("com.google.android.apps.walletnfcrel") != null
-            }.getOrDefault(false)))
+            "isAvailable" -> {
+{{NATIVE_WALLET_AVAILABILITY}}
+            }
             "add" -> {
                 val source = args.optJSONObject(0) ?: return done(failure("INVALID_ARGUMENT", "Wallet.add needs a source object"))
+                val jwt = source.optString("jwt").trim()
+                if (jwt.isNotEmpty()) {
+                    val host = activity() ?: return done(failure("NEEDS_ACTIVITY", "No screen is showing to open Wallet"))
+{{NATIVE_WALLET_JWT_ADD}}
+                    return
+                }
                 val address = source.optString("url").trim()
                 if (!address.startsWith("https://")) return done(failure("INVALID_ARGUMENT", "Android Wallet.add needs an HTTPS save URL"))
                 val host = activity() ?: return done(failure("NEEDS_ACTIVITY", "No screen is showing to open Wallet"))
@@ -200,6 +220,7 @@ internal class CraftNativeServices(
             else -> done(failure("UNKNOWN_ACTION", "Unsupported Wallet method"))
         }
     }
+{{NATIVE_WALLET_HELPER}}
 
     // MARK: Dialogs
 
@@ -542,8 +563,10 @@ internal class CraftNativeServices(
 
     // MARK: Health Connect
 
-    fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?): Boolean =
-        health?.onActivityResult(requestCode, resultCode, data) == true
+    fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?): Boolean {
+{{NATIVE_WALLET_RESULT}}
+        return health?.onActivityResult(requestCode, resultCode, data) == true
+    }
 
     // MARK: The screen
 

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

@@ -21,6 +21,9 @@ import android.widget.FrameLayout
 import android.widget.ImageView
 import android.widget.LinearLayout
 import android.widget.TextView
+import androidx.core.view.AccessibilityDelegateCompat
+import androidx.core.view.ViewCompat
+import androidx.core.view.accessibility.AccessibilityNodeInfoCompat
 import androidx.core.content.ContextCompat
 import androidx.security.crypto.EncryptedSharedPreferences
 import androidx.security.crypto.MasterKey
@@ -838,7 +841,17 @@ internal class CraftNativeChrome(context: Context, private val tabs: List<CraftN
             cell.background = rippleBackground()
             cell.contentDescription = tab.title
             cell.tag = "craft-tab-${tab.id}"
+            cell.importantForAccessibility = View.IMPORTANT_FOR_ACCESSIBILITY_YES
+            ViewCompat.setAccessibilityDelegate(cell, object : AccessibilityDelegateCompat() {
+                override fun onInitializeAccessibilityNodeInfo(host: View, info: AccessibilityNodeInfoCompat) {
+                    super.onInitializeAccessibilityNodeInfo(host, info)
+                    info.viewIdResourceName = "craft-tab-${tab.id}"
+                    info.className = android.widget.Button::class.java.name
+                    info.isSelected = host.isSelected
+                }
+            })
             val icon = TextView(context)
+            icon.importantForAccessibility = View.IMPORTANT_FOR_ACCESSIBILITY_NO
             icon.text = CraftNativeSymbols.glyph(tab.symbol)
             icon.textSize = 22f
             icon.minWidth = dp(26)
@@ -846,6 +859,7 @@ internal class CraftNativeChrome(context: Context, private val tabs: List<CraftN
             icon.gravity = Gravity.CENTER
             icon.includeFontPadding = false
             val label = TextView(context)
+            label.importantForAccessibility = View.IMPORTANT_FOR_ACCESSIBILITY_NO
             label.text = tab.title
             label.textSize = 12f
             label.fontFeatureSettings = "tnum"
@@ -893,6 +907,11 @@ internal class CraftNativeChrome(context: Context, private val tabs: List<CraftN
                 if (kotlin.math.abs(dx) > swipeSlop && kotlin.math.abs(dx) > kotlin.math.abs(dy)) {
                     swipeTracking = false
                     swipeIntercepted = onTabSwipeStart?.invoke(dx, event.x, event.y) == true
+                    // Android cancels the child's touch target for this move;
+                    // it does not replay the move through our onTouchEvent.
+                    // Apply it now so a paused or coalesced drag still previews
+                    // the incoming tab before another input event arrives.
+                    if (swipeIntercepted) onTabSwipeMove?.invoke(dx)
                     return swipeIntercepted
                 }
             }
@@ -1234,6 +1253,7 @@ internal object CraftNativeSymbols {
  * transfer finishes on its own; the next keep answers from the copy.
  */
 internal object CraftNativeMedia {
+    const val ATTEMPT_SETTLED = "craft.media.attemptSettled"
     private const val TAG = "craft-media"
     private const val PREFS = "craft.media"
     private val lock = Any()
@@ -1301,7 +1321,7 @@ internal object CraftNativeMedia {
             try {
                 if (generation(app) == started) {
                     val pending = work.getWorkInfosForUniqueWork(name).get().any {
-                        "$TAG:generation:$started" in it.tags &&
+                        "$TAG:generation:$started" in it.tags && !it.progress.getBoolean(ATTEMPT_SETTLED, false) &&
                             (it.state == androidx.work.WorkInfo.State.RUNNING ||
                                 (it.state == androidx.work.WorkInfo.State.ENQUEUED && it.runAttemptCount == 0))
                     }
@@ -1349,12 +1369,22 @@ internal object CraftNativeMedia {
      * file where it stopped, moves it into place whole, and answers whoever
      * waits. RETRY leaves the part file for the next attempt.
      */
-    fun transfer(context: Context, address: String, headers: JSONObject, started: Int, attempt: Int, stopped: () -> Boolean): Outcome {
+    fun transfer(context: Context, address: String, headers: JSONObject, started: Int, attempt: Int, beforeAnswer: () -> Unit = {}, stopped: () -> Boolean): Outcome {
+        fun answer(result: CraftNativeCapabilityResult) {
+            // The callback can immediately call keep again. Publish completion
+            // before that callback, while WorkManager may still say RUNNING.
+            synchronized(lock) {
+                // A keep registered after this marker belongs to the next
+                // attempt; it must not enter the old callback batch.
+                beforeAnswer()
+                deliver(context, address, started, result)
+            }
+        }
         // clear() already answered the old generation's waiters. Never answer
         // a new athlete's waiters from an obsolete worker for the same URL.
         if (generation(context) != started) return Outcome.DONE
         local(context, address)?.let {
-            deliver(context, address, started, CraftNativeCapabilityResult(data = describe(address, it)))
+            answer(CraftNativeCapabilityResult(data = describe(address, it)))
             return Outcome.DONE
         }
         val writer = writers.getOrPut(address) { Any() }
@@ -1364,7 +1394,7 @@ internal object CraftNativeMedia {
             if (generation(context) != started) return Outcome.DONE
             if (stopped()) return Outcome.RETRY
             local(context, address)?.let {
-                deliver(context, address, started, CraftNativeCapabilityResult(data = describe(address, it)))
+                answer(CraftNativeCapabilityResult(data = describe(address, it)))
                 return Outcome.DONE
             }
             val target = file(context, address)
@@ -1383,22 +1413,22 @@ internal object CraftNativeMedia {
                 }
                 if (full) {
                     staging.delete()
-                    deliver(context, address, started, CraftNativeCapabilityResult(code = "NO_SPACE", message = error.message ?: "The phone is out of space"))
+                    answer(CraftNativeCapabilityResult(code = "NO_SPACE", message = error.message ?: "The phone is out of space"))
                     return Outcome.DONE
                 }
                 if (stopped()) return Outcome.RETRY
                 // Lost the connection part way: the part waits for the next attempt.
-                deliver(context, address, started, if (!online(context)) queued(address, "offline") else CraftNativeCapabilityResult(code = if (error is java.net.SocketTimeoutException) "TIMEOUT" else "NETWORK_ERROR", message = error.message ?: "media.keep failed"))
+                answer(if (!online(context)) queued(address, "offline") else CraftNativeCapabilityResult(code = if (error is java.net.SocketTimeoutException) "TIMEOUT" else "NETWORK_ERROR", message = error.message ?: "media.keep failed"))
                 return if (attempt < 8) Outcome.RETRY else Outcome.DONE.also { staging.delete() }
             }
             when (fetched) {
                 is CraftResumableDownload.Fetched.Stopped, is CraftResumableDownload.Fetched.Restart -> return Outcome.RETRY
                 is CraftResumableDownload.Fetched.Refused -> {
-                    deliver(context, address, started, CraftNativeCapabilityResult(data = JSONObject().put("ok", false).put("url", address).put("status", fetched.status)))
+                    answer(CraftNativeCapabilityResult(data = JSONObject().put("ok", false).put("url", address).put("status", fetched.status)))
                     return Outcome.DONE
                 }
                 is CraftResumableDownload.Fetched.Incomplete -> {
-                    deliver(context, address, started, CraftNativeCapabilityResult(code = "NETWORK_ERROR", message = "media.keep received an incomplete file"))
+                    answer(CraftNativeCapabilityResult(code = "NETWORK_ERROR", message = "media.keep received an incomplete file"))
                     return if (attempt < 8) Outcome.RETRY else Outcome.DONE.also { staging.delete() }
                 }
                 is CraftResumableDownload.Fetched.Complete -> Unit
@@ -1410,11 +1440,11 @@ internal object CraftNativeMedia {
                 }
                 target.delete()
                 if (!staging.renameTo(target)) {
-                    deliver(context, address, started, CraftNativeCapabilityResult(code = "IO_ERROR", message = "media.keep could not store the file"))
+                    answer(CraftNativeCapabilityResult(code = "IO_ERROR", message = "media.keep could not store the file"))
                     return Outcome.DONE
                 }
             }
-            deliver(context, address, started, CraftNativeCapabilityResult(data = describe(address, target)))
+            answer(CraftNativeCapabilityResult(data = describe(address, target)))
             return Outcome.DONE
         }
     }
@@ -1432,13 +1462,13 @@ internal object CraftNativeMedia {
         capabilities?.hasCapability(android.net.NetworkCapabilities.NET_CAPABILITY_INTERNET) == true
     }.getOrDefault(true)
 
-    /** Removes every copy whose address is not in `keep`, and stops their transfers; answers how many files went. */
+    /** Removes idle copies outside `keep` and cancels their jobs; pending keeps retain ownership. */
     fun prune(context: Context, keep: List<String>): Int {
         val wanted = keep.map { digest(it) }.toSet()
         var removed = 0
-        // A keep still waiting owns its address's files and its transfer until it is answered.
-        val active = synchronized(lock) { waiting.keys.map { digest(it) }.toSet() }
         synchronized(lock) {
+            // A keep still waiting owns its files until it is answered.
+            val active = waiting.keys.map { digest(it) }.toSet()
             root(context).listFiles()?.forEach { file ->
                 val owner = file.name.substringBefore('.')
                 // Part files from before transfers resumed (`<sha>.<ext>.<id>.part`) are never picked up again.
@@ -1451,8 +1481,16 @@ internal object CraftNativeMedia {
             runCatching {
                 androidx.work.WorkManager.getInstance(app).getWorkInfosByTag(TAG).get()
                     .filter { !it.state.isFinished }
-                    .filter { info -> info.tags.none { it.startsWith("$TAG:") && it.removePrefix("$TAG:").let { owner -> owner in wanted || owner in active } } }
-                    .forEach { androidx.work.WorkManager.getInstance(app).cancelWorkById(it.id) }
+                    .forEach { info ->
+                        synchronized(lock) {
+                            // The query runs asynchronously: a new keep may now
+                            // own an address that was idle when prune was called.
+                            val active = waiting.keys.map { digest(it) }.toSet()
+                            if (info.tags.none { it.startsWith("$TAG:") && it.removePrefix("$TAG:") in wanted + active }) {
+                                androidx.work.WorkManager.getInstance(app).cancelWorkById(info.id)
+                            }
+                        }
+                    }
             }
         }
         return removed
@@ -1470,9 +1508,10 @@ internal object CraftNativeMedia {
             root(context).listFiles()?.forEach { file ->
                 if (file.delete()) removed++ else failure = java.io.IOException("The video cache could not be cleared")
             }
+            // Schedule cancellation before a new generation can enqueue its work.
+            androidx.work.WorkManager.getInstance(context.applicationContext).cancelAllWorkByTag(TAG)
             callbacks
         }
-        androidx.work.WorkManager.getInstance(context.applicationContext).cancelAllWorkByTag(TAG)
         main.post { answered.forEach { it.answer(CraftNativeCapabilityResult(code = "CANCELLED", message = "The video cache was cleared")) } }
         failure?.let { throw it }
         return removed
@@ -1511,12 +1550,10 @@ internal class CraftResumableDownload(
         if (have > 0) connection.setRequestProperty("Range", "bytes=$have-")
         try {
             val status = connection.responseCode
-            // Part of a file nobody asked a part of: not something to keep.
-            if (status == 206 && have == 0L) return Fetched.Refused(status)
             val resumed = status == 206 && have > 0 && rangeStart(connection.getHeaderField("Content-Range")) == have
             if (status == 416 || (status == 206 && !resumed)) {
                 part.delete()
-                return Fetched.Restart
+                return if (have > 0) Fetched.Restart else Fetched.Refused(status)
             }
             if (status != 200 && !resumed) {
                 part.delete()
@@ -1539,8 +1576,8 @@ internal class CraftResumableDownload(
             // HttpURLConnection inflates gzip itself; a Content-Length is then the compressed size.
             val encoded = connection.getHeaderField("Content-Encoding") != null
             if (size <= 0 || (!encoded && total >= 0 && size != total)) {
-                // Longer than the file says it is: nothing to resume from.
-                if (total in 0 until size) part.delete()
+                // Empty or longer than the file says: nothing useful to resume.
+                if (size <= 0 || total in 0 until size) part.delete()
                 return Fetched.Incomplete
             }
             return Fetched.Complete(size)
@@ -1563,8 +1600,21 @@ internal class CraftNativeMediaWorker(context: Context, parameters: androidx.wor
     override fun doWork(): Result {
         val address = inputData.getString("address") ?: return Result.failure()
         val headers = runCatching { JSONObject(inputData.getString("headers") ?: "{}") }.getOrDefault(JSONObject())
-        val outcome = CraftNativeMedia.transfer(applicationContext, address, headers, inputData.getInt("generation", 0), runAttemptCount) { isStopped }
-        return if (outcome == CraftNativeMedia.Outcome.RETRY) Result.retry() else Result.success()
+        val started = inputData.getInt("generation", 0)
+        return try {
+            setProgressAsync(androidx.work.workDataOf(CraftNativeMedia.ATTEMPT_SETTLED to false)).get()
+            val outcome = CraftNativeMedia.transfer(applicationContext, address, headers, started, runAttemptCount,
+                beforeAnswer = { setProgressAsync(androidx.work.workDataOf(CraftNativeMedia.ATTEMPT_SETTLED to true)).get() }
+            ) { isStopped }
+            if (outcome == CraftNativeMedia.Outcome.RETRY) Result.retry() else Result.success()
+        } catch (error: Exception) {
+            if (error is InterruptedException) Thread.currentThread().interrupt()
+            // A replacement owns the address's new waiters. A real progress
+            // storage failure still needs an answer instead of a lost callback.
+            if (!isStopped) CraftNativeMedia.deliver(applicationContext, address, started,
+                CraftNativeCapabilityResult(code = "IO_ERROR", message = error.message ?: "media.keep could not store worker progress"))
+            if (isStopped) Result.retry() else Result.failure()
+        }
     }
 }