@capgo/capacitor-health 7.0.0

package/android/src/main/java/app/capgo/plugin/health/HealthManager.kt

@@ -0,0 +1,280 @@
+package app.capgo.plugin.health
+
+import androidx.health.connect.client.HealthConnectClient
+import androidx.health.connect.client.records.ActiveCaloriesBurnedRecord
+import androidx.health.connect.client.records.DistanceRecord
+import androidx.health.connect.client.records.HeartRateRecord
+import androidx.health.connect.client.records.Record
+import androidx.health.connect.client.records.StepsRecord
+import androidx.health.connect.client.records.WeightRecord
+import androidx.health.connect.client.request.ReadRecordsRequest
+import androidx.health.connect.client.time.TimeRangeFilter
+import androidx.health.connect.client.units.Energy
+import androidx.health.connect.client.units.Length
+import androidx.health.connect.client.units.Mass
+import androidx.health.connect.client.records.metadata.Metadata
+import com.getcapacitor.JSArray
+import com.getcapacitor.JSObject
+import java.time.Instant
+import java.time.ZoneId
+import java.time.ZoneOffset
+import java.time.format.DateTimeFormatter
+import kotlin.math.min
+import kotlin.collections.buildSet
+
+class HealthManager {
+
+    private val formatter: DateTimeFormatter = DateTimeFormatter.ISO_INSTANT
+
+    fun permissionsFor(readTypes: Collection<HealthDataType>, writeTypes: Collection<HealthDataType>): Set<String> = buildSet {
+        readTypes.forEach { add(it.readPermission) }
+        writeTypes.forEach { add(it.writePermission) }
+    }
+
+    suspend fun authorizationStatus(
+        client: HealthConnectClient,
+        readTypes: Collection<HealthDataType>,
+        writeTypes: Collection<HealthDataType>
+    ): JSObject {
+        val granted = client.permissionController.getGrantedPermissions()
+
+        val readAuthorized = JSArray()
+        val readDenied = JSArray()
+        readTypes.forEach { type ->
+            if (granted.contains(type.readPermission)) {
+                readAuthorized.put(type.identifier)
+            } else {
+                readDenied.put(type.identifier)
+            }
+        }
+
+        val writeAuthorized = JSArray()
+        val writeDenied = JSArray()
+        writeTypes.forEach { type ->
+            if (granted.contains(type.writePermission)) {
+                writeAuthorized.put(type.identifier)
+            } else {
+                writeDenied.put(type.identifier)
+            }
+        }
+
+        return JSObject().apply {
+            put("readAuthorized", readAuthorized)
+            put("readDenied", readDenied)
+            put("writeAuthorized", writeAuthorized)
+            put("writeDenied", writeDenied)
+        }
+    }
+
+    suspend fun readSamples(
+        client: HealthConnectClient,
+        dataType: HealthDataType,
+        startTime: Instant,
+        endTime: Instant,
+        limit: Int,
+        ascending: Boolean
+    ): JSArray {
+        val samples = mutableListOf<Pair<Instant, JSObject>>()
+        when (dataType) {
+            HealthDataType.STEPS -> readRecords(client, StepsRecord::class, startTime, endTime, limit) { record ->
+                val payload = createSamplePayload(
+                    dataType,
+                    record.startTime,
+                    record.endTime,
+                    record.count.toDouble(),
+                    record.metadata
+                )
+                samples.add(record.startTime to payload)
+            }
+            HealthDataType.DISTANCE -> readRecords(client, DistanceRecord::class, startTime, endTime, limit) { record ->
+                val payload = createSamplePayload(
+                    dataType,
+                    record.startTime,
+                    record.endTime,
+                    record.distance.inMeters,
+                    record.metadata
+                )
+                samples.add(record.startTime to payload)
+            }
+            HealthDataType.CALORIES -> readRecords(client, ActiveCaloriesBurnedRecord::class, startTime, endTime, limit) { record ->
+                val payload = createSamplePayload(
+                    dataType,
+                    record.startTime,
+                    record.endTime,
+                    record.energy.inKilocalories,
+                    record.metadata
+                )
+                samples.add(record.startTime to payload)
+            }
+            HealthDataType.WEIGHT -> readRecords(client, WeightRecord::class, startTime, endTime, limit) { record ->
+                val payload = createSamplePayload(
+                    dataType,
+                    record.time,
+                    record.time,
+                    record.weight.inKilograms,
+                    record.metadata
+                )
+                samples.add(record.time to payload)
+            }
+            HealthDataType.HEART_RATE -> readRecords(client, HeartRateRecord::class, startTime, endTime, limit) { record ->
+                record.samples.forEach { sample ->
+                    val payload = createSamplePayload(
+                        dataType,
+                        sample.time,
+                        sample.time,
+                        sample.beatsPerMinute.toDouble(),
+                        record.metadata
+                    )
+                    samples.add(sample.time to payload)
+                }
+            }
+        }
+
+        val sorted = samples.sortedBy { it.first }
+        val ordered = if (ascending) sorted else sorted.asReversed()
+        val limited = if (limit > 0) ordered.take(limit) else ordered
+
+        val array = JSArray()
+        limited.forEach { array.put(it.second) }
+        return array
+    }
+
+    private suspend fun <T : Record> readRecords(
+        client: HealthConnectClient,
+        recordClass: kotlin.reflect.KClass<T>,
+        startTime: Instant,
+        endTime: Instant,
+        limit: Int,
+        consumer: (record: T) -> Unit
+    ) {
+        var pageToken: String? = null
+        val pageSize = if (limit > 0) min(limit, MAX_PAGE_SIZE) else DEFAULT_PAGE_SIZE
+        var fetched = 0
+
+        do {
+            val request = ReadRecordsRequest(
+                recordType = recordClass,
+                timeRangeFilter = TimeRangeFilter.between(startTime, endTime),
+                pageSize = pageSize,
+                pageToken = pageToken
+            )
+            val response = client.readRecords(request)
+            response.records.forEach { record ->
+                consumer(record)
+            }
+            fetched += response.records.size
+            pageToken = response.pageToken
+        } while (pageToken != null && (limit <= 0 || fetched < limit))
+    }
+
+    @Suppress("UNUSED_PARAMETER")
+    suspend fun saveSample(
+        client: HealthConnectClient,
+        dataType: HealthDataType,
+        value: Double,
+        startTime: Instant,
+        endTime: Instant,
+        metadata: Map<String, String>?
+    ) {
+        when (dataType) {
+            HealthDataType.STEPS -> {
+                val record = StepsRecord(
+                    startTime = startTime,
+                    startZoneOffset = zoneOffset(startTime),
+                    endTime = endTime,
+                    endZoneOffset = zoneOffset(endTime),
+                    count = value.toLong().coerceAtLeast(0)
+                )
+                client.insertRecords(listOf(record))
+            }
+            HealthDataType.DISTANCE -> {
+                val record = DistanceRecord(
+                    startTime = startTime,
+                    startZoneOffset = zoneOffset(startTime),
+                    endTime = endTime,
+                    endZoneOffset = zoneOffset(endTime),
+                    distance = Length.meters(value)
+                )
+                client.insertRecords(listOf(record))
+            }
+            HealthDataType.CALORIES -> {
+                val record = ActiveCaloriesBurnedRecord(
+                    startTime = startTime,
+                    startZoneOffset = zoneOffset(startTime),
+                    endTime = endTime,
+                    endZoneOffset = zoneOffset(endTime),
+                    energy = Energy.kilocalories(value)
+                )
+                client.insertRecords(listOf(record))
+            }
+            HealthDataType.WEIGHT -> {
+                val record = WeightRecord(
+                    time = startTime,
+                    zoneOffset = zoneOffset(startTime),
+                    weight = Mass.kilograms(value)
+                )
+                client.insertRecords(listOf(record))
+            }
+            HealthDataType.HEART_RATE -> {
+                val samples = listOf(HeartRateRecord.Sample(time = startTime, beatsPerMinute = value.toBpmLong()))
+                val record = HeartRateRecord(
+                    startTime = startTime,
+                    startZoneOffset = zoneOffset(startTime),
+                    endTime = endTime,
+                    endZoneOffset = zoneOffset(endTime),
+                    samples = samples
+                )
+                client.insertRecords(listOf(record))
+            }
+        }
+    }
+
+    fun parseInstant(value: String?, defaultInstant: Instant): Instant {
+        if (value.isNullOrBlank()) {
+            return defaultInstant
+        }
+        return Instant.parse(value)
+    }
+
+    private fun createSamplePayload(
+        dataType: HealthDataType,
+        startTime: Instant,
+        endTime: Instant,
+        value: Double,
+        metadata: Metadata
+    ): JSObject {
+        val payload = JSObject()
+        payload.put("dataType", dataType.identifier)
+        payload.put("value", value)
+        payload.put("unit", dataType.unit)
+        payload.put("startDate", formatter.format(startTime))
+        payload.put("endDate", formatter.format(endTime))
+
+        val dataOrigin = metadata.dataOrigin
+        payload.put("sourceId", dataOrigin.packageName)
+        payload.put("sourceName", dataOrigin.packageName)
+        metadata.device?.let { device ->
+            val manufacturer = device.manufacturer?.takeIf { it.isNotBlank() }
+            val model = device.model?.takeIf { it.isNotBlank() }
+            val label = listOfNotNull(manufacturer, model).joinToString(" ").trim()
+            if (label.isNotEmpty()) {
+                payload.put("sourceName", label)
+            }
+        }
+
+        return payload
+    }
+
+    private fun zoneOffset(instant: Instant): ZoneOffset? {
+        return ZoneId.systemDefault().rules.getOffset(instant)
+    }
+
+    private fun Double.toBpmLong(): Long {
+        return java.lang.Math.round(this.coerceAtLeast(0.0))
+    }
+
+    companion object {
+        private const val DEFAULT_PAGE_SIZE = 100
+        private const val MAX_PAGE_SIZE = 500
+    }
+}

package/android/src/main/java/app/capgo/plugin/health/HealthPlugin.kt

@@ -0,0 +1,316 @@
+package app.capgo.plugin.health
+
+import android.app.Activity
+import android.content.Intent
+import com.getcapacitor.JSArray
+import com.getcapacitor.JSObject
+import com.getcapacitor.Plugin
+import com.getcapacitor.PluginCall
+import com.getcapacitor.PluginMethod
+import com.getcapacitor.annotation.CapacitorPlugin
+import androidx.health.connect.client.HealthConnectClient
+import androidx.health.connect.client.contracts.HealthPermissionsRequestContract
+import java.time.Instant
+import java.time.Duration
+import java.time.format.DateTimeParseException
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+
+@CapacitorPlugin(name = "Health")
+class HealthPlugin : Plugin() {
+    private val manager = HealthManager()
+    private val pluginScope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
+    private var pendingAuthorization: PendingAuthorization? = null
+    private val permissionRequestContract = HealthPermissionsRequestContract()
+
+    override fun handleOnDestroy() {
+        super.handleOnDestroy()
+        pluginScope.cancel()
+    }
+
+    @PluginMethod
+    fun isAvailable(call: PluginCall) {
+        val status = HealthConnectClient.getSdkStatus(context)
+        call.resolve(availabilityPayload(status))
+    }
+
+    @PluginMethod
+    fun requestAuthorization(call: PluginCall) {
+        val readTypes = try {
+            parseTypeList(call, "read")
+        } catch (e: IllegalArgumentException) {
+            call.reject(e.message, null, e)
+            return
+        }
+
+        val writeTypes = try {
+            parseTypeList(call, "write")
+        } catch (e: IllegalArgumentException) {
+            call.reject(e.message, null, e)
+            return
+        }
+
+        pluginScope.launch {
+            val client = getClientOrReject(call) ?: return@launch
+            val permissions = manager.permissionsFor(readTypes, writeTypes)
+
+            if (permissions.isEmpty()) {
+                val status = manager.authorizationStatus(client, readTypes, writeTypes)
+                call.resolve(status)
+                return@launch
+            }
+
+            val granted = client.permissionController.getGrantedPermissions()
+            if (granted.containsAll(permissions)) {
+                val status = manager.authorizationStatus(client, readTypes, writeTypes)
+                call.resolve(status)
+                return@launch
+            }
+
+            val activity = activity
+            if (activity == null) {
+                call.reject("Unable to request authorization without an active Activity.")
+                return@launch
+            }
+
+            if (pendingAuthorization != null) {
+                call.reject("Another authorization request is already running. Try again later.")
+                return@launch
+            }
+
+            val intent = withContext(Dispatchers.IO) {
+                permissionRequestContract.createIntent(activity, permissions)
+            }
+            pendingAuthorization = PendingAuthorization(call, readTypes, writeTypes)
+            call.setKeepAlive(true)
+
+            withContext(Dispatchers.Main) {
+                try {
+                    activity.startActivityForResult(intent, REQUEST_AUTHORIZATION)
+                } catch (e: Exception) {
+                    pendingAuthorization = null
+                    call.setKeepAlive(false)
+                    call.reject("Failed to launch Health Connect permission request.", null, e)
+                }
+            }
+        }
+    }
+
+    @PluginMethod
+    fun checkAuthorization(call: PluginCall) {
+        val readTypes = try {
+            parseTypeList(call, "read")
+        } catch (e: IllegalArgumentException) {
+            call.reject(e.message, null, e)
+            return
+        }
+
+        val writeTypes = try {
+            parseTypeList(call, "write")
+        } catch (e: IllegalArgumentException) {
+            call.reject(e.message, null, e)
+            return
+        }
+
+        pluginScope.launch {
+            val client = getClientOrReject(call) ?: return@launch
+            val status = manager.authorizationStatus(client, readTypes, writeTypes)
+            call.resolve(status)
+        }
+    }
+
+    @PluginMethod
+    fun readSamples(call: PluginCall) {
+        val identifier = call.getString("dataType")
+        if (identifier.isNullOrBlank()) {
+            call.reject("dataType is required")
+            return
+        }
+
+        val dataType = HealthDataType.from(identifier)
+        if (dataType == null) {
+            call.reject("Unsupported data type: $identifier")
+            return
+        }
+
+        val limit = (call.getInt("limit") ?: DEFAULT_LIMIT).coerceAtLeast(0)
+        val ascending = call.getBoolean("ascending") ?: false
+
+        val startInstant = try {
+            manager.parseInstant(call.getString("startDate"), Instant.now().minus(DEFAULT_PAST_DURATION))
+        } catch (e: DateTimeParseException) {
+            call.reject(e.message, null, e)
+            return
+        }
+
+        val endInstant = try {
+            manager.parseInstant(call.getString("endDate"), Instant.now())
+        } catch (e: DateTimeParseException) {
+            call.reject(e.message, null, e)
+            return
+        }
+
+        if (endInstant.isBefore(startInstant)) {
+            call.reject("endDate must be greater than or equal to startDate")
+            return
+        }
+
+        pluginScope.launch {
+            val client = getClientOrReject(call) ?: return@launch
+            try {
+                val samples = manager.readSamples(client, dataType, startInstant, endInstant, limit, ascending)
+                val result = JSObject().apply { put("samples", samples) }
+                call.resolve(result)
+            } catch (e: Exception) {
+                call.reject(e.message ?: "Failed to read samples.", null, e)
+            }
+        }
+    }
+
+    @PluginMethod
+    fun saveSample(call: PluginCall) {
+        val identifier = call.getString("dataType")
+        if (identifier.isNullOrBlank()) {
+            call.reject("dataType is required")
+            return
+        }
+
+        val dataType = HealthDataType.from(identifier)
+        if (dataType == null) {
+            call.reject("Unsupported data type: $identifier")
+            return
+        }
+
+        val value = call.getDouble("value")
+        if (value == null) {
+            call.reject("value is required")
+            return
+        }
+
+        val unit = call.getString("unit")
+        if (unit != null && unit != dataType.unit) {
+            call.reject("Unsupported unit $unit for ${dataType.identifier}. Expected ${dataType.unit}.")
+            return
+        }
+
+        val startInstant = try {
+            manager.parseInstant(call.getString("startDate"), Instant.now())
+        } catch (e: DateTimeParseException) {
+            call.reject(e.message, null, e)
+            return
+        }
+
+        val endInstant = try {
+            manager.parseInstant(call.getString("endDate"), startInstant)
+        } catch (e: DateTimeParseException) {
+            call.reject(e.message, null, e)
+            return
+        }
+
+        if (endInstant.isBefore(startInstant)) {
+            call.reject("endDate must be greater than or equal to startDate")
+            return
+        }
+
+        val metadataObj = call.getObject("metadata")
+        val metadata = metadataObj?.let { obj ->
+            val iterator = obj.keys()
+            val map = mutableMapOf<String, String>()
+            while (iterator.hasNext()) {
+                val key = iterator.next()
+                val rawValue = obj.opt(key)
+                if (rawValue is String) {
+                    map[key] = rawValue
+                }
+            }
+            map.takeIf { it.isNotEmpty() }
+        }
+
+        pluginScope.launch {
+            val client = getClientOrReject(call) ?: return@launch
+            try {
+                manager.saveSample(client, dataType, value, startInstant, endInstant, metadata)
+                call.resolve()
+            } catch (e: Exception) {
+                call.reject(e.message ?: "Failed to save sample.", null, e)
+            }
+        }
+    }
+
+    override fun handleOnActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
+        super.handleOnActivityResult(requestCode, resultCode, data)
+        if (requestCode != REQUEST_AUTHORIZATION) {
+            return
+        }
+
+        val pending = pendingAuthorization ?: return
+        pendingAuthorization = null
+        pending.call.setKeepAlive(false)
+
+        pluginScope.launch {
+            val client = getClientOrReject(pending.call) ?: return@launch
+            if (resultCode != Activity.RESULT_OK) {
+                pending.call.reject("Authorization request was cancelled or denied.")
+                return@launch
+            }
+
+            val status = manager.authorizationStatus(client, pending.readTypes, pending.writeTypes)
+            pending.call.resolve(status)
+        }
+    }
+
+    private fun parseTypeList(call: PluginCall, key: String): List<HealthDataType> {
+        val array = call.getArray(key) ?: JSArray()
+        val result = mutableListOf<HealthDataType>()
+        for (i in 0 until array.length()) {
+            val identifier = array.optString(i, null) ?: continue
+            val dataType = HealthDataType.from(identifier)
+                ?: throw IllegalArgumentException("Unsupported data type: $identifier")
+            result.add(dataType)
+        }
+        return result
+    }
+
+    private fun getClientOrReject(call: PluginCall): HealthConnectClient? {
+        val status = HealthConnectClient.getSdkStatus(context)
+        if (status != HealthConnectClient.SDK_AVAILABLE) {
+            call.reject(availabilityReason(status))
+            return null
+        }
+        return HealthConnectClient.getOrCreate(context)
+    }
+
+    private fun availabilityPayload(status: Int): JSObject {
+        val payload = JSObject()
+        payload.put("platform", "android")
+        payload.put("available", status == HealthConnectClient.SDK_AVAILABLE)
+        if (status != HealthConnectClient.SDK_AVAILABLE) {
+            payload.put("reason", availabilityReason(status))
+        }
+        return payload
+    }
+
+    private fun availabilityReason(status: Int): String {
+        return when (status) {
+            HealthConnectClient.SDK_UNAVAILABLE_PROVIDER_UPDATE_REQUIRED -> "Health Connect needs an update."
+            HealthConnectClient.SDK_UNAVAILABLE -> "Health Connect is unavailable on this device."
+            else -> "Health Connect availability unknown."
+        }
+    }
+
+    private data class PendingAuthorization(
+        val call: PluginCall,
+        val readTypes: List<HealthDataType>,
+        val writeTypes: List<HealthDataType>
+    )
+
+    companion object {
+        private const val REQUEST_AUTHORIZATION = 9501
+        private const val DEFAULT_LIMIT = 100
+        private val DEFAULT_PAST_DURATION: Duration = Duration.ofDays(1)
+    }
+}