package `in`.caresoft.carepulse.connect.health import android.content.Context import androidx.health.connect.client.HealthConnectClient import androidx.health.connect.client.permission.HealthPermission import androidx.health.connect.client.records.* import androidx.health.connect.client.request.AggregateRequest import androidx.health.connect.client.request.ReadRecordsRequest import androidx.health.connect.client.time.TimeRangeFilter import `in`.caresoft.carepulse.connect.Prefs import `in`.caresoft.carepulse.connect.data.ReadingQueue import org.json.JSONArray import org.json.JSONObject import java.time.Instant import java.time.ZoneId import java.time.temporal.ChronoUnit import kotlin.reflect.KClass /** * Reads what the patient's watch / apps write to Android Health Connect (with the patient's permission) * and queues it for CarePulse. Spot vitals (BP, SpO2, glucose, weight, temperature) are sent as they are; * heart rate is thinned to one value per 15 minutes; steps, sleep and active energy are sent as daily totals. * Glucose from a CGM app arrives here only if that app writes to Health Connect on this phone. */ class HealthConnectSync(private val ctx: Context) { companion object { val TYPES: List> = listOf( BloodPressureRecord::class, HeartRateRecord::class, RestingHeartRateRecord::class, OxygenSaturationRecord::class, BloodGlucoseRecord::class, WeightRecord::class, BodyTemperatureRecord::class, RespiratoryRateRecord::class, HeartRateVariabilityRmssdRecord::class, StepsRecord::class, SleepSessionRecord::class, ActiveCaloriesBurnedRecord::class) val PERMISSIONS: Set = TYPES.map { HealthPermission.getReadPermission(it) }.toSet() + setOf("android.permission.health.READ_HEALTH_DATA_IN_BACKGROUND") private const val FIRST_SYNC_DAYS = 14L fun available(ctx: Context) = HealthConnectClient.getSdkStatus(ctx) == HealthConnectClient.SDK_AVAILABLE } private val client by lazy { HealthConnectClient.getOrCreate(ctx) } private val prefs = Prefs.get(ctx) suspend fun granted(): Set = client.permissionController.getGrantedPermissions() /** Read everything since the last sync (overlapping by an hour; the server ignores duplicates) and queue it. Returns values queued. */ suspend fun sync(): Int { val granted = granted() val now = Instant.now() val since = prefs.healthSyncedAt?.let { Instant.ofEpochMilli(it).minus(1, ChronoUnit.HOURS) } ?: now.minus(FIRST_SYNC_DAYS, ChronoUnit.DAYS) val range = TimeRangeFilter.between(since, now) val out = JSONArray() fun add(param: String, value: Double, at: Instant, unit: String? = null) { out.put(JSONObject().put("param", param).put("value", value).put("measured_at", at.toString()).put("context", if (param == "glucose") "cgm" else "wearable") .also { if (unit != null) it.put("unit", unit) }) } suspend fun read(type: KClass): List = if (HealthPermission.getReadPermission(type) in granted) client.readRecords(ReadRecordsRequest(type, range)).records else emptyList() read(BloodPressureRecord::class).forEach { add("bp_sys", it.systolic.inMillimetersOfMercury, it.time); add("bp_dia", it.diastolic.inMillimetersOfMercury, it.time) } read(OxygenSaturationRecord::class).forEach { add("spo2", it.percentage.value, it.time) } read(BloodGlucoseRecord::class).forEach { add("glucose", it.level.inMilligramsPerDeciliter, it.time, "mg/dL") } read(WeightRecord::class).forEach { add("weight", it.weight.inKilograms, it.time, "kg") } read(BodyTemperatureRecord::class).forEach { add("temp", it.temperature.inCelsius, it.time, "Cel") } read(RespiratoryRateRecord::class).forEach { add("rr", it.rate, it.time) } read(RestingHeartRateRecord::class).forEach { add("resting_hr", it.beatsPerMinute.toDouble(), it.time) } read(HeartRateVariabilityRmssdRecord::class).forEach { add("hrv_rmssd", it.heartRateVariabilityMillis, it.time) } // Heart rate: watches write a sample every few seconds; keep the last value of each 15-minute slot read(HeartRateRecord::class).flatMap { it.samples }.groupBy { it.time.epochSecond / 900 }.values .map { it.maxBy { s -> s.time } }.forEach { add("hr", it.beatsPerMinute.toDouble(), it.time) } // Daily totals for completed days (today is sent tomorrow) val zone = ZoneId.systemDefault() var day = since.atZone(zone).toLocalDate() val today = now.atZone(zone).toLocalDate() while (day.isBefore(today)) { val s = day.atStartOfDay(zone).toInstant(); val e = day.plusDays(1).atStartOfDay(zone).toInstant() val metrics = buildSet { if (HealthPermission.getReadPermission(StepsRecord::class) in granted) add(StepsRecord.COUNT_TOTAL) if (HealthPermission.getReadPermission(ActiveCaloriesBurnedRecord::class) in granted) add(ActiveCaloriesBurnedRecord.ACTIVE_CALORIES_TOTAL) } if (metrics.isNotEmpty()) { val agg = client.aggregate(AggregateRequest(metrics, TimeRangeFilter.between(s, e))) agg[StepsRecord.COUNT_TOTAL]?.let { add("steps", it.toDouble(), e.minusSeconds(60)) } agg[ActiveCaloriesBurnedRecord.ACTIVE_CALORIES_TOTAL]?.let { add("active_energy", it.inKilocalories, e.minusSeconds(60)) } } day = day.plusDays(1) } // Sleep: hours of each session, dated at wake-up read(SleepSessionRecord::class).forEach { add("sleep_hours", (it.endTime.epochSecond - it.startTime.epochSecond) / 3600.0, it.endTime) } if (out.length() > 0) { val q = ReadingQueue(ctx) // Chunks of 400; marked "history" so old values are flagged but do not page the care team for (i in 0 until out.length() step 400) { val part = JSONArray(); for (k in i until minOf(out.length(), i + 400)) part.put(out.get(k)) q.add(JSONObject().put("device", JSONObject().put("serial", "HC-" + android.os.Build.MODEL.take(30)).put("manufacturer", "Health Connect").put("model", android.os.Build.MODEL)) .put("history", true).put("readings", part), "${part.length()} values from Health Connect") } q.log("Health Connect: ${out.length()} values queued") } prefs.healthSyncedAt = now.toEpochMilli() return out.length() } }