neoagent 2.3.1-beta.2 → 2.3.1-beta.21

package/flutter_app/android/app/src/main/kotlin/com/neoagent/flutter_app/health/HealthConnectGateway.kt

@@ -0,0 +1,280 @@
+package com.neoagent.flutter_app.health
+
+import android.content.Context
+import androidx.health.connect.client.HealthConnectClient
+import androidx.health.connect.client.HealthConnectFeatures
+import androidx.health.connect.client.permission.HealthPermission
+import androidx.health.connect.client.records.ExerciseSessionRecord
+import androidx.health.connect.client.records.HeartRateRecord
+import androidx.health.connect.client.records.Record
+import androidx.health.connect.client.records.SleepSessionRecord
+import androidx.health.connect.client.records.StepsRecord
+import androidx.health.connect.client.records.WeightRecord
+import androidx.health.connect.client.records.metadata.Device
+import androidx.health.connect.client.request.ReadRecordsRequest
+import androidx.health.connect.client.time.TimeRangeFilter
+import org.json.JSONArray
+import org.json.JSONObject
+import java.time.Duration
+import java.time.Instant
+
+class HealthConnectGateway(
+    private val context: Context,
+) {
+
+    fun getSdkStatus(): Int {
+        return HealthConnectClient.getSdkStatus(context, PROVIDER_PACKAGE_NAME)
+    }
+
+    fun isAvailable(): Boolean = getSdkStatus() == HealthConnectClient.SDK_AVAILABLE
+
+    fun getClientOrNull(): HealthConnectClient? {
+        if (!isAvailable()) return null
+        return HealthConnectClient.getOrCreate(context)
+    }
+
+    suspend fun getRequestedPermissions(client: HealthConnectClient): Set<String> {
+        val permissions = mutableSetOf(
+            HealthPermission.getReadPermission(StepsRecord::class),
+            HealthPermission.getReadPermission(HeartRateRecord::class),
+            HealthPermission.getReadPermission(SleepSessionRecord::class),
+            HealthPermission.getReadPermission(ExerciseSessionRecord::class),
+            HealthPermission.getReadPermission(WeightRecord::class),
+        )
+
+        if (
+            client.features.getFeatureStatus(
+                HealthConnectFeatures.FEATURE_READ_HEALTH_DATA_IN_BACKGROUND,
+            ) == HealthConnectFeatures.FEATURE_STATUS_AVAILABLE
+        ) {
+            permissions += HealthPermission.PERMISSION_READ_HEALTH_DATA_IN_BACKGROUND
+        }
+
+        return permissions
+    }
+
+    suspend fun collectBatch(
+        client: HealthConnectClient,
+        windowStart: Instant,
+        windowEnd: Instant,
+    ): HealthSyncBatchPayload {
+        val timeRange = TimeRangeFilter.between(windowStart, windowEnd)
+
+        val steps = readAllRecords<StepsRecord>(client, timeRange)
+        val heartRates = readAllRecords<HeartRateRecord>(client, timeRange)
+        val sleepSessions = readAllRecords<SleepSessionRecord>(client, timeRange)
+        val exerciseSessions = readAllRecords<ExerciseSessionRecord>(client, timeRange)
+        val weights = readAllRecords<WeightRecord>(client, timeRange)
+
+        val records = buildList {
+            steps.forEach { add(it.toPayload()) }
+            heartRates.forEach { add(it.toPayload()) }
+            sleepSessions.forEach { add(it.toPayload()) }
+            exerciseSessions.forEach { add(it.toPayload()) }
+            weights.forEach { add(it.toPayload()) }
+        }
+
+        val totalSteps = steps.sumOf { it.count }
+        val allHeartRateSamples = heartRates.flatMap { it.samples }
+        val sleepMinutes = sleepSessions.sumOf { Duration.between(it.startTime, it.endTime).toMinutes() }
+        val exerciseMinutes = exerciseSessions.sumOf { Duration.between(it.startTime, it.endTime).toMinutes() }
+        val latestWeightKg = weights.maxByOrNull { it.time }?.weight?.inKilograms
+
+        val summary = JSONObject().apply {
+            put("stepsTotal", totalSteps)
+            put("heartRateRecordCount", heartRates.size)
+            put("heartRateSampleCount", allHeartRateSamples.size)
+            put("heartRateAvgBpm", if (allHeartRateSamples.isEmpty()) JSONObject.NULL else allHeartRateSamples.map { it.beatsPerMinute }.average())
+            put("sleepSessionCount", sleepSessions.size)
+            put("sleepMinutes", sleepMinutes)
+            put("exerciseSessionCount", exerciseSessions.size)
+            put("exerciseMinutes", exerciseMinutes)
+            put("weightRecordCount", weights.size)
+            put("latestWeightKg", latestWeightKg ?: JSONObject.NULL)
+        }
+
+        return HealthSyncBatchPayload(
+            source = SOURCE_NAME,
+            provider = PROVIDER_PACKAGE_NAME,
+            windowStart = windowStart.toString(),
+            windowEnd = windowEnd.toString(),
+            summary = summary,
+            records = records,
+        )
+    }
+
+    private suspend inline fun <reified T : Record> readAllRecords(
+        client: HealthConnectClient,
+        timeRange: TimeRangeFilter,
+    ): List<T> {
+        val records = mutableListOf<T>()
+        var pageToken: String? = null
+
+        do {
+            val response = client.readRecords(
+                ReadRecordsRequest<T>(
+                    timeRangeFilter = timeRange,
+                    ascendingOrder = true,
+                    pageSize = PAGE_SIZE,
+                    pageToken = pageToken,
+                ),
+            )
+            records += response.records
+            pageToken = response.pageToken
+        } while (pageToken != null)
+
+        return records
+    }
+
+    private fun StepsRecord.toPayload(): HealthSyncRecordPayload {
+        return HealthSyncRecordPayload(
+            metricType = "steps",
+            recordId = metadata.id,
+            startTime = startTime.toString(),
+            endTime = endTime.toString(),
+            recordedAt = endTime.toString(),
+            numericValue = count.toDouble(),
+            textValue = null,
+            unit = "steps",
+            sourceAppId = metadata.dataOrigin.packageName.takeIf { it.isNotBlank() },
+            sourceDevice = metadata.device.toLabel(),
+            lastModifiedTime = metadata.lastModifiedTime.toString(),
+            payload = JSONObject().apply {
+                put("count", count)
+            },
+        )
+    }
+
+    private fun HeartRateRecord.toPayload(): HealthSyncRecordPayload {
+        val min = samples.minOfOrNull { it.beatsPerMinute }
+        val max = samples.maxOfOrNull { it.beatsPerMinute }
+        val avg = samples.map { it.beatsPerMinute }.average().takeIf { !it.isNaN() }
+
+        return HealthSyncRecordPayload(
+            metricType = "heart_rate",
+            recordId = metadata.id,
+            startTime = startTime.toString(),
+            endTime = endTime.toString(),
+            recordedAt = endTime.toString(),
+            numericValue = avg,
+            textValue = "${samples.size} samples",
+            unit = "bpm",
+            sourceAppId = metadata.dataOrigin.packageName.takeIf { it.isNotBlank() },
+            sourceDevice = metadata.device.toLabel(),
+            lastModifiedTime = metadata.lastModifiedTime.toString(),
+            payload = JSONObject().apply {
+                put("sampleCount", samples.size)
+                put("minBpm", min ?: JSONObject.NULL)
+                put("maxBpm", max ?: JSONObject.NULL)
+                put("avgBpm", avg ?: JSONObject.NULL)
+                put(
+                    "samples",
+                    JSONArray().apply {
+                        samples.forEach { sample ->
+                            put(
+                                JSONObject().apply {
+                                    put("time", sample.time.toString())
+                                    put("beatsPerMinute", sample.beatsPerMinute)
+                                },
+                            )
+                        }
+                    },
+                )
+            },
+        )
+    }
+
+    private fun SleepSessionRecord.toPayload(): HealthSyncRecordPayload {
+        val durationMinutes = Duration.between(startTime, endTime).toMinutes()
+        return HealthSyncRecordPayload(
+            metricType = "sleep_session",
+            recordId = metadata.id,
+            startTime = startTime.toString(),
+            endTime = endTime.toString(),
+            recordedAt = endTime.toString(),
+            numericValue = durationMinutes.toDouble(),
+            textValue = title,
+            unit = "minutes",
+            sourceAppId = metadata.dataOrigin.packageName.takeIf { it.isNotBlank() },
+            sourceDevice = metadata.device.toLabel(),
+            lastModifiedTime = metadata.lastModifiedTime.toString(),
+            payload = JSONObject().apply {
+                put("title", title ?: JSONObject.NULL)
+                put("notes", notes ?: JSONObject.NULL)
+                put("stageCount", stages.size)
+                put(
+                    "stages",
+                    JSONArray().apply {
+                        stages.forEach { stage ->
+                            put(
+                                JSONObject().apply {
+                                    put("startTime", stage.startTime.toString())
+                                    put("endTime", stage.endTime.toString())
+                                    put("stage", stage.stage)
+                                },
+                            )
+                        }
+                    },
+                )
+            },
+        )
+    }
+
+    private fun ExerciseSessionRecord.toPayload(): HealthSyncRecordPayload {
+        val durationMinutes = Duration.between(startTime, endTime).toMinutes()
+        return HealthSyncRecordPayload(
+            metricType = "exercise_session",
+            recordId = metadata.id,
+            startTime = startTime.toString(),
+            endTime = endTime.toString(),
+            recordedAt = endTime.toString(),
+            numericValue = durationMinutes.toDouble(),
+            textValue = title ?: "exercise:$exerciseType",
+            unit = "minutes",
+            sourceAppId = metadata.dataOrigin.packageName.takeIf { it.isNotBlank() },
+            sourceDevice = metadata.device.toLabel(),
+            lastModifiedTime = metadata.lastModifiedTime.toString(),
+            payload = JSONObject().apply {
+                put("exerciseType", exerciseType)
+                put("title", title ?: JSONObject.NULL)
+                put("notes", notes ?: JSONObject.NULL)
+            },
+        )
+    }
+
+    private fun WeightRecord.toPayload(): HealthSyncRecordPayload {
+        val kilograms = weight.inKilograms
+        return HealthSyncRecordPayload(
+            metricType = "weight",
+            recordId = metadata.id,
+            startTime = time.toString(),
+            endTime = null,
+            recordedAt = time.toString(),
+            numericValue = kilograms,
+            textValue = null,
+            unit = "kg",
+            sourceAppId = metadata.dataOrigin.packageName.takeIf { it.isNotBlank() },
+            sourceDevice = metadata.device.toLabel(),
+            lastModifiedTime = metadata.lastModifiedTime.toString(),
+            payload = JSONObject().apply {
+                put("kilograms", kilograms)
+            },
+        )
+    }
+
+    private fun Device?.toLabel(): String? {
+        if (this == null) return null
+        return when {
+            !manufacturer.isNullOrBlank() && !model.isNullOrBlank() -> "$manufacturer $model"
+            !manufacturer.isNullOrBlank() -> manufacturer
+            !model.isNullOrBlank() -> model
+            else -> type.toString()
+        }
+    }
+
+    companion object {
+        private const val PAGE_SIZE = 500
+        private const val PROVIDER_PACKAGE_NAME = "com.google.android.apps.healthdata"
+        private const val SOURCE_NAME = "android-health-connect"
+    }
+}

package/flutter_app/android/app/src/main/kotlin/com/neoagent/flutter_app/health/HealthSyncNotifications.kt

@@ -0,0 +1,113 @@
+package com.neoagent.flutter_app.health
+
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.content.pm.ServiceInfo
+import android.os.Build
+import androidx.core.app.NotificationCompat
+import androidx.core.app.NotificationManagerCompat
+import androidx.work.ForegroundInfo
+import com.neoagent.flutter_app.MainActivity
+import com.neoagent.flutter_app.R
+
+object HealthSyncNotifications {
+    private const val ACTIVE_CHANNEL_ID = "neoagent_health_sync_active"
+    private const val ALERT_CHANNEL_ID = "neoagent_health_sync_alerts"
+    private const val ACTIVE_NOTIFICATION_ID = 4201
+    private const val ALERT_NOTIFICATION_ID = 4202
+
+    fun register(context: Context) {
+        val manager =
+            context.getSystemService(NotificationManager::class.java) ?: return
+
+        manager.createNotificationChannel(
+            NotificationChannel(
+                ACTIVE_CHANNEL_ID,
+                "NeoAgent Health Sync",
+                NotificationManager.IMPORTANCE_MIN,
+            ).apply {
+                description =
+                    "Low-key notification shown while NeoAgent health sync is actively running."
+                setShowBadge(false)
+            },
+        )
+
+        manager.createNotificationChannel(
+            NotificationChannel(
+                ALERT_CHANNEL_ID,
+                "NeoAgent Health Alerts",
+                NotificationManager.IMPORTANCE_LOW,
+            ).apply {
+                description =
+                    "Shown when background health sync needs attention."
+                setShowBadge(false)
+                enableVibration(false)
+                setSound(null, null)
+            },
+        )
+    }
+
+    fun foregroundInfo(
+        context: Context,
+        message: String,
+    ): ForegroundInfo {
+        val notification =
+            NotificationCompat.Builder(context, ACTIVE_CHANNEL_ID)
+                .setSmallIcon(R.mipmap.ic_launcher)
+                .setContentTitle("NeoAgent health sync")
+                .setContentText(message)
+                .setOngoing(true)
+                .setSilent(true)
+                .setOnlyAlertOnce(true)
+                .setCategory(NotificationCompat.CATEGORY_SERVICE)
+                .setPriority(NotificationCompat.PRIORITY_MIN)
+                .setContentIntent(buildLaunchIntent(context))
+                .build()
+
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            ForegroundInfo(
+                ACTIVE_NOTIFICATION_ID,
+                notification,
+                ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC,
+            )
+        } else {
+            ForegroundInfo(ACTIVE_NOTIFICATION_ID, notification)
+        }
+    }
+
+    fun showFailure(context: Context, message: String) {
+        NotificationManagerCompat.from(context).notify(
+            ALERT_NOTIFICATION_ID,
+            NotificationCompat.Builder(context, ALERT_CHANNEL_ID)
+                .setSmallIcon(android.R.drawable.stat_sys_warning)
+                .setContentTitle("Health sync needs attention")
+                .setContentText(message)
+                .setStyle(NotificationCompat.BigTextStyle().bigText(message))
+                .setAutoCancel(true)
+                .setOnlyAlertOnce(true)
+                .setSilent(true)
+                .setPriority(NotificationCompat.PRIORITY_LOW)
+                .setContentIntent(buildLaunchIntent(context))
+                .build(),
+        )
+    }
+
+    fun clearFailure(context: Context) {
+        NotificationManagerCompat.from(context).cancel(ALERT_NOTIFICATION_ID)
+    }
+
+    private fun buildLaunchIntent(context: Context): PendingIntent {
+        val intent = Intent(context, MainActivity::class.java).apply {
+            flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
+        }
+        return PendingIntent.getActivity(
+            context,
+            0,
+            intent,
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE,
+        )
+    }
+}

package/flutter_app/android/app/src/main/kotlin/com/neoagent/flutter_app/health/HealthSyncPayload.kt

@@ -0,0 +1,57 @@
+package com.neoagent.flutter_app.health
+
+import org.json.JSONArray
+import org.json.JSONObject
+
+data class HealthSyncRecordPayload(
+    val metricType: String,
+    val recordId: String,
+    val startTime: String?,
+    val endTime: String?,
+    val recordedAt: String?,
+    val numericValue: Double?,
+    val textValue: String?,
+    val unit: String?,
+    val sourceAppId: String?,
+    val sourceDevice: String?,
+    val lastModifiedTime: String?,
+    val payload: JSONObject,
+) {
+    fun toJson(): JSONObject = JSONObject().apply {
+        put("metricType", metricType)
+        put("recordId", recordId)
+        put("startTime", startTime)
+        put("endTime", endTime)
+        put("recordedAt", recordedAt)
+        put("numericValue", numericValue)
+        put("textValue", textValue)
+        put("unit", unit)
+        put("sourceAppId", sourceAppId)
+        put("sourceDevice", sourceDevice)
+        put("lastModifiedTime", lastModifiedTime)
+        put("payload", payload)
+    }
+}
+
+data class HealthSyncBatchPayload(
+    val source: String,
+    val provider: String,
+    val windowStart: String,
+    val windowEnd: String,
+    val summary: JSONObject,
+    val records: List<HealthSyncRecordPayload>,
+) {
+    fun toJson(): JSONObject = JSONObject().apply {
+        put("source", source)
+        put("provider", provider)
+        put("windowStart", windowStart)
+        put("windowEnd", windowEnd)
+        put("summary", summary)
+        put(
+            "records",
+            JSONArray().apply {
+                records.forEach { put(it.toJson()) }
+            },
+        )
+    }
+}

package/flutter_app/android/app/src/main/kotlin/com/neoagent/flutter_app/health/HealthSyncScheduler.kt

@@ -0,0 +1,78 @@
+package com.neoagent.flutter_app.health
+
+import android.content.Context
+import androidx.work.Constraints
+import androidx.work.ExistingPeriodicWorkPolicy
+import androidx.work.ExistingWorkPolicy
+import androidx.work.NetworkType
+import androidx.work.OneTimeWorkRequestBuilder
+import androidx.work.PeriodicWorkRequestBuilder
+import androidx.work.WorkManager
+import java.util.concurrent.TimeUnit
+
+internal object HealthSyncPrefs {
+    const val PREFS_NAME = "neoagent_health_sync"
+    const val KEY_ENABLED = "enabled"
+    const val KEY_BACKEND_URL = "backend_url"
+    const val KEY_SESSION_COOKIE = "session_cookie"
+    const val KEY_LAST_SUCCESS_AT = "last_success_at"
+    const val KEY_CONSECUTIVE_FAILURES = "consecutive_failures"
+    const val KEY_LAST_ERROR = "last_error"
+
+    fun read(context: Context) =
+        context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
+}
+
+class HealthSyncScheduler(private val context: Context) {
+
+    fun configure(
+        enabled: Boolean,
+        backendUrl: String,
+        sessionCookie: String,
+    ) {
+        HealthSyncNotifications.register(context)
+        HealthSyncPrefs.read(context)
+            .edit()
+            .putBoolean(HealthSyncPrefs.KEY_ENABLED, enabled)
+            .putString(HealthSyncPrefs.KEY_BACKEND_URL, backendUrl.trim())
+            .putString(HealthSyncPrefs.KEY_SESSION_COOKIE, sessionCookie.trim())
+            .apply()
+
+        val workManager = WorkManager.getInstance(context)
+        if (!enabled) {
+            HealthSyncNotifications.clearFailure(context)
+            workManager.cancelUniqueWork(UNIQUE_PERIODIC_WORK)
+            workManager.cancelUniqueWork(UNIQUE_IMMEDIATE_WORK)
+            return
+        }
+
+        val constraints = Constraints.Builder()
+            .setRequiredNetworkType(NetworkType.CONNECTED)
+            .build()
+
+        val periodicRequest =
+            PeriodicWorkRequestBuilder<HealthSyncWorker>(15, TimeUnit.MINUTES)
+                .setConstraints(constraints)
+                .build()
+
+        val immediateRequest = OneTimeWorkRequestBuilder<HealthSyncWorker>()
+            .setConstraints(constraints)
+            .build()
+
+        workManager.enqueueUniquePeriodicWork(
+            UNIQUE_PERIODIC_WORK,
+            ExistingPeriodicWorkPolicy.UPDATE,
+            periodicRequest,
+        )
+        workManager.enqueueUniqueWork(
+            UNIQUE_IMMEDIATE_WORK,
+            ExistingWorkPolicy.REPLACE,
+            immediateRequest,
+        )
+    }
+
+    companion object {
+        private const val UNIQUE_PERIODIC_WORK = "neoagent_health_periodic_sync"
+        private const val UNIQUE_IMMEDIATE_WORK = "neoagent_health_immediate_sync"
+    }
+}