From 565c8acf7880962c6aec9255196388d76f2f4273 Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 22 Oct 2026 10:01:40 +0000 Subject: [PATCH] Use PulseLoop without a ring: Health Connect as the data source People who wear an Oura, Galaxy Ring, Fitbit or watch can pick that app in onboarding ("I wear an Oura or another device") or Settings -> Use without a ring. PulseLoop reads only that app from Health Connect, hourly and on every foreground, and stores heart rate, HRV, SpO2, respiratory rate, sleep stages, steps, distance, calories, workouts and periods through the ring's own persistence path, so every screen, the coach and the insights work. While it is on, the Health Connect export holds back every type so the source's data is never written back under PulseLoop's name. Pairing a ring turns the mode off. Design in docs/health-connect-source.md. Claude-Session: https://claude.ai/code/session_01P1t1aUqSUPd3whKXmgVm7w --- AGENTS.md | 21 ++ app/src/main/AndroidManifest.xml | 6 + .../com/pulseloop/PulseLoopApplication.kt | 1 + .../health/HealthConnectExportWorker.kt | 1 + .../pulseloop/health/HealthConnectExporter.kt | 6 +- .../health/exporters/WorkoutExporter.kt | 2 + .../health/source/HealthConnectSource.kt | 226 +++++++++++++++ .../source/HealthConnectSourceImporter.kt | 272 ++++++++++++++++++ .../service/EventPersistenceSubscriber.kt | 29 +- .../java/com/pulseloop/ui/PulseLoopApp.kt | 12 +- .../com/pulseloop/ui/components/AppChrome.kt | 10 +- .../ui/screens/HealthConnectSourceUi.kt | 237 +++++++++++++++ .../pulseloop/ui/screens/OnboardingScreen.kt | 27 +- .../pulseloop/ui/screens/SettingsScreen.kt | 8 +- .../com/pulseloop/ui/screens/TodayScreen.kt | 4 +- .../com/pulseloop/ui/viewmodels/ViewModels.kt | 4 +- .../health/source/HealthConnectSourceTest.kt | 84 ++++++ docs/health-connect-source.md | 58 ++++ 18 files changed, 997 insertions(+), 11 deletions(-) create mode 100644 app/src/main/java/com/pulseloop/health/source/HealthConnectSource.kt create mode 100644 app/src/main/java/com/pulseloop/health/source/HealthConnectSourceImporter.kt create mode 100644 app/src/main/java/com/pulseloop/ui/screens/HealthConnectSourceUi.kt create mode 100644 app/src/test/java/com/pulseloop/health/source/HealthConnectSourceTest.kt create mode 100644 docs/health-connect-source.md diff --git a/AGENTS.md b/AGENTS.md index 501b7c40..c2bcc582 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -1012,3 +1012,24 @@ because breaking it fails silently: - **A running check ends the moment a different ring is paired** (`AccuracyRingWatcher`, started from `PulseLoopApplication`). Ring rows carry no device id, so a later sweep could not split the two rings' data. + +## Health Connect as the data source: one app, no ring, nothing back + +**Read this before touching `health/source/` or the export's exclusions.** Full design: +`docs/health-connect-source.md`. + +A user without a PulseLoop ring can pick another device's app (Oura, Samsung Health, Fitbit) and +PulseLoop imports it from Health Connect into the ring's own tables. Three rules hold it together, +and each one fails silently if broken: + +- **Every read carries a `DataOrigin` filter for the chosen package.** Unfiltered, PulseLoop's own + earlier exports come straight back in as "new" data, and two apps' steps sum into the same slot. +- **It goes through `EventPersistenceSubscriber.ingest`, not around it.** That path is what gives an + import deterministic ids, the user's deletions, and the waking-day sleep reconcile. Writing rows + directly would re-create every duplicate and resurrection bug the ring path already fixed. +- **While it is on, the export holds back every type, for all time** (`exportExclusions`, through + `ExportPause`). Exporting would write the source app's own data back to Health Connect under + PulseLoop's name. Don't narrow it to "the types the source writes": a type the source starts + writing next month would then echo. + +It is exclusive with a paired ring: a `DeviceIdentified` turns it off. diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml index d3cd4dd1..c0b754bd 100644 --- a/app/src/main/AndroidManifest.xml +++ b/app/src/main/AndroidManifest.xml @@ -86,6 +86,12 @@ + + + + + diff --git a/app/src/main/java/com/pulseloop/PulseLoopApplication.kt b/app/src/main/java/com/pulseloop/PulseLoopApplication.kt index 4417646a..f2f771de 100644 --- a/app/src/main/java/com/pulseloop/PulseLoopApplication.kt +++ b/app/src/main/java/com/pulseloop/PulseLoopApplication.kt @@ -27,6 +27,7 @@ class PulseLoopApplication : Application() { super.onCreate() CrashLogger.install(this) com.pulseloop.service.DrinkPrefs.init(this) + com.pulseloop.health.source.HealthConnectSource.isEnabled(this) // warms [HealthConnectSource.enabledNow] // Application-scoped so capture runs whether or not the Debug screen is open. DiagnosticsSubscriber(PulseLoopDatabase.getInstance(this)).start(appScope) // Accuracy check: a different ring ends a running check at once (it can't be told apart later). diff --git a/app/src/main/java/com/pulseloop/health/HealthConnectExportWorker.kt b/app/src/main/java/com/pulseloop/health/HealthConnectExportWorker.kt index a242ac97..86bb71b6 100644 --- a/app/src/main/java/com/pulseloop/health/HealthConnectExportWorker.kt +++ b/app/src/main/java/com/pulseloop/health/HealthConnectExportWorker.kt @@ -49,6 +49,7 @@ class HealthConnectExportWorker( client = client, db = PulseLoopDatabase.getInstance(applicationContext), store = store, + extraExclusions = com.pulseloop.health.source.HealthConnectSource.exportExclusions(applicationContext), ) // The pass and "Remove PulseLoop data" must never interleave (review pass 5): a pass // still inserting while the removal deletes would re-write records the user asked to diff --git a/app/src/main/java/com/pulseloop/health/HealthConnectExporter.kt b/app/src/main/java/com/pulseloop/health/HealthConnectExporter.kt index 7654b986..1ec53904 100644 --- a/app/src/main/java/com/pulseloop/health/HealthConnectExporter.kt +++ b/app/src/main/java/com/pulseloop/health/HealthConnectExporter.kt @@ -227,6 +227,8 @@ class HealthConnectExporter( private val db: PulseLoopDatabase, private val store: HealthConnectPrefsStore, private val now: () -> Long = { System.currentTimeMillis() }, + /** Held back on top of the accuracy check's, for all time: the Health Connect source mode's. */ + private val extraExclusions: List = emptyList(), ) { /** @@ -306,7 +308,9 @@ class HealthConnectExporter( // advance past them (see [ExportPause]). Read once per pass; the pass runs under // HealthConnectExportWorker.passMutex, which the resume choice also takes, so a choice can't // land halfway through a pass. - val exclusions = ExportPause.exclusions(db.accuracyDao().all(), db.accuracyDao().allPausedUnits()) + // While Health Connect is the data source ([extraExclusions]), nothing it wrote goes back to it. + val exclusions = ExportPause.exclusions(db.accuracyDao().all(), db.accuracyDao().allPausedUnits()) + + extraExclusions fun noteHeldBack(label: String, f: ExportPause.Filtered) { if (f.heldBack > 0) skipped += "$label: ${f.heldBack} record(s) held back by the accuracy check" } diff --git a/app/src/main/java/com/pulseloop/health/exporters/WorkoutExporter.kt b/app/src/main/java/com/pulseloop/health/exporters/WorkoutExporter.kt index d0503b0e..54bbf400 100644 --- a/app/src/main/java/com/pulseloop/health/exporters/WorkoutExporter.kt +++ b/app/src/main/java/com/pulseloop/health/exporters/WorkoutExporter.kt @@ -111,6 +111,8 @@ class WorkoutExporter(private val db: PulseLoopDatabase) { ): PendingWorkouts { val wm = watermark ?: 0L val sessions = db.activitySessionDao().finishedUpdatedSince(wm) + // A workout imported from Health Connect is already there, under its own app. + .filterNot { com.pulseloop.health.source.HealthConnectSource.isImportedWorkout(it.id) } if (sessions.isEmpty()) return PendingWorkouts(emptyList(), emptyList()) // All GPS fixes for the pending sessions in one query — a first-enable backfill can diff --git a/app/src/main/java/com/pulseloop/health/source/HealthConnectSource.kt b/app/src/main/java/com/pulseloop/health/source/HealthConnectSource.kt new file mode 100644 index 00000000..e9e53bf3 --- /dev/null +++ b/app/src/main/java/com/pulseloop/health/source/HealthConnectSource.kt @@ -0,0 +1,226 @@ +package com.pulseloop.health.source + +import android.content.Context +import androidx.health.connect.client.permission.HealthPermission +import androidx.health.connect.client.records.ExerciseSessionRecord +import androidx.health.connect.client.records.MenstruationPeriodRecord +import androidx.health.connect.client.records.RespiratoryRateRecord +import androidx.health.connect.client.records.SleepSessionRecord +import androidx.health.connect.client.records.TotalCaloriesBurnedRecord +import androidx.work.Constraints +import androidx.work.ExistingPeriodicWorkPolicy +import androidx.work.ExistingWorkPolicy +import androidx.work.OneTimeWorkRequestBuilder +import androidx.work.PeriodicWorkRequestBuilder +import androidx.work.WorkManager +import com.pulseloop.health.accuracy.AccuracyCheckPermissions +import com.pulseloop.health.accuracy.ExportExclusion +import com.pulseloop.health.accuracy.ExportUnit +import com.pulseloop.health.accuracy.ReferenceAppLabels +import com.pulseloop.ring.SleepStage +import com.pulseloop.ring.WearableCapability +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import java.util.concurrent.TimeUnit + +/** + * "No ring, Health Connect instead" (docs/health-connect-source.md): the user wears another + * device — an Oura, a Galaxy Ring, a Fitbit — whose app writes to Health Connect, and PulseLoop + * reads that one app's records into the same tables a paired ring fills, so every screen works. + * + * Three rules hold the feature together: + * - **One source app, by package.** Every read carries a `DataOrigin` filter. Reading "everything + * in Health Connect" would pull PulseLoop's own earlier exports back in, and mix two devices' + * steps into one day. + * - **Exclusive with a paired ring.** Both would write the same 15-minute activity slots and the + * same nights; the screen refuses to switch on while a ring is paired. + * - **Nothing goes back.** While this is on, every exported type the source writes is held back + * from the Health Connect export ([exportExclusions]), or the app would echo the source's own + * data to it under PulseLoop's name. Meals and workouts recorded in PulseLoop still export. + */ +object HealthConnectSource { + + /** How far back the first import reads. Health Connect itself only serves 30 days before the first grant. */ + const val FIRST_IMPORT_DAYS = 30L + /** Later passes re-read this much, because source apps write late (a night lands in the morning). */ + const val OVERLAP_DAYS = 3L + + /** Source rows' marker in `activity_daily.source`, so the device's own calorie figure is used. */ + const val ACTIVITY_SOURCE = "health_connect" + /** Prefix of a workout imported from Health Connect; the workout export skips these. */ + const val WORKOUT_ID_PREFIX = "hc-" + + fun isImportedWorkout(id: String): Boolean = id.startsWith(WORKOUT_ID_PREFIX) + + // ── Settings ───────────────────────────────────────────────────────────────────────────── + + private fun prefs(c: Context) = c.applicationContext.getSharedPreferences("hc_source", Context.MODE_PRIVATE) + + @Volatile private var cachedEnabled: Boolean? = null + @Volatile private var active: MutableStateFlow? = null + + /** The source app's package while the mode is on, null while off; for the header and settings. */ + fun activeSource(c: Context): StateFlow = active ?: synchronized(this) { + active ?: MutableStateFlow(if (isEnabled(c)) sourcePackage(c) else null).also { active = it } + } + + /** [isEnabled] for code with no Context (view models); warmed from the Application. */ + val enabledNow: Boolean get() = cachedEnabled == true + + /** What the cards can show while the mode is on: what Oura and its peers write to Health Connect. */ + val CAPABILITIES: Set = setOf( + WearableCapability.HEART_RATE, WearableCapability.SPO2, WearableCapability.STEPS, + WearableCapability.SLEEP, WearableCapability.REM_SLEEP, WearableCapability.HRV, + ) + + fun isEnabled(c: Context): Boolean = cachedEnabled ?: prefs(c).getBoolean("enabled", false).also { cachedEnabled = it } + fun sourcePackage(c: Context): String? = prefs(c).getString("package", null) + fun lastImportAt(c: Context): Long? = prefs(c).getLong("lastImportAt", 0L).takeIf { it > 0 } + fun lastImportCount(c: Context): Int = prefs(c).getInt("lastImportCount", 0) + fun lastError(c: Context): String? = prefs(c).getString("lastError", null) + + fun enable(c: Context, packageName: String) { + val changed = sourcePackage(c) != packageName + prefs(c).edit().putBoolean("enabled", true).putString("package", packageName).apply { + // A different source starts from a full window, not the old one's watermark. + if (changed) remove("lastImportAt").remove("seenWorkouts") + }.apply() + cachedEnabled = true + activeSource(c); active?.value = packageName + schedule(c) + runNow(c) + } + + fun disable(c: Context) { + prefs(c).edit().putBoolean("enabled", false).apply() + cachedEnabled = false + activeSource(c); active?.value = null + WorkManager.getInstance(c).cancelUniqueWork(PERIODIC) + } + + internal fun recordPass(c: Context, at: Long, count: Int, error: String?) { + prefs(c).edit().apply { + if (error == null) putLong("lastImportAt", at).putInt("lastImportCount", count).remove("lastError") + else putString("lastError", error) + }.apply() + } + + /** Workouts already imported once; the user deleting one must not bring it back. */ + internal fun seenWorkouts(c: Context): Set = prefs(c).getStringSet("seenWorkouts", emptySet()).orEmpty() + + internal fun markWorkoutsSeen(c: Context, ids: Collection) { + if (ids.isEmpty()) return + val keep = (seenWorkouts(c) + ids).toList().takeLast(500).toSet() + prefs(c).edit().putStringSet("seenWorkouts", keep).apply() + } + + fun label(c: Context, packageName: String): String = ReferenceAppLabels.label(c, packageName) + + // ── Permissions ────────────────────────────────────────────────────────────────────────── + + /** The accuracy check's reads plus what only this feature uses. Declared in the manifest too. */ + val readPermissions: Set = AccuracyCheckPermissions.all + setOf( + HealthPermission.getReadPermission(TotalCaloriesBurnedRecord::class), + HealthPermission.getReadPermission(ExerciseSessionRecord::class), + HealthPermission.getReadPermission(RespiratoryRateRecord::class), + HealthPermission.getReadPermission(MenstruationPeriodRecord::class), + ) + + /** What the screen asks for: the reads, plus background reading so imports run with the app closed. */ + val request: Set = readPermissions + HealthPermission.PERMISSION_READ_HEALTH_DATA_IN_BACKGROUND + + fun canReadInBackground(granted: Set): Boolean = + HealthPermission.PERMISSION_READ_HEALTH_DATA_IN_BACKGROUND in granted + + // ── Export ─────────────────────────────────────────────────────────────────────────────── + + /** While this is on, every unit the export could echo is held back, for all time. */ + fun exportExclusions(c: Context): List = + if (isEnabled(c)) exportExclusions() else emptyList() + + fun exportExclusions(): List = ExportUnit.entries.map { ExportExclusion(it, Long.MIN_VALUE, null) } + + // ── Scheduling ─────────────────────────────────────────────────────────────────────────── + + private const val PERIODIC = "hc_source_import" + private const val ONE_SHOT = "hc_source_import_now" + + fun schedule(c: Context) { + if (!isEnabled(c)) return + val request = PeriodicWorkRequestBuilder(1, TimeUnit.HOURS) + .setConstraints(Constraints.Builder().setRequiresBatteryNotLow(true).build()) + .build() + WorkManager.getInstance(c).enqueueUniquePeriodicWork(PERIODIC, ExistingPeriodicWorkPolicy.KEEP, request) + } + + fun runNow(c: Context) { + if (!isEnabled(c)) return + WorkManager.getInstance(c).enqueueUniqueWork( + ONE_SHOT, ExistingWorkPolicy.KEEP, + OneTimeWorkRequestBuilder().build(), + ) + } + + // ── Pure conversions (tested) ──────────────────────────────────────────────────────────── + + /** Health Connect's stage constant as the app's stage. "Sleeping" with no stage is asleep, stage unknown. */ + fun stage(hc: Int): SleepStage = when (hc) { + SleepSessionRecord.STAGE_TYPE_LIGHT -> SleepStage.LIGHT + SleepSessionRecord.STAGE_TYPE_DEEP -> SleepStage.DEEP + SleepSessionRecord.STAGE_TYPE_REM -> SleepStage.REM + SleepSessionRecord.STAGE_TYPE_AWAKE, + SleepSessionRecord.STAGE_TYPE_AWAKE_IN_BED, + SleepSessionRecord.STAGE_TYPE_OUT_OF_BED -> SleepStage.AWAKE + else -> SleepStage.UNKNOWN + } + + data class Stage(val startMs: Long, val endMs: Long, val type: Int) + + /** + * A night as one stage per minute from its start, the shape a ring's sleep record has. A night + * with no stages at all is asleep throughout (stage unknown); with stages, a minute none of them + * covers is awake. Each minute takes the stage covering most of it. Null for an empty or + * over-long session. + */ + fun minuteStages(startMs: Long, endMs: Long, stages: List, maxMinutes: Int = 24 * 60): List? { + val minutes = ((endMs - startMs) / 60_000L).toInt() + if (minutes <= 0 || minutes > maxMinutes) return null + if (stages.isEmpty()) return List(minutes) { SleepStage.UNKNOWN } + val sorted = stages.sortedBy { it.startMs } + return List(minutes) { i -> + val a = startMs + i * 60_000L + val b = a + 60_000L + var best: Stage? = null + var bestOverlap = 0L + for (s in sorted) { + if (s.startMs >= b) break + val o = minOf(b, s.endMs) - maxOf(a, s.startMs) + if (o > bestOverlap) { bestOverlap = o; best = s } + } + best?.let { stage(it.type) } ?: SleepStage.AWAKE + } + } + + /** The app's workout type for a Health Connect exercise type; the inverse of the export's mapping. */ + fun workoutType(exerciseType: Int): String = when (exerciseType) { + ExerciseSessionRecord.EXERCISE_TYPE_WALKING -> "walk" + ExerciseSessionRecord.EXERCISE_TYPE_RUNNING, + ExerciseSessionRecord.EXERCISE_TYPE_RUNNING_TREADMILL -> "run" + ExerciseSessionRecord.EXERCISE_TYPE_BIKING, + ExerciseSessionRecord.EXERCISE_TYPE_BIKING_STATIONARY -> "cycle" + ExerciseSessionRecord.EXERCISE_TYPE_STRENGTH_TRAINING, + ExerciseSessionRecord.EXERCISE_TYPE_WEIGHTLIFTING -> "gym" + ExerciseSessionRecord.EXERCISE_TYPE_SQUASH -> "squash" + ExerciseSessionRecord.EXERCISE_TYPE_YOGA -> "yoga" + ExerciseSessionRecord.EXERCISE_TYPE_DANCING -> "dance" + ExerciseSessionRecord.EXERCISE_TYPE_HIKING -> "hike" + else -> "sport" + } + + /** The window a pass reads: the first one goes back [FIRST_IMPORT_DAYS], later ones overlap the last. */ + fun window(lastImportAt: Long?, now: Long): LongRange { + val from = if (lastImportAt == null) now - FIRST_IMPORT_DAYS * 86_400_000L + else maxOf(now - FIRST_IMPORT_DAYS * 86_400_000L, lastImportAt - OVERLAP_DAYS * 86_400_000L) + return from..now + } +} diff --git a/app/src/main/java/com/pulseloop/health/source/HealthConnectSourceImporter.kt b/app/src/main/java/com/pulseloop/health/source/HealthConnectSourceImporter.kt new file mode 100644 index 00000000..bca59596 --- /dev/null +++ b/app/src/main/java/com/pulseloop/health/source/HealthConnectSourceImporter.kt @@ -0,0 +1,272 @@ +package com.pulseloop.health.source + +import android.content.Context +import android.util.Log +import androidx.health.connect.client.HealthConnectClient +import androidx.health.connect.client.permission.HealthPermission +import androidx.health.connect.client.records.ActiveCaloriesBurnedRecord +import androidx.health.connect.client.records.DistanceRecord +import androidx.health.connect.client.records.ExerciseSessionRecord +import androidx.health.connect.client.records.HeartRateRecord +import androidx.health.connect.client.records.HeartRateVariabilityRmssdRecord +import androidx.health.connect.client.records.MenstruationPeriodRecord +import androidx.health.connect.client.records.OxygenSaturationRecord +import androidx.health.connect.client.records.Record +import androidx.health.connect.client.records.RespiratoryRateRecord +import androidx.health.connect.client.records.SleepSessionRecord +import androidx.health.connect.client.records.StepsRecord +import androidx.health.connect.client.records.TotalCaloriesBurnedRecord +import androidx.health.connect.client.records.metadata.DataOrigin +import androidx.health.connect.client.request.AggregateGroupByDurationRequest +import androidx.health.connect.client.request.AggregateGroupByPeriodRequest +import androidx.health.connect.client.request.ReadRecordsRequest +import androidx.health.connect.client.time.TimeRangeFilter +import androidx.work.CoroutineWorker +import androidx.work.WorkerParameters +import com.pulseloop.AppServices +import com.pulseloop.data.PulseLoopDatabase +import com.pulseloop.data.entity.ActivityDailyEntity +import com.pulseloop.data.entity.ActivitySessionEntity +import com.pulseloop.data.entity.PeriodEntity +import com.pulseloop.health.HealthConnectAvailability +import com.pulseloop.health.HealthConnectSdk +import com.pulseloop.ring.MeasurementKind +import com.pulseloop.ring.PulseEvent +import com.pulseloop.service.ActivityAggregates +import com.pulseloop.service.ActivityRollup +import kotlinx.coroutines.sync.Mutex +import kotlinx.coroutines.sync.withLock +import java.time.Duration +import java.time.Instant +import java.time.LocalDateTime +import java.time.Period +import java.time.ZoneId +import kotlin.reflect.KClass + +/** + * One import pass from the chosen source app ([HealthConnectSource]). Every reading becomes the + * same [PulseEvent] a ring's history would produce and goes through the persistence subscriber, + * so the import inherits everything that path already gets right: deterministic ids (a re-read + * updates rather than duplicates), the user's deletions, sleep reconciliation by waking day, and + * activity buckets summed per day. + */ +object HealthConnectSourceImporter { + + private const val TAG = "HCSource" + private const val MAX_PAGES = 50 + private val passLock = Mutex() + + sealed interface Outcome { + data object Off : Outcome + data object Unavailable : Outcome + data object NoPermission : Outcome + data class Done(val stored: Int) : Outcome + data class Failed(val message: String) : Outcome + } + + suspend fun run(context: Context, now: Long = System.currentTimeMillis()): Outcome = passLock.withLock { + if (!HealthConnectSource.isEnabled(context)) return Outcome.Off + val pkg = HealthConnectSource.sourcePackage(context) ?: return Outcome.Off + if (HealthConnectSdk.availability(context) != HealthConnectAvailability.AVAILABLE) return Outcome.Unavailable + val client = HealthConnectClient.getOrCreate(context) + val granted = runCatching { client.permissionController.getGrantedPermissions() }.getOrDefault(emptySet()) + if (granted.none { it in HealthConnectSource.readPermissions }) return Outcome.NoPermission + + val services = AppServices.get(context) + val db = services.db + val window = HealthConnectSource.window(HealthConnectSource.lastImportAt(context), now) + val range = TimeRangeFilter.between(Instant.ofEpochMilli(window.first), Instant.ofEpochMilli(window.last)) + val origin = setOf(DataOrigin(pkg)) + val events = mutableListOf() + val failures = mutableListOf() + fun can(type: KClass) = HealthPermission.getReadPermission(type) in granted + suspend fun step(name: String, block: suspend () -> Unit) { + runCatching { block() }.onFailure { + Log.w(TAG, "import $name failed", it) + failures += name + } + } + + step("heart rate") { + if (can(HeartRateRecord::class)) readAll(client, HeartRateRecord::class, range, origin) { r -> + r.samples.forEach { s -> + val bpm = s.beatsPerMinute.toDouble() + if (bpm in 30.0..230.0) events += PulseEvent.HistoryMeasurement(MeasurementKind.HEART_RATE, bpm, s.time) + } + } + } + step("HRV") { + if (can(HeartRateVariabilityRmssdRecord::class)) readAll(client, HeartRateVariabilityRmssdRecord::class, range, origin) { r -> + if (r.heartRateVariabilityMillis in 1.0..250.0) { + events += PulseEvent.HistoryMeasurement(MeasurementKind.HRV, r.heartRateVariabilityMillis, r.time) + } + } + } + step("blood oxygen") { + if (can(OxygenSaturationRecord::class)) readAll(client, OxygenSaturationRecord::class, range, origin) { r -> + val pct = r.percentage.value + if (pct in 70.0..100.0) events += PulseEvent.HistoryMeasurement(MeasurementKind.SPO2, pct, r.time) + } + } + step("respiratory rate") { + if (can(RespiratoryRateRecord::class)) readAll(client, RespiratoryRateRecord::class, range, origin) { r -> + if (r.rate in 4.0..60.0) events += PulseEvent.HistoryMeasurement(MeasurementKind.RESPIRATORY_RATE, r.rate, r.time) + } + } + step("sleep") { + if (can(SleepSessionRecord::class)) readAll(client, SleepSessionRecord::class, range, origin) { r -> + val start = r.startTime.toEpochMilli() / 60_000L * 60_000L + val minutes = HealthConnectSource.minuteStages( + start, r.endTime.toEpochMilli(), + r.stages.map { HealthConnectSource.Stage(it.startTime.toEpochMilli(), it.endTime.toEpochMilli(), it.stage) }, + ) + if (minutes != null) events += PulseEvent.SleepTimeline(Instant.ofEpochMilli(start), minutes, completeSession = true) + } + } + step("steps") { + if (can(StepsRecord::class)) { + val withDistance = can(DistanceRecord::class) + val metrics = buildSet { + add(StepsRecord.COUNT_TOTAL) + if (withDistance) add(DistanceRecord.DISTANCE_TOTAL) + } + // A week per request keeps each response to a few hundred 15-minute groups. + var from = window.first / 900_000L * 900_000L + while (from < window.last) { + val to = minOf(window.last, from + 7 * 86_400_000L) + client.aggregateGroupByDuration( + AggregateGroupByDurationRequest( + metrics = metrics, + timeRangeFilter = TimeRangeFilter.between(Instant.ofEpochMilli(from), Instant.ofEpochMilli(to)), + timeRangeSlicer = Duration.ofMinutes(15), + dataOriginFilter = origin, + ), + ).forEach { g -> + val steps = g.result[StepsRecord.COUNT_TOTAL] ?: 0L + val meters = if (withDistance) g.result[DistanceRecord.DISTANCE_TOTAL]?.inMeters ?: 0.0 else 0.0 + if (steps > 0 || meters > 0) { + events += PulseEvent.ActivityBucket(g.startTime, steps.toInt().coerceAtMost(50_000), meters) + } + } + from = to + } + } + } + + val stored = events.size + services.persistence.ingest(events) + + // After the buckets, so the day rows exist and carry the device's own calorie figure. + step("calories") { + val metric = when { + can(TotalCaloriesBurnedRecord::class) -> TotalCaloriesBurnedRecord.ENERGY_TOTAL + can(ActiveCaloriesBurnedRecord::class) -> ActiveCaloriesBurnedRecord.ACTIVE_CALORIES_TOTAL + else -> null + } + if (metric != null) { + val zone = ZoneId.systemDefault() + val fromDay = Instant.ofEpochMilli(window.first).atZone(zone).toLocalDate() + val toDay = Instant.ofEpochMilli(window.last).atZone(zone).toLocalDate().plusDays(1) + client.aggregateGroupByPeriod( + AggregateGroupByPeriodRequest( + metrics = setOf(metric), + timeRangeFilter = TimeRangeFilter.between(fromDay.atStartOfDay(), LocalDateTime.of(toDay, java.time.LocalTime.MIDNIGHT)), + timeRangeSlicer = Period.ofDays(1), + dataOriginFilter = origin, + ), + ).forEach { g -> + val kcal = g.result[metric]?.inKilocalories ?: return@forEach + if (kcal <= 0 || kcal > 20_000) return@forEach + val day = g.startTime.toLocalDate().atStartOfDay(zone).toInstant().toEpochMilli() + val existing = db.activityDailyDao().byDay(day) + db.activityDailyDao().upsert( + (existing ?: ActivityDailyEntity(date = day)).copy( + calories = kcal, + source = HealthConnectSource.ACTIVITY_SOURCE, + syncedAt = now, + updatedAt = now, + ), + ) + } + } + } + var workouts = 0 + step("workouts") { + if (can(ExerciseSessionRecord::class)) { + val seen = HealthConnectSource.seenWorkouts(context) + val fresh = mutableListOf() + readAll(client, ExerciseSessionRecord::class, range, origin) { r -> + val id = HealthConnectSource.WORKOUT_ID_PREFIX + r.metadata.id + if (id !in seen) fresh += id + } + if (fresh.isNotEmpty()) { + readAll(client, ExerciseSessionRecord::class, range, origin) { r -> + val id = HealthConnectSource.WORKOUT_ID_PREFIX + r.metadata.id + if (id in fresh && db.activitySessionDao().byId(id) == null && r.endTime > r.startTime) { + val session = ActivitySessionEntity( + id = id, + type = HealthConnectSource.workoutType(r.exerciseType), + statusRaw = "finished", + startedAt = r.startTime.toEpochMilli(), + endedAt = r.endTime.toEpochMilli(), + notes = r.title ?: "From ${HealthConnectSource.label(context, pkg)}", + useGps = false, + ) + val summarized = ActivityAggregates.recompute(db, session) + db.activitySessionDao().upsert(summarized) + ActivityRollup.credit(db, summarized) + workouts++ + } + } + HealthConnectSource.markWorkoutsSeen(context, fresh) + } + } + } + step("periods") { + if (can(MenstruationPeriodRecord::class)) { + val zone = ZoneId.systemDefault() + val known = db.periodDao().all().map { it.startDay }.toSet() + readAll(client, MenstruationPeriodRecord::class, range, origin) { r -> + val start = r.startTime.atZone(zone).toLocalDate().toEpochDay() + // The record's end is exclusive: a period ending at midnight ended the day before. + val end = r.endTime.minusMillis(1).atZone(zone).toLocalDate().toEpochDay().coerceAtLeast(start) + if (known.none { kotlin.math.abs(it - start) <= 2 }) { + db.periodDao().upsert(PeriodEntity(id = "hc-${r.metadata.id}", startDay = start, endDay = end)) + } + } + } + } + + val total = stored + workouts + val error = failures.takeIf { it.size >= 6 }?.let { "Couldn't read ${it.joinToString(", ")}" } + HealthConnectSource.recordPass(context, now, total, error) + return if (error != null) Outcome.Failed(error) else Outcome.Done(total) + } + + private suspend fun readAll( + client: HealthConnectClient, + type: KClass, + range: TimeRangeFilter, + origin: Set, + consume: suspend (T) -> Unit, + ) { + var token: String? = null + var pages = 0 + do { + val response = client.readRecords( + ReadRecordsRequest(type, range, dataOriginFilter = origin, pageSize = 1000, pageToken = token), + ) + response.records.forEach { consume(it) } + token = response.pageToken + pages++ + } while (token != null && pages < MAX_PAGES) + } +} + +class HealthConnectSourceWorker(context: Context, params: WorkerParameters) : CoroutineWorker(context, params) { + override suspend fun doWork(): Result { + if (!HealthConnectSource.isEnabled(applicationContext)) return Result.success() + return runCatching { HealthConnectSourceImporter.run(applicationContext) } + .fold({ Result.success() }, { Log.w("HCSource", "pass failed", it); Result.success() }) + } +} diff --git a/app/src/main/java/com/pulseloop/service/EventPersistenceSubscriber.kt b/app/src/main/java/com/pulseloop/service/EventPersistenceSubscriber.kt index 474c16bf..7ad3e3d4 100644 --- a/app/src/main/java/com/pulseloop/service/EventPersistenceSubscriber.kt +++ b/app/src/main/java/com/pulseloop/service/EventPersistenceSubscriber.kt @@ -9,6 +9,7 @@ import com.pulseloop.health.HealthConnectExportWorker import com.pulseloop.settings.QuietHoursPrefs import com.pulseloop.ring.* import kotlinx.coroutines.* +import kotlinx.coroutines.sync.withLock /** * Ported from [EventPersistenceSubscriber] in PulseEventBus.swift. @@ -61,10 +62,18 @@ class EventPersistenceSubscriber( fun stop() { job?.cancel(); job = null } - private suspend fun persist(event: PulseEvent) { + /** + * Serialises the bus collector with [ingest]: the spot-reading cache and the gate set above are + * only safe from one writer at a time. + */ + private val writeLock = kotlinx.coroutines.sync.Mutex() + + private suspend fun persist(event: PulseEvent) = writeLock.withLock { persistOne(event, notify = true) } + + private suspend fun persistOne(event: PulseEvent, notify: Boolean) { try { persistUnsafe(event) - if (isDataEvent(event)) onDataPersisted?.invoke() + if (notify && isDataEvent(event)) onDataPersisted?.invoke() } catch (e: Exception) { // Swallow individual persistence failures so one bad event // (malformed ring packet, DB constraint, etc.) never crashes the app. @@ -72,6 +81,17 @@ class EventPersistenceSubscriber( } } + /** + * Persist a batch of history events directly, without the bus: the Health Connect source + * import (health/source) hands over a month of readings at once, which a replay-less bus + * could drop under load. Same handlers, same rules; the data-changed callback fires once. + */ + suspend fun ingest(events: List) { + if (events.isEmpty()) return + writeLock.withLock { events.forEach { persistOne(it, notify = false) } } + if (events.any(::isDataEvent)) onDataPersisted?.invoke() + } + /** Events that change what the Today tiles (and therefore the widgets) show. */ private fun isDataEvent(event: PulseEvent): Boolean = when (event) { is PulseEvent.HeartRateSample, @@ -242,6 +262,11 @@ class EventPersistenceSubscriber( )) } is PulseEvent.DeviceIdentified -> { + // A real ring takes over from Health Connect: the two would write the same + // activity slots and nights (health/source/HealthConnectSource.kt). + if (com.pulseloop.health.source.HealthConnectSource.isEnabled(context)) { + com.pulseloop.health.source.HealthConnectSource.disable(context) + } val device = db.deviceDao().currentReal() ?: DeviceEntity() db.deviceDao().upsert(device.copy( deviceTypeRaw = event.deviceType.name, diff --git a/app/src/main/java/com/pulseloop/ui/PulseLoopApp.kt b/app/src/main/java/com/pulseloop/ui/PulseLoopApp.kt index a914269a..464e2873 100644 --- a/app/src/main/java/com/pulseloop/ui/PulseLoopApp.kt +++ b/app/src/main/java/com/pulseloop/ui/PulseLoopApp.kt @@ -219,6 +219,7 @@ fun PulseLoopApp() { // Daily guidance: unusual-signal alerts, weekly report, wind-down reminder. com.pulseloop.notifications.GuidanceWorker.schedule(context.applicationContext) com.pulseloop.health.HealthConnectBodyImport.schedule(context.applicationContext) + com.pulseloop.health.source.HealthConnectSource.schedule(context.applicationContext) runCatching { com.pulseloop.health.ProfileAging.refresh(db) } // NOTE: demo data is never auto-seeded. A clean install starts empty so the UI @@ -251,6 +252,8 @@ fun PulseLoopApp() { activityVM.refreshCurrentDay() sleepVM.refreshReferenceNight() if (isFirstStart) isFirstStart = false else bleClient.reconnectIfNeeded() + // No ring, Health Connect instead: foreground reads get the larger quota. + com.pulseloop.health.source.HealthConnectSource.runNow(context.applicationContext) } Lifecycle.Event.ON_STOP -> { if (liveWorkout.state.value.activeSession != null) return@LifecycleEventObserver @@ -304,7 +307,8 @@ fun PulseLoopApp() { LaunchedEffect(Unit) { if (!apiKeyStore.onboardingCompleted) { val profileDone = db.userProfileDao().get()?.onboardingCompleted == true - val hasRing = db.deviceDao().current() != null || bleClient.hasLastKnownRing + val hasRing = db.deviceDao().current() != null || bleClient.hasLastKnownRing || + com.pulseloop.health.source.HealthConnectSource.isEnabled(context) if (profileDone || hasRing) { apiKeyStore.onboardingCompleted = true } else { @@ -433,12 +437,15 @@ fun PulseLoopApp() { com.pulseloop.ring.RingConnectionState.RECONNECTING, com.pulseloop.ring.RingConnectionState.SCANNING, ) + val hcSource by remember { com.pulseloop.health.source.HealthConnectSource.activeSource(context) } + .collectAsState() AppHeader( state = if (liveActive) ble.connectionState else storedDevice?.state ?: ble.connectionState, batteryPercent = ble.batteryPercent ?: storedDevice?.batteryPercent, onOpenSettings = { navController.navigate("settings") }, idle = ble.idleSince != null, + sourceLabel = hcSource?.let { com.pulseloop.health.source.HealthConnectSource.label(context, it) + " · Health Connect" }, ) // Thin sync-progress accent under the greeting while history streams in. val syncPct = coordinator.syncProgress.collectAsState().value @@ -628,6 +635,9 @@ fun PulseLoopApp() { paddedComposable("settings/health-connect") { HealthConnectSettingsScreen(onBack = { navController.popBackStack() }) } + paddedComposable("settings/hc-source") { + HealthConnectSourceScreen(onBack = { navController.popBackStack() }) + } paddedComposable("settings/accuracy-check") { AccuracyCheckSettingsScreen(onBack = { navController.popBackStack() }) } diff --git a/app/src/main/java/com/pulseloop/ui/components/AppChrome.kt b/app/src/main/java/com/pulseloop/ui/components/AppChrome.kt index d80c92ea..93417c26 100644 --- a/app/src/main/java/com/pulseloop/ui/components/AppChrome.kt +++ b/app/src/main/java/com/pulseloop/ui/components/AppChrome.kt @@ -43,6 +43,8 @@ fun AppHeader( onOpenSettings: () -> Unit, /** The ring hung up between syncs on its own (see `IdleLinkPolicy`), not a fault. */ idle: Boolean = false, + /** Set while Health Connect stands in for a ring ("Oura · Health Connect"); replaces the BLE state. */ + sourceLabel: String? = null, ) { Row( modifier = Modifier @@ -74,6 +76,7 @@ fun AppHeader( state = state, batteryPercent = batteryPercent, idle = idle, + sourceLabel = sourceLabel, modifier = Modifier.clickable( onClickLabel = "Open ring settings", role = Role.Button, @@ -98,17 +101,18 @@ fun ConnectionStatusPill( modifier: Modifier = Modifier, /** Disconnected because the ring idled out after a sync — shown neutral, not as an error. */ idle: Boolean = false, + sourceLabel: String? = null, ) { val idleNow = idle && state == RingConnectionState.DISCONNECTED // Holds still under "Remove animations"; the label already says "Connecting…". - val isPulsing = (state == RingConnectionState.CONNECTING || state == RingConnectionState.RECONNECTING) && + val isPulsing = sourceLabel == null && (state == RingConnectionState.CONNECTING || state == RingConnectionState.RECONNECTING) && !rememberReduceMotion() - val dotColor = when (state) { + val dotColor = if (sourceLabel != null) PulseColors.success else when (state) { RingConnectionState.CONNECTED -> PulseColors.success RingConnectionState.CONNECTING, RingConnectionState.RECONNECTING -> PulseColors.accent else -> if (idleNow) PulseColors.textMuted else PulseColors.danger // scanning/failed/idle/disconnected all read "not connected" } - val label = when (state) { + val label = sourceLabel ?: when (state) { RingConnectionState.CONNECTED -> if (batteryPercent != null && batteryPercent > 0) "Connected · $batteryPercent%" else "Connected" RingConnectionState.CONNECTING, RingConnectionState.RECONNECTING -> "Connecting…" diff --git a/app/src/main/java/com/pulseloop/ui/screens/HealthConnectSourceUi.kt b/app/src/main/java/com/pulseloop/ui/screens/HealthConnectSourceUi.kt new file mode 100644 index 00000000..a62619f4 --- /dev/null +++ b/app/src/main/java/com/pulseloop/ui/screens/HealthConnectSourceUi.kt @@ -0,0 +1,237 @@ +package com.pulseloop.ui.screens + +import androidx.activity.compose.rememberLauncherForActivityResult +import androidx.compose.foundation.background +import androidx.compose.foundation.clickable +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.ui.draw.clip +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.size +import androidx.compose.material3.Button +import androidx.compose.material3.CircularProgressIndicator +import androidx.compose.material3.OutlinedButton +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.collectAsState +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableIntStateOf +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberCoroutineScope +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp +import androidx.health.connect.client.PermissionController +import com.pulseloop.AppServices +import com.pulseloop.health.HealthConnectAvailability +import com.pulseloop.health.HealthConnectSdk +import com.pulseloop.health.accuracy.ReferenceSourceScanner +import com.pulseloop.health.accuracy.RingIdentity +import com.pulseloop.health.source.HealthConnectSource +import com.pulseloop.health.source.HealthConnectSourceImporter +import com.pulseloop.ui.theme.PulseColors +import kotlinx.coroutines.launch +import java.time.Instant +import java.time.ZoneId +import java.time.format.DateTimeFormatter + +/** Settings → Health Connect as your data source (docs/health-connect-source.md). */ +@Composable +fun HealthConnectSourceScreen(onBack: () -> Unit) { + SettingsSubScreen(title = "Use without a ring", onBack = onBack) { + HealthConnectSourceContent() + } +} + +/** + * Pick the app whose data PulseLoop should use — Oura, Samsung Health, Fitbit — then import. Also + * the onboarding step for people who don't have a PulseLoop ring ([onEnabled] moves it on). + */ +@Composable +fun HealthConnectSourceContent(onEnabled: (() -> Unit)? = null) { + val context = LocalContext.current + val scope = rememberCoroutineScope() + val services = remember { AppServices.get(context) } + val available = remember { HealthConnectSdk.availability(context) == HealthConnectAvailability.AVAILABLE } + val ring by services.db.deviceDao().currentFlow().collectAsState(initial = null) + val hasRing = ring?.let { it.id != RingIdentity.DEMO_DEVICE_ID } == true || services.bleClient.hasLastKnownRing + var enabled by remember { mutableStateOf(HealthConnectSource.isEnabled(context)) } + var source by remember { mutableStateOf(HealthConnectSource.sourcePackage(context)) } + var granted by remember { mutableStateOf>(emptySet()) } + var scanning by remember { mutableStateOf(false) } + var importing by remember { mutableStateOf(false) } + var scan by remember { mutableStateOf(null) } + var note by remember { mutableStateOf(null) } + var refresh by remember { mutableIntStateOf(0) } + + fun doScan() { + scanning = true + note = null + scope.launch { + when (val r = runCatching { ReferenceSourceScanner.scan(context) }.getOrNull()) { + is ReferenceSourceScanner.Result.Done -> scan = r + ReferenceSourceScanner.Result.Unavailable -> note = "Health Connect isn't available on this phone." + null -> note = "Couldn't read Health Connect. Try again in a moment." + } + scanning = false + } + } + + fun importNow() { + importing = true + note = null + scope.launch { + note = when (val r = runCatching { HealthConnectSourceImporter.run(context) }.getOrNull()) { + is HealthConnectSourceImporter.Outcome.Done -> "Imported ${"%,d".format(r.stored)} readings." + is HealthConnectSourceImporter.Outcome.Failed -> r.message + HealthConnectSourceImporter.Outcome.NoPermission -> "PulseLoop isn't allowed to read Health Connect any more." + HealthConnectSourceImporter.Outcome.Unavailable -> "Health Connect isn't available on this phone." + else -> "The import failed. Try again in a moment." + } + importing = false + refresh++ + } + } + + LaunchedEffect(Unit) { + granted = ReferenceSourceScanner.grantedPermissions(context) + if (granted.any { it in HealthConnectSource.readPermissions } && !enabled) doScan() + } + + val launcher = rememberLauncherForActivityResult(PermissionController.createRequestPermissionResultContract()) { got -> + granted = got + if (got.none { it in HealthConnectSource.readPermissions }) { + note = "No access granted. You can allow it in Health Connect's settings." + } else if (!enabled) doScan() + } + val canRead = granted.any { it in HealthConnectSource.readPermissions } + val missing = HealthConnectSource.request - granted + + Column(verticalArrangement = Arrangement.spacedBy(12.dp)) { + AccuracyCard { + Text("Use the device you already wear", fontSize = 15.sp, fontWeight = FontWeight.Bold, color = PulseColors.textPrimary) + Text( + "No PulseLoop ring? If your Oura, Galaxy Ring, Fitbit or watch app writes to Health Connect, PulseLoop can " + + "read it from there: sleep, heart rate, HRV, blood oxygen, steps, calories, workouts and periods. " + + "Every screen, the coach and your insights then work from that data.", + fontSize = 13.sp, color = PulseColors.textSecondary, + ) + Text( + "PulseLoop reads only the app you choose, and doesn't write that data back to Health Connect.", + fontSize = 12.sp, color = PulseColors.textMuted, + ) + if (!available) { + Text("Health Connect isn't available on this phone.", fontSize = 12.sp, color = PulseColors.danger) + } else if (hasRing && !enabled) { + Text( + "A ring is paired. Forget it in Settings → Wearable first: the two would count the same steps and nights.", + fontSize = 12.sp, color = PulseColors.warning, + ) + } else if (!canRead) { + Button(onClick = { launcher.launch(HealthConnectSource.request) }) { Text("Allow access") } + } + } + + if (enabled && source != null) { + val pkg = source!! + AccuracyCard { + Text("Using ${HealthConnectSource.label(context, pkg)}", fontSize = 15.sp, fontWeight = FontWeight.Bold, color = PulseColors.textPrimary) + val last = remember(refresh) { HealthConnectSource.lastImportAt(context) } + val count = remember(refresh) { HealthConnectSource.lastImportCount(context) } + Text( + last?.let { + "Last import " + DateTimeFormatter.ofPattern("EEE d MMM, HH:mm").format(Instant.ofEpochMilli(it).atZone(ZoneId.systemDefault())) + + " · ${"%,d".format(count)} readings" + } ?: "Not imported yet", + fontSize = 13.sp, color = PulseColors.textSecondary, + ) + Text( + "PulseLoop checks for new data every hour and whenever you open the app. A night usually appears once " + + "${HealthConnectSource.label(context, pkg)} has synced it in the morning.", + fontSize = 12.sp, color = PulseColors.textMuted, + ) + if (canRead && !HealthConnectSource.canReadInBackground(granted)) { + Text("Allow background access so imports also run while PulseLoop is closed.", fontSize = 12.sp, color = PulseColors.warning) + } + Row(horizontalArrangement = Arrangement.spacedBy(8.dp), verticalAlignment = Alignment.CenterVertically) { + Button(onClick = { importNow() }, enabled = !importing && canRead) { Text("Import now") } + if (missing.isNotEmpty()) { + OutlinedButton(onClick = { launcher.launch(HealthConnectSource.request) }) { Text("Allow more") } + } + if (importing) CircularProgressIndicator(Modifier.size(20.dp), strokeWidth = 2.dp) + } + TextButton(onClick = { + HealthConnectSource.disable(context) + enabled = false + doScan() + }) { Text("Stop using Health Connect", color = PulseColors.danger) } + } + } else if (canRead && !hasRing) { + val r = scan + if (scanning) { + Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) { + CircularProgressIndicator(Modifier.size(20.dp), strokeWidth = 2.dp) + Text("Looking for apps writing to Health Connect…", fontSize = 13.sp, color = PulseColors.textSecondary) + } + } else if (r != null) { + val usable = r.sources.filter { it.echo?.looksLikeEcho != true } + if (usable.isEmpty()) { + AccuracyCard { + Text("No app wrote health data in the last ${ReferenceSourceScanner.LOOKBACK_DAYS} days.", fontSize = 13.sp, color = PulseColors.textSecondary) + Text( + "In the Oura app: Settings → Health Connect, and turn on sharing. Then come back and look again.", + fontSize = 12.sp, color = PulseColors.textMuted, + ) + OutlinedButton(onClick = { doScan() }) { Text("Look again") } + } + } + usable.forEach { src -> + AccuracyCard { + Text(HealthConnectSource.label(context, src.packageName), fontSize = 15.sp, fontWeight = FontWeight.Bold, color = PulseColors.textPrimary) + Text(src.metrics.joinToString(", ") { it.metric.label }, fontSize = 13.sp, color = PulseColors.textSecondary) + Button(onClick = { + HealthConnectSource.enable(context, src.packageName) + enabled = true + source = src.packageName + // enable() queues the first import as background work, which outlives this + // screen; onboarding moves on at once, settings shows the pass running here. + if (onEnabled != null) onEnabled() else importNow() + }, modifier = Modifier.fillMaxWidth()) { Text("Use ${HealthConnectSource.label(context, src.packageName)}") } + } + } + } + } + note?.let { Text(it, fontSize = 12.sp, color = PulseColors.textMuted) } + } +} + +/** Settings' top card while Health Connect stands in for a ring: which app, and when it last imported. */ +@Composable +fun HealthConnectSourceHeroCard(onOpen: () -> Unit) { + val context = LocalContext.current + val pkg = HealthConnectSource.sourcePackage(context) ?: return + val last = HealthConnectSource.lastImportAt(context) + Column( + Modifier.fillMaxWidth().clip(RoundedCornerShape(12.dp)).background(PulseColors.card) + .clickable(onClick = onOpen).padding(16.dp), + verticalArrangement = Arrangement.spacedBy(4.dp), + ) { + Text("DATA SOURCE", fontSize = 11.sp, letterSpacing = 1.6.sp, color = PulseColors.textMuted) + Text("${HealthConnectSource.label(context, pkg)} via Health Connect", fontSize = 18.sp, fontWeight = FontWeight.Bold, color = PulseColors.textPrimary) + Text( + last?.let { "Last import " + DateTimeFormatter.ofPattern("EEE HH:mm").format(Instant.ofEpochMilli(it).atZone(ZoneId.systemDefault())) } + ?: "Waiting for the first import", + fontSize = 13.sp, color = PulseColors.textSecondary, + ) + } +} diff --git a/app/src/main/java/com/pulseloop/ui/screens/OnboardingScreen.kt b/app/src/main/java/com/pulseloop/ui/screens/OnboardingScreen.kt index 68a3be92..64b164f9 100644 --- a/app/src/main/java/com/pulseloop/ui/screens/OnboardingScreen.kt +++ b/app/src/main/java/com/pulseloop/ui/screens/OnboardingScreen.kt @@ -42,6 +42,7 @@ import androidx.compose.material.icons.filled.Lock import androidx.compose.material.icons.filled.MonitorHeart import androidx.compose.material.icons.filled.Paid import androidx.compose.material.icons.filled.Verified +import androidx.compose.material.icons.filled.Watch import androidx.compose.material3.Icon import androidx.compose.material3.IconButton import androidx.compose.material3.Text @@ -106,6 +107,8 @@ fun OnboardingScreen( } var path by remember { mutableStateOf(progressStore.loadPath()) } val step = path.lastOrNull() ?: OnboardingStep.WELCOME + // "I wear an Oura…": the RING step becomes the Health Connect source picker instead of pairing. + var useHealthConnect by androidx.compose.runtime.saveable.rememberSaveable { mutableStateOf(false) } fun push(next: OnboardingStep) { if (path.lastOrNull() == next) return @@ -195,6 +198,7 @@ fun OnboardingScreen( OnboardingStep.WELCOME -> WelcomeStep( getStarted = ::getStarted, exploreWithoutRing = { push(OnboardingStep.PROFILE) }, + useOtherDevice = { useHealthConnect = true; push(OnboardingStep.RING) }, permissionDenied = blePermissionDenied, openAppSettings = { context.startActivity( @@ -204,7 +208,9 @@ fun OnboardingScreen( ) }, ) - OnboardingStep.RING -> PairingScreen( + OnboardingStep.RING -> if (useHealthConnect) HealthConnectSourceStep( + next = { push(OnboardingStep.PROFILE) }, + ) else PairingScreen( bleClient = bleClient, onConnected = { scope.launch { @@ -310,6 +316,7 @@ private data class WelcomeFeature( private fun WelcomeStep( getStarted: () -> Unit, exploreWithoutRing: () -> Unit, + useOtherDevice: () -> Unit = {}, permissionDenied: Boolean = false, openAppSettings: () -> Unit = {}, ) { @@ -341,6 +348,7 @@ private fun WelcomeStep( SecondaryButton("Continue without ring", icon = Icons.Filled.GridView, onClick = exploreWithoutRing) } else { PrimaryButton("Get started", icon = Icons.Filled.ArrowForward, onClick = getStarted) + SecondaryButton("I wear an Oura or another device", icon = Icons.Filled.Watch, onClick = useOtherDevice) SecondaryButton("Explore without ring", icon = Icons.Filled.GridView, onClick = exploreWithoutRing) } } @@ -653,6 +661,23 @@ private fun SetupCompleteEyebrow() { // MARK: - Shared step chrome /** Scrolling step content above a pinned action footer (iOS `OnboardingActionFooter`). */ +/** The RING step for someone without a PulseLoop ring: read their Oura (or other) app from Health Connect. */ +@Composable +private fun HealthConnectSourceStep(next: () -> Unit) { + StepScaffold( + footer = { SecondaryButton("Skip for now", modifier = Modifier.fillMaxWidth(), onClick = next) }, + ) { + Text( + "Use your device's data", + fontSize = 26.sp, + fontWeight = FontWeight.Bold, + color = PulseColors.textPrimary, + textAlign = TextAlign.Center, + ) + HealthConnectSourceContent(onEnabled = next) + } +} + @Composable private fun StepScaffold( footer: @Composable () -> Unit, diff --git a/app/src/main/java/com/pulseloop/ui/screens/SettingsScreen.kt b/app/src/main/java/com/pulseloop/ui/screens/SettingsScreen.kt index dc5a17b2..4833cbcf 100644 --- a/app/src/main/java/com/pulseloop/ui/screens/SettingsScreen.kt +++ b/app/src/main/java/com/pulseloop/ui/screens/SettingsScreen.kt @@ -84,7 +84,10 @@ fun SettingsScreen( ) { Text("Settings", style = MaterialTheme.typography.headlineLarge, fontWeight = FontWeight.Bold) - DeviceHeroCard( + val hcSource by remember { com.pulseloop.health.source.HealthConnectSource.activeSource(context) }.collectAsState() + if (hcSource != null) { + HealthConnectSourceHeroCard(onOpen = { navigate("settings/hc-source") }) + } else DeviceHeroCard( bleState = bleState, storedDevice = storedDevice, lastSyncAt = coordinator?.lastSyncAt ?: storedDevice?.lastSyncAt, @@ -177,6 +180,9 @@ fun SettingsScreen( add(SettingsRowItem(Icons.Filled.Sync, PulseColors.success, "Health Connect") { navigate("settings/health-connect") }) + add(SettingsRowItem(Icons.Filled.Watch, PulseColors.info, "Use without a ring") { + navigate("settings/hc-source") + }) add(SettingsRowItem(Icons.Filled.Verified, PulseColors.info, "Accuracy check", accuracyTrailing) { navigate("settings/accuracy-check") }) diff --git a/app/src/main/java/com/pulseloop/ui/screens/TodayScreen.kt b/app/src/main/java/com/pulseloop/ui/screens/TodayScreen.kt index f60a5ba6..9bd83775 100644 --- a/app/src/main/java/com/pulseloop/ui/screens/TodayScreen.kt +++ b/app/src/main/java/com/pulseloop/ui/screens/TodayScreen.kt @@ -564,7 +564,9 @@ private data class Hero(val title: String, val summary: String, val chips: List< private fun deriveHero(state: TodayViewModel.TodayState, sleep: SleepViewModel.SleepState): Hero { val steps = state.steps ?: return Hero( title = "Waiting for first sync", - summary = "Sync your ring to start collecting movement, heart rate, blood oxygen, and recovery context.", + summary = if (com.pulseloop.health.source.HealthConnectSource.enabledNow) + "Importing from Health Connect. Your steps, sleep and heart rate appear once your device's app has synced." + else "Sync your ring to start collecting movement, heart rate, blood oxygen, and recovery context.", chips = listOf( ToneChip("Baseline pending", ChipTone.WARN), ToneChip(if (state.heartRate == null) "HR pending" else "HR collected", ChipTone.NEUTRAL), diff --git a/app/src/main/java/com/pulseloop/ui/viewmodels/ViewModels.kt b/app/src/main/java/com/pulseloop/ui/viewmodels/ViewModels.kt index 0658f88f..6232addf 100644 --- a/app/src/main/java/com/pulseloop/ui/viewmodels/ViewModels.kt +++ b/app/src/main/java/com/pulseloop/ui/viewmodels/ViewModels.kt @@ -728,7 +728,9 @@ class VitalsViewModel(private val db: PulseLoopDatabase, private val apiKeyStore val now = System.currentTimeMillis() val twentyFourHoursAgo = now - 24 * 3600_000L val device = db.deviceDao().current() - val caps = device?.capabilities ?: setOf( + val caps = device?.capabilities + ?: com.pulseloop.health.source.HealthConnectSource.CAPABILITIES.takeIf { com.pulseloop.health.source.HealthConnectSource.enabledNow } + ?: setOf( com.pulseloop.ring.WearableCapability.HEART_RATE, com.pulseloop.ring.WearableCapability.SPO2, com.pulseloop.ring.WearableCapability.STEPS, diff --git a/app/src/test/java/com/pulseloop/health/source/HealthConnectSourceTest.kt b/app/src/test/java/com/pulseloop/health/source/HealthConnectSourceTest.kt new file mode 100644 index 00000000..183a35f3 --- /dev/null +++ b/app/src/test/java/com/pulseloop/health/source/HealthConnectSourceTest.kt @@ -0,0 +1,84 @@ +package com.pulseloop.health.source + +import androidx.health.connect.client.records.ExerciseSessionRecord +import androidx.health.connect.client.records.SleepSessionRecord +import com.pulseloop.health.accuracy.ExportUnit +import com.pulseloop.ring.SleepStage +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Test + +/** Health Connect as the data source: how its records become the app's (docs/health-connect-source.md). */ +class HealthConnectSourceTest { + + private val t0 = 1_700_000_000_000L / 60_000L * 60_000L + private fun min(n: Int) = t0 + n * 60_000L + + @Test + fun `stages map to the app's, out of bed and awake in bed are awake, plain sleeping is unknown`() { + assertEquals(SleepStage.DEEP, HealthConnectSource.stage(SleepSessionRecord.STAGE_TYPE_DEEP)) + assertEquals(SleepStage.REM, HealthConnectSource.stage(SleepSessionRecord.STAGE_TYPE_REM)) + assertEquals(SleepStage.LIGHT, HealthConnectSource.stage(SleepSessionRecord.STAGE_TYPE_LIGHT)) + assertEquals(SleepStage.AWAKE, HealthConnectSource.stage(SleepSessionRecord.STAGE_TYPE_OUT_OF_BED)) + assertEquals(SleepStage.AWAKE, HealthConnectSource.stage(SleepSessionRecord.STAGE_TYPE_AWAKE_IN_BED)) + assertEquals(SleepStage.UNKNOWN, HealthConnectSource.stage(SleepSessionRecord.STAGE_TYPE_SLEEPING)) + } + + @Test + fun `a night becomes one stage per minute, gaps between stages are awake`() { + val stages = listOf( + HealthConnectSource.Stage(min(0), min(3), SleepSessionRecord.STAGE_TYPE_LIGHT), + HealthConnectSource.Stage(min(5), min(8), SleepSessionRecord.STAGE_TYPE_DEEP), + ) + val m = HealthConnectSource.minuteStages(min(0), min(8), stages)!! + assertEquals(8, m.size) + assertEquals(List(3) { SleepStage.LIGHT } + List(2) { SleepStage.AWAKE } + List(3) { SleepStage.DEEP }, m) + } + + @Test + fun `a minute split between stages takes the one covering most of it`() { + val stages = listOf( + HealthConnectSource.Stage(min(0), min(1) + 40_000, SleepSessionRecord.STAGE_TYPE_REM), + HealthConnectSource.Stage(min(1) + 40_000, min(2), SleepSessionRecord.STAGE_TYPE_LIGHT), + ) + assertEquals(listOf(SleepStage.REM, SleepStage.REM), HealthConnectSource.minuteStages(min(0), min(2), stages)) + } + + @Test + fun `a night with no stages is asleep throughout, an empty or over-long one is dropped`() { + assertEquals(List(90) { SleepStage.UNKNOWN }, HealthConnectSource.minuteStages(min(0), min(90), emptyList())) + assertNull(HealthConnectSource.minuteStages(min(0), min(0), emptyList())) + assertNull(HealthConnectSource.minuteStages(min(0), min(25 * 60), emptyList())) + } + + @Test + fun `workout types map back to the app's`() { + assertEquals("run", HealthConnectSource.workoutType(ExerciseSessionRecord.EXERCISE_TYPE_RUNNING_TREADMILL)) + assertEquals("cycle", HealthConnectSource.workoutType(ExerciseSessionRecord.EXERCISE_TYPE_BIKING)) + assertEquals("walk", HealthConnectSource.workoutType(ExerciseSessionRecord.EXERCISE_TYPE_WALKING)) + assertEquals("sport", HealthConnectSource.workoutType(ExerciseSessionRecord.EXERCISE_TYPE_TENNIS)) + } + + @Test + fun `the first pass reads 30 days, later ones overlap the last by 3`() { + val now = 100L * 86_400_000L + assertEquals(now - 30L * 86_400_000L, HealthConnectSource.window(null, now).first) + assertEquals(now - 4L * 86_400_000L, HealthConnectSource.window(now - 86_400_000L, now).first) + // A long gap never reads further back than Health Connect serves. + assertEquals(now - 30L * 86_400_000L, HealthConnectSource.window(now - 60L * 86_400_000L, now).first) + } + + @Test + fun `while on, every exported type is held back for all time`() { + val ex = HealthConnectSource.exportExclusions() + assertEquals(ExportUnit.entries.toSet(), ex.map { it.unit }.toSet()) + assertTrue(ex.all { it.until == null && it.overlaps(0L, 0L) && it.overlaps(Long.MAX_VALUE - 1, Long.MAX_VALUE) }) + } + + @Test + fun `imported workouts are recognised by id`() { + assertTrue(HealthConnectSource.isImportedWorkout(HealthConnectSource.WORKOUT_ID_PREFIX + "abc")) + assertTrue(!HealthConnectSource.isImportedWorkout("2b8c-uuid")) + } +} diff --git a/docs/health-connect-source.md b/docs/health-connect-source.md new file mode 100644 index 00000000..d1440b62 --- /dev/null +++ b/docs/health-connect-source.md @@ -0,0 +1,58 @@ +# Health Connect as the data source (no ring) + +For people who already wear an Oura, a Galaxy Ring, a Fitbit or a watch: PulseLoop reads that +device's app from Health Connect instead of pairing a ring, and every screen, the coach and the +insights run on that data. + +## How a user gets there + +- Onboarding, welcome step: **"I wear an Oura or another device"**. The ring step then shows the + source picker instead of pairing. +- Settings → Resources → **Use without a ring** (`settings/hc-source`). + +The screen asks for Health Connect read access, lists the apps that wrote health data in the last +week (the accuracy check's `ReferenceSourceScanner`, so PulseLoop's own exports and bridge-app +echoes are already filtered out), and the user picks one. + +## What is imported + +Each pass reads only the chosen package (`DataOrigin` filter) and turns records into the same +`PulseEvent`s a ring's history produces. Those go through `EventPersistenceSubscriber.ingest`, so +ids, tombstones, the sleep reconcile and the bucket sums all behave exactly as for a ring. + +| Health Connect | Becomes | +| --- | --- | +| Heart rate samples | `HistoryMeasurement(HEART_RATE)` | +| HRV (RMSSD) | `HistoryMeasurement(HRV)` | +| Oxygen saturation | `HistoryMeasurement(SPO2)` | +| Respiratory rate | `HistoryMeasurement(RESPIRATORY_RATE)` | +| Sleep session + stages | `SleepTimeline`, one stage per minute, `completeSession = true` | +| Steps + distance | 15-minute aggregates → `ActivityBucket` | +| Total (else active) calories | the day's `activity_daily.calories`, `source = "health_connect"` | +| Exercise sessions | finished `activity_sessions`, id `hc-`, imported once | +| Menstruation periods | `periods`, unless one is logged within 2 days of the start | + +The first pass reads 30 days, the most Health Connect serves before the first grant. Later passes +re-read from 3 days before the last one, because source apps write late (a night lands in the +morning). Passes run hourly in the background (with the background-read permission), and whenever +the app comes to the foreground. + +## Rules + +- **One source app, by package.** Without the filter, PulseLoop's own earlier exports would come + back in, and two devices' steps would land in the same 15-minute slots. +- **Exclusive with a paired ring.** The screen refuses while a ring is paired, and a ring being + identified switches the mode off (`EventPersistenceSubscriber`, `DeviceIdentified`). +- **Nothing goes back.** While the mode is on, `HealthConnectSource.exportExclusions` holds back + every `ExportUnit` for all time, through the same `ExportPause` filter the accuracy check uses, + so watermarks still advance. Imported workouts are skipped by the workout export by id prefix. + Meals and workouts recorded in PulseLoop still export. +- **A deleted import stays deleted.** Measurements and sleep use the ring's tombstones. Workouts are + imported once (the seen-id list), so deleting one doesn't bring it back. + +## Known limits + +- Health Connect has no skin temperature from most of these apps yet, so temperature cards stay + empty, and stress is derived from HRV as for rings without a stress sensor. +- Whatever the source app's own scores are (readiness, sleep score), they don't reach Health + Connect. PulseLoop computes its own from the raw data.