Sleep and nap edits, and workouts first release

app/src/main/AndroidManifest.xml

@@ -5,6 +5,8 @@
     <!-- INTERNET is used only for Zepp sign-in (device list), strap firmware checks and downloads, map tiles, and the
          daily check for a new OpenStrap on GitHub and its download. Health data is never uploaded. -->
     <uses-permission android:name="android.permission.INTERNET" />
+    <!-- Saving a share card to the gallery: Android 10 and later need no permission for the app's own pictures. -->
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" android:maxSdkVersion="28" />
     <!-- Installing a new OpenStrap downloaded from its GitHub releases (update/AppUpdater.kt). Android asks the user to
          allow it the first time. -->
     <uses-permission android:name="android.permission.REQUEST_INSTALL_PACKAGES" />
@@ -230,6 +232,16 @@
                 android:name="android.service.notification.disabled_filter_types"
                 android:value="ongoing|silent" />
         </service>
+        <!-- A workout's share card, handed to another app from the cache (ui/glow/ShareScreen.kt). -->
+        <provider
+            android:name="androidx.core.content.FileProvider"
+            android:authorities="${applicationId}.share"
+            android:exported="false"
+            android:grantUriPermissions="true">
+            <meta-data
+                android:name="android.support.FILE_PROVIDER_PATHS"
+                android:resource="@xml/share_paths" />
+        </provider>
         <!-- WorkManager starts from OpenStrapApp's configuration, so Glance renders off the main thread
              (widget/WidgetWork.kt), not from its own startup initializer. -->
         <provider

app/src/main/kotlin/org/openstrap/app/OpenStrapApp.kt

@@ -3,6 +3,7 @@ package org.openstrap.app
 import android.Manifest
 import android.app.Application
 import android.content.pm.PackageManager
+import kotlinx.coroutines.launch
 import org.openstrap.app.ble.BleScanner
 import org.openstrap.app.data.HealthRepository
 import org.openstrap.app.data.db.OpenStrapDatabase
@@ -19,6 +20,9 @@ class AppContainer(val app: Application) {
     val database = OpenStrapDatabase.create(app)
     val settings = SettingsStore(app)
     val health = HealthRepository(database.healthDao())
+    /** The max heart rate every zone goes by: `maxHeartRates.current` to follow it, `maxHeartRates.now()` to read it once. */
+    val maxHeartRates = org.openstrap.app.data.MaxHeartRates(database.healthDao(), settings.profile)
+    val rewards = org.openstrap.app.data.RewardsKeeper(database.healthDao(), settings, maxHeartRates)
     val scanner = BleScanner(app)
     val csv = CsvExporter(database.healthDao())
     val healthConnect = HealthConnectExporter(app, database.healthDao())
@@ -27,7 +31,7 @@ class AppContainer(val app: Application) {
     val phoneAlerts = PhoneAlerts(app, settings, strap)
     val autoHealthConnect = org.openstrap.app.health.HealthConnectAutoSync(app, settings, healthConnect, strap)
     val workout = org.openstrap.app.device.WorkoutSession(
-        app, database.healthDao(), settings, strap, callRinging = { phoneAlerts.callRinging }, onSaved = autoHealthConnect::workoutSaved,
+        app, database.healthDao(), settings, strap, maxHeartRates, callRinging = { phoneAlerts.callRinging }, onSaved = autoHealthConnect::workoutSaved,
     )
     val updater = org.openstrap.app.update.AppUpdater(app, settings, recording = { workout.state.value is org.openstrap.app.device.WorkoutState.Recording })
 }
@@ -43,6 +47,10 @@ class OpenStrapApp : Application(), androidx.work.Configuration.Provider {
     override fun onCreate() {
         super.onCreate()
         container = AppContainer(this)
+        // Your heart rate zones, kept in use for everything that reads a zone, a restored backup's included.
+        kotlinx.coroutines.CoroutineScope(kotlinx.coroutines.SupervisorJob() + kotlinx.coroutines.Dispatchers.Default).launch {
+            container.settings.heartZones.collect { org.openstrap.app.data.HeartZones.use(it) }
+        }
         container.companion.refresh()
         // A workout still recording when the process died carries on (the service restarts it too).
         container.workout.restore()
@@ -55,5 +63,7 @@ class OpenStrapApp : Application(), androidx.work.Configuration.Provider {
         org.openstrap.app.device.WidgetUpdater.publishPreviews(this)
         // The daily check for a new OpenStrap, unless it was turned off on the Updates page.
         container.updater.start()
+        // Looks for the first morning of the week, for the weekly recap (workouts spec 3.4).
+        org.openstrap.app.device.WeeklyRecap.schedule(this)
     }
 }

app/src/main/kotlin/org/openstrap/app/data/Activity.kt

@@ -1,6 +1,5 @@
 package org.openstrap.app.data
 
-import kotlin.math.abs
 
 /**
  * Steps, distance and moderate-to-vigorous activity (docs/algorithms/evidence-review.md, "Energy and activity").
@@ -23,8 +22,6 @@ object Activity {
     const val HR_RUN_MINUTES = 10
     /** WHO 2020: 150 min of moderate a week, a vigorous minute counting double. */
     const val MVPA_WEEKLY_TARGET = 150
-    /** Flag a divergence between the strap's daily counter and the summed minutes above this fraction. */
-    const val STEP_DIVERGENCE = 0.05f
 
     data class Mvpa(
         val moderateMinutes: Int,
@@ -74,13 +71,6 @@ object Activity {
         return Mvpa(moderate, vigorous, fromHr)
     }
 
-    /** True when the strap's daily counter and the summed minutes differ by more than [STEP_DIVERGENCE]. */
-    fun stepsDiverge(strapTotal: Int?, minuteSum: Int): Boolean {
-        if (strapTotal == null || strapTotal <= 0 && minuteSum <= 0) return false
-        val ref = maxOf(strapTotal, minuteSum).toFloat()
-        return abs(strapTotal - minuteSum) / ref > STEP_DIVERGENCE
-    }
-
     /**
      * Step length in metres for a minute at [cadence] steps/min and height [heightCm]: 0.414·H below 120 spm, rising
      * linearly to 0.45·H at 130 and above. An estimate; distance is always shown with "≈".

app/src/main/kotlin/org/openstrap/app/data/Coaching.kt

@@ -1,15 +1,15 @@
 package org.openstrap.app.data
 
 /**
- * What a workout aims for, chosen on the ready screen: a zone or a range of zones (0..4, inclusive), a time, or active
- * kcal. Stored on the workout as [code] ("z:1-2", "t:2700", "k:300").
+ * What a workout aims for, chosen on the ready screen: a zone or a range of zones (0..4, inclusive), a time, active
+ * kcal or a distance. Stored on the workout as [code] ("z:1-2", "t:2700", "k:300", "d:5000").
  */
 sealed interface WorkoutTarget {
     val code: String
 
     data class Zones(val low: Int, val high: Int) : WorkoutTarget {
         override val code get() = "z:$low-$high"
-        val label: String get() = if (low == high) "Zone ${low + 1}" else "Zone ${low + 1}–${high + 1}"
+        val label: String get() = if (low == high) "Zone ${low + 1}" else "Zone ${low + 1} to ${high + 1}"
     }
 
     data class Time(val seconds: Long) : WorkoutTarget {
@@ -23,6 +23,17 @@ sealed interface WorkoutTarget {
         val label: String get() = "$kcal kcal"
     }
 
+    /** Metres: from GPS, or the strap's steps without it, as the workout counts its distance. */
+    data class Distance(val meters: Int) : WorkoutTarget {
+        override val code get() = "d:$meters"
+        /** "5 km", "21.1 km", "800 m". */
+        val label: String get() = when {
+            meters < 1000 -> "$meters m"
+            meters % 1000 == 0 -> "${meters / 1000} km"
+            else -> String.format(java.util.Locale.ROOT, "%.1f km", meters / 1000f)
+        }
+    }
+
     companion object {
         fun parse(code: String?): WorkoutTarget? {
             code ?: return null
@@ -31,6 +42,7 @@ sealed interface WorkoutTarget {
                 "z" -> v.split('-').mapNotNull { it.toIntOrNull() }.takeIf { it.size == 2 }?.let { (a, b) -> Zones(a, b) }
                 "t" -> v.toLongOrNull()?.let(::Time)
                 "k" -> v.toIntOrNull()?.takeIf { it > 0 }?.let(::Kcal)
+                "d" -> v.toIntOrNull()?.takeIf { it > 0 }?.let(::Distance)
                 else -> null
             }
         }
@@ -53,12 +65,12 @@ enum class Cue(val pattern: List<Int>) {
     BelowTarget(listOf(700)),
     /** Back in the target: one short pulse. */
     BackInTarget(listOf(200)),
-    /** Halfway through a time target: two short pulses. */
-    Halfway(listOf(150, 150, 150)),
-    /** Time or kcal target reached: long, short, long. */
-    GoalReached(listOf(500, 200, 200, 200, 500)),
-    /** Strength: rest is over, start the next set. Two medium pulses. */
-    RestOver(listOf(400, 150, 400)),
+    /** Halfway through a time or distance goal: one long ([WorkoutBuzz.LONG]). */
+    Halfway(WorkoutBuzz.LONG),
+    /** A time, distance or kcal goal reached: three short ([WorkoutBuzz.GOAL]). */
+    GoalReached(WorkoutBuzz.GOAL),
+    /** Strength: rest is over, start the next set. Two short, as work starting is everywhere ([WorkoutBuzz.WORK_STARTS]). */
+    RestOver(WorkoutBuzz.WORK_STARTS),
 }
 
 /**
@@ -88,7 +100,7 @@ class Coach(private val target: WorkoutTarget?, reachedAt: Long? = null) {
             else -> null
         }
         is WorkoutTarget.Zones -> zone?.let { zoneCue(t, it, target) }
-        is WorkoutTarget.Kcal, null -> null
+        is WorkoutTarget.Kcal, is WorkoutTarget.Distance, null -> null
     }
 
     /**
@@ -102,6 +114,19 @@ class Coach(private val target: WorkoutTarget?, reachedAt: Long? = null) {
         return Cue.GoalReached
     }
 
+    /**
+     * The distance so far, [meters] at [t]: the halfway cue, then the goal cue the first time it reaches a distance
+     * target, each once. Distance only grows, so a pause holds it where it is.
+     */
+    fun distance(t: Long, meters: Float): Cue? {
+        if (target !is WorkoutTarget.Distance || goalDone) return null
+        return when {
+            meters >= target.meters -> { goalDone = true; halfwayDone = true; reachedAt = t; Cue.GoalReached }
+            !halfwayDone && meters * 2 >= target.meters -> { halfwayDone = true; Cue.Halfway }
+            else -> null
+        }
+    }
+
     private fun zoneCue(t: Long, zone: Int, target: WorkoutTarget.Zones): Cue? {
         val side = when { zone > target.high -> 1; zone < target.low -> -1; else -> 0 }
         if (side != pendingSide) { pendingSide = side; pendingSince = t; return null }

app/src/main/kotlin/org/openstrap/app/data/Games.kt

@@ -0,0 +1,43 @@
+package org.openstrap.app.data
+
+/**
+ * Games and sports played with the phone in a bag (workouts spec 2.7): how hard it has been, from the time in each
+ * zone, and the hard efforts in it. Pure, like [Strength].
+ */
+object Games {
+    /** A spell in zone 5 counts as a hard effort from this long. */
+    const val HARD_EFFORT_S = 10L
+
+    /**
+     * Effort 1 to 5 from [zoneSeconds], the seconds in each zone so far: the time-weighted average zone, rounded, at
+     * least 1. Null with no time in any zone yet.
+     */
+    fun effort(zoneSeconds: IntArray): Int? {
+        val total = zoneSeconds.sum()
+        if (total <= 0) return null
+        val mean = zoneSeconds.withIndex().sumOf { (z, s) -> (z + 1) * s.toDouble() } / total
+        return Math.round(mean).toInt().coerceIn(1, Workouts.ZONES)
+    }
+
+    /**
+     * Spells of at least [HARD_EFFORT_S] in zone 5 in [readings] (time, bpm, ascending): one effort per spell, however
+     * long. A gap of more than a few seconds between readings ends a spell.
+     */
+    fun hardEfforts(readings: List<Pair<Long, Int>>, maxHr: Int): Int {
+        var count = 0
+        var since: Long? = null
+        var last: Long? = null
+        var counted = false
+        for ((t, bpm) in readings) {
+            val top = WorkoutRecorder.liveZone(bpm, maxHr) == Workouts.ZONES - 1
+            val gap = last != null && t - last > WorkoutRecorder.MAX_STEP_S
+            if (!top || gap) { since = null; counted = false }
+            if (top) {
+                if (since == null) since = t
+                if (!counted && t - since >= HARD_EFFORT_S) { count++; counted = true }
+            }
+            last = t
+        }
+        return count
+    }
+}

app/src/main/kotlin/org/openstrap/app/data/HealthRepository.kt

@@ -50,6 +50,8 @@ data class DayWindow(val from: Long, val to: Long) {
 class HealthRepository(private val dao: HealthDao) {
     private val recoveryEngine = RecoveryEngine(dao)
     private val healthspanEngine = HealthspanEngine(dao)
+    /** The one reader of sleep for everything shown ([SleepSource]). */
+    val sleep = SleepSource(dao)
 
     /**
      * Readiness and charge for [date]; heavy, so call it off the main thread. Also logs the night's own inputs next to
@@ -91,7 +93,7 @@ class HealthRepository(private val dao: HealthDao) {
      */
     fun changes(): Flow<Unit> = kotlinx.coroutines.flow.combine(
         dao.latestHeartRateTime(), dao.latestStressTime(), dao.latestSleepEnd(), dao.workoutCountFlow().distinctUntilChanged(),
-        dao.napEdits().distinctUntilChanged(),
+        dao.sleepEdits().distinctUntilChanged(),
     ) { _, _, _, _, _ -> }
 
     /** Local days that have any heart rate, steps or sleep, for the calendar. */
@@ -101,15 +103,40 @@ class HealthRepository(private val dao: HealthDao) {
 
     fun heartRate(w: DayWindow): Flow<List<HeartRateSample>> = dao.heartRate(w.from, w.to)
     fun activity(w: DayWindow): Flow<List<ActivityMinute>> = dao.activity(w.from, w.to)
-    fun sleepSessions(w: DayWindow): Flow<List<SleepSession>> = dao.sleepSessions(w.from, w.to)
-    fun sleepStages(sessionStart: Long): Flow<List<SleepStage>> = dao.sleepStages(sessionStart)
-    fun napEdits(): Flow<List<org.openstrap.app.data.db.NapEdit>> = dao.napEdits()
-
-    /** Keeps [start] to [end] as the strap's nap [strap]'s times; its own times again drop the edit. */
-    suspend fun setNapTimes(strap: SleepSession, start: Long, end: Long) {
-        val e = NapTimes.edit(strap, start, end)
-        if (e == null) dao.deleteNapEdit(strap.start) else dao.upsertNapEdit(e)
+    /** Sleep and naps as shown, ending in [w]: with the user's times, deleted ones left out ([SleepSource]). */
+    fun sleepSessions(w: DayWindow): Flow<List<SleepSession>> = sleep.sessions(w.from, w.to)
+    /** Each strap session ending in [w] with its edit, deleted ones too, for the screens that change them. */
+    fun sleepResolved(w: DayWindow): Flow<List<SleepEdits.Resolved>> = sleep.resolved(w.from, w.to)
+    /** [resolved] as [sleepSessions] shows them. */
+    suspend fun sleepShown(resolved: List<SleepEdits.Resolved>): List<SleepSession> = sleep.shown(resolved)
+    /** [r]'s stages as shown. */
+    fun sleepStages(r: SleepEdits.Resolved): Flow<List<SleepStage>> = sleep.stages(r)
+    /** The strap's own stages for its session [strap], unclipped. */
+    fun strapStages(strap: SleepSession): Flow<List<SleepStage>> = sleep.strapStages(strap)
+    fun sleepEdits(): Flow<List<org.openstrap.app.data.db.SleepEdit>> = dao.sleepEdits()
+
+    /** Keeps [start] to [end] as the strap's session [strap]'s times; its own times again drop the edit. */
+    suspend fun setSleepTimes(strap: SleepSession, start: Long, end: Long) {
+        val current = sleep.editOf(strap)
+        val e = SleepEdits.edit(strap, start, end, current, System.currentTimeMillis() / 1000)
+        if (e == null) dao.deleteSleepEdit(current?.strapStart ?: strap.start) else dao.upsertSleepEdit(e)
     }
+
+    /** Deletes the strap's session [strap], keeping any times the user gave it, so [restoreSleep] brings back exactly that. */
+    suspend fun deleteSleep(strap: SleepSession) {
+        val current = sleep.editOf(strap)
+        dao.upsertSleepEdit(SleepEdits.delete(strap, current, System.currentTimeMillis() / 1000))
+    }
+
+    /** Brings back the strap's deleted session [strap], with the times it had: Undo and Restore. */
+    suspend fun restoreSleep(strap: SleepSession) {
+        val current = sleep.editOf(strap) ?: return
+        val restored = SleepEdits.restore(current, System.currentTimeMillis() / 1000)
+        if (restored == null) dao.deleteSleepEdit(current.strapStart) else dao.upsertSleepEdit(restored)
+    }
+
+    /** Sleep and naps deleted in the last [SleepEdits.KEEP_DAYS], newest first, for You, Your data, Deleted sleep. */
+    fun deletedSleep(): Flow<List<SleepEdits.Resolved>> = sleep.deleted { System.currentTimeMillis() / 1000 }
     fun spo2(w: DayWindow): Flow<List<Spo2Sample>> = dao.spo2(w.from, w.to)
     /**
      * The day's stress readings that count as daily stress: those outside the exclusion around workouts

app/src/main/kotlin/org/openstrap/app/data/HealthspanEngine.kt

@@ -14,6 +14,8 @@ import java.time.temporal.TemporalAdjusters
  * thread. The last result is kept until a sync adds data to its window.
  */
 class HealthspanEngine(private val dao: HealthDao) {
+    /** Sleep as shown, with the user's edits ([SleepEdits]). */
+    private val sleepSource = SleepSource(dao)
     private data class Key(val asOf: Long, val profile: UserProfile, val fingerprint: Long)
     private var cached: Pair<Key, Healthspan.Outcome>? = null
 
@@ -76,7 +78,7 @@ class HealthspanEngine(private val dao: HealthDao) {
         }.toMap()
 
         // Main sleeps: the longest non-nap session per morning, as Recovery picks them.
-        val sessions = dao.sleepSessionsOnce(from, to)
+        val sessions = sleepSource.sessionsOnce(from, to)
         val mains = sessions.filter { !it.nap }
             .groupBy { RecoveryEngine.morningOf(it, zone) }
             .filterKeys { it in from until asOf }
@@ -97,7 +99,7 @@ class HealthspanEngine(private val dao: HealthDao) {
         }.toMap()
 
         // Sleep regularity: one SRI per week, each over 8 noon-to-noon grid days ending at a Saturday noon.
-        val stages = sessions.flatMap { s -> dao.sleepStagesOnce(s.start).map { Triple(it.start, it.end, it.stage) } }
+        val stages = sessions.flatMap { s -> sleepSource.stagesOnce(s).map { Triple(it.start, it.end, it.stage) } }
         val weeks = (Healthspan.WINDOW_DAYS - 1) / 7
         val weeklySri = (0 until weeks).mapNotNull { k ->
             val end = sunday.minusDays(7L * k + 1)