@flomentumsolutions/capacitor-health-extended 0.4.3 → 0.4.4

package/README.md

@@ -334,7 +334,7 @@ Query aggregated data
 **Returns:** <code>Promise&lt;<a href="#queryaggregatedresponse">QueryAggregatedResponse</a>&gt;</code>
 
 - Blood-pressure aggregates return the systolic average in `value` plus `systolic`, `diastolic`, and `unit`.
-- On iOS `total-calories` is derived as active + basal energy (Android uses Health Connect's total calories when available).
+- `total-calories` is derived as active + basal energy on both iOS and Android for latest samples, aggregated queries, and workouts. We fall back to the platform's total‑calories metric (or active calories) when basal data isn't available or permission is missing. Request both `READ_ACTIVE_CALORIES` and `READ_BASAL_CALORIES` for full totals.
 - Weight/height aggregation returns the latest sample per day (no averaging).
 - Android aggregation currently supports daily buckets; unsupported buckets will be rejected.
 - Android `distance-cycling` aggregates distance recorded during biking exercise sessions (requires distance + workouts permissions).
@@ -374,6 +374,8 @@ Query latest sample for a specific data type
 
 **Returns:** <code>Promise&lt;<a href="#querylatestsampleresponse">QueryLatestSampleResponse</a>&gt;</code>
 
+- Latest sleep sample returns the most recent complete sleep session (asleep states only) from the last ~36 hours; if a longer overnight session exists, shorter naps are ignored.
+
 --------------------
 
 

package/android/src/main/java/com/flomentum/health/capacitor/HealthPlugin.kt

@@ -804,7 +804,72 @@ class HealthPlugin : Plugin() {
         }
     }
 
+    private suspend fun sumActiveAndBasalCalories(
+        timeRange: TimeRangeFilter,
+        includeTotalMetricFallback: Boolean = false
+    ): Double? {
+        val metrics = mutableSetOf<AggregateMetric<*>>()
+        val includeActive = hasPermission(CapHealthPermission.READ_ACTIVE_CALORIES)
+        val includeBasal = hasPermission(CapHealthPermission.READ_BASAL_CALORIES)
+        val includeTotal = includeTotalMetricFallback && hasPermission(CapHealthPermission.READ_TOTAL_CALORIES)
+
+        if (includeActive) metrics.add(ActiveCaloriesBurnedRecord.ACTIVE_CALORIES_TOTAL)
+        if (includeBasal) metrics.add(BasalMetabolicRateRecord.BASAL_CALORIES_TOTAL)
+        if (includeTotal) metrics.add(TotalCaloriesBurnedRecord.ENERGY_TOTAL)
+
+        if (metrics.isEmpty()) {
+            return null
+        }
+
+        val aggregation = healthConnectClient.aggregate(
+            AggregateRequest(
+                metrics = metrics,
+                timeRangeFilter = timeRange,
+                dataOriginFilter = emptySet()
+            )
+        )
+
+        val active = if (includeActive) {
+            aggregation[ActiveCaloriesBurnedRecord.ACTIVE_CALORIES_TOTAL]?.inKilocalories
+        } else null
+        val basal = if (includeBasal) {
+            aggregation[BasalMetabolicRateRecord.BASAL_CALORIES_TOTAL]?.inKilocalories
+        } else null
+        val total = if (includeTotal) {
+            aggregation[TotalCaloriesBurnedRecord.ENERGY_TOTAL]?.inKilocalories
+        } else null
+
+        return when {
+            active != null || basal != null -> (active ?: 0.0) + (basal ?: 0.0)
+            includeTotal -> total
+            else -> null
+        }
+    }
+
     private suspend fun readLatestTotalCalories(): JSObject {
+        val zone = ZoneId.systemDefault()
+        val now = LocalDateTime.now(zone)
+
+        val derivedTotal = try {
+            sumActiveAndBasalCalories(
+                TimeRangeFilter.between(
+                    now.toLocalDate().atStartOfDay(),
+                    now
+                )
+            )
+        } catch (e: Exception) {
+            Log.w(tag, "readLatestTotalCalories: Failed to derive active+basal calories, falling back to total metric", e)
+            null
+        }
+
+        if (derivedTotal != null) {
+            return JSObject().apply {
+                put("value", derivedTotal)
+                put("timestamp", now.atZone(zone).toInstant().toEpochMilli())
+                put("unit", "kcal")
+            }
+        }
+
         if (!hasPermission(CapHealthPermission.READ_TOTAL_CALORIES)) {
             throw Exception("Permission for total calories not granted")
         }
@@ -952,13 +1017,17 @@ class HealthPlugin : Plugin() {
                         }
 
                         else -> {
-                            val metricAndMapper = getMetricAndMapper(dataType)
-                            val r = queryAggregatedMetric(
-                                metricAndMapper,
-                                timeRange,
-                                period
-                            )
-                            r.forEach { aggregatedList.put(it.toJs()) }
+                            val aggregated = if (dataType == "total-calories") {
+                                aggregateTotalCalories(timeRange, period)
+                            } else {
+                                val metricAndMapper = getMetricAndMapper(dataType)
+                                queryAggregatedMetric(
+                                    metricAndMapper,
+                                    timeRange,
+                                    period
+                                )
+                            }
+                            aggregated.forEach { aggregatedList.put(it.toJs()) }
                         }
                     }
 
@@ -1068,6 +1137,51 @@ class HealthPlugin : Plugin() {
 
     }
 
+    private suspend fun aggregateTotalCalories(
+        timeRange: TimeRangeFilter,
+        period: Period
+    ): List<AggregatedSample> {
+        val includeActive = hasPermission(CapHealthPermission.READ_ACTIVE_CALORIES)
+        val includeBasal = hasPermission(CapHealthPermission.READ_BASAL_CALORIES)
+        val includeTotal = hasPermission(CapHealthPermission.READ_TOTAL_CALORIES)
+
+        val metrics = mutableSetOf<AggregateMetric<*>>()
+        if (includeActive) metrics.add(ActiveCaloriesBurnedRecord.ACTIVE_CALORIES_TOTAL)
+        if (includeBasal) metrics.add(BasalMetabolicRateRecord.BASAL_CALORIES_TOTAL)
+        if (includeTotal) metrics.add(TotalCaloriesBurnedRecord.ENERGY_TOTAL)
+
+        if (metrics.isEmpty()) {
+            return emptyList()
+        }
+
+        val response: List<AggregationResultGroupedByPeriod> = healthConnectClient.aggregateGroupByPeriod(
+            AggregateGroupByPeriodRequest(
+                metrics = metrics,
+                timeRangeFilter = timeRange,
+                timeRangeSlicer = period
+            )
+        )
+
+        return response.map {
+            val active = if (includeActive) {
+                it.result[ActiveCaloriesBurnedRecord.ACTIVE_CALORIES_TOTAL]?.inKilocalories
+            } else null
+            val basal = if (includeBasal) {
+                it.result[BasalMetabolicRateRecord.BASAL_CALORIES_TOTAL]?.inKilocalories
+            } else null
+            val total = if (includeTotal) {
+                it.result[TotalCaloriesBurnedRecord.ENERGY_TOTAL]?.inKilocalories
+            } else null
+
+            val value = when {
+                active != null || basal != null -> (active ?: 0.0) + (basal ?: 0.0)
+                else -> total ?: 0.0
+            }
+
+            AggregatedSample(it.startTime, it.endTime, value)
+        }
+    }
+
     private suspend fun aggregateHrvByPeriod(
         timeRange: TimeRangeFilter,
         period: Period
@@ -1409,9 +1523,12 @@ class HealthPlugin : Plugin() {
                         addWorkoutMetric(workout, workoutObject, getMetricAndMapper("steps"))
                     }
 
-                    val readTotalCaloriesResult = addWorkoutMetric(workout, workoutObject, getMetricAndMapper("total-calories"))
-                    if(!readTotalCaloriesResult) {
-                        addWorkoutMetric(workout, workoutObject, getMetricAndMapper("active-calories"))
+                    val derivedTotalAdded = addWorkoutTotalCalories(workout, workoutObject)
+                    if (!derivedTotalAdded) {
+                        val readTotalCaloriesResult = addWorkoutMetric(workout, workoutObject, getMetricAndMapper("total-calories"))
+                        if(!readTotalCaloriesResult) {
+                            addWorkoutMetric(workout, workoutObject, getMetricAndMapper("active-calories"))
+                        }
                     }
 
                     addWorkoutMetric(workout, workoutObject, getMetricAndMapper("distance"))
@@ -1451,6 +1568,27 @@ class HealthPlugin : Plugin() {
         }
     }
 
+    private suspend fun addWorkoutTotalCalories(
+        workout: ExerciseSessionRecord,
+        jsWorkout: JSObject
+    ): Boolean {
+        return try {
+            val totalCalories = sumActiveAndBasalCalories(
+                TimeRangeFilter.between(workout.startTime, workout.endTime),
+                includeTotalMetricFallback = true
+            )
+            if (totalCalories != null) {
+                jsWorkout.put("calories", totalCalories)
+                true
+            } else {
+                false
+            }
+        } catch (e: Exception) {
+            Log.e(tag, "addWorkoutTotalCalories: Failed to derive calories", e)
+            false
+        }
+    }
+
     private suspend fun addWorkoutMetric(
         workout: ExerciseSessionRecord,
         jsWorkout: JSObject,

package/ios/Sources/HealthPluginPlugin/HealthPlugin.swift

@@ -161,26 +161,85 @@ public class HealthPlugin: CAPPlugin, CAPBridgedPlugin {
                 call.reject("Sleep type not available")
                 return
             }
-            
-            let sortDescriptor = NSSortDescriptor(key: HKSampleSortIdentifierStartDate, ascending: false)
-            let predicate = HKQuery.predicateForSamples(withStart: Date.distantPast, end: Date(), options: .strictEndDate)
-            
-            let query = HKSampleQuery(sampleType: sleepType, predicate: predicate, limit: 1, sortDescriptors: [sortDescriptor]) { _, samples, error in
-                guard let sleepSample = samples?.first as? HKCategorySample else {
-                    if let error = error {
-                        call.reject("Error fetching latest sleep sample", "NO_SAMPLE", error)
-                    } else {
-                        call.reject("No sleep sample found", "NO_SAMPLE")
+
+            let endDate = Date()
+            let startDate = Calendar.current.date(byAdding: .hour, value: -36, to: endDate) ?? endDate.addingTimeInterval(-36 * 3600)
+            let predicate = HKQuery.predicateForSamples(withStart: startDate, end: endDate, options: .strictEndDate)
+
+            let query = HKSampleQuery(sampleType: sleepType, predicate: predicate, limit: HKObjectQueryNoLimit, sortDescriptors: nil) { _, samples, error in
+                if let error = error {
+                    call.reject("Error fetching latest sleep sample", "NO_SAMPLE", error)
+                    return
+                }
+                guard let categorySamples = samples as? [HKCategorySample], !categorySamples.isEmpty else {
+                    call.reject("No sleep sample found", "NO_SAMPLE")
+                    return
+                }
+
+                let asleepValues: Set<Int> = {
+                    var values: [Int] = [HKCategoryValueSleepAnalysis.asleepUnspecified.rawValue]
+                    if #available(iOS 16.0, *) {
+                        values.append(contentsOf: [
+                            HKCategoryValueSleepAnalysis.asleepCore.rawValue,
+                            HKCategoryValueSleepAnalysis.asleepDeep.rawValue,
+                            HKCategoryValueSleepAnalysis.asleepREM.rawValue
+                        ])
+                    }
+                    return Set(values)
+                }()
+
+                func isAsleep(_ value: Int) -> Bool {
+                    if asleepValues.contains(value) {
+                        return true
                     }
+                    // Fallback: treat any non in-bed/awake as asleep
+                    return value != HKCategoryValueSleepAnalysis.inBed.rawValue &&
+                        value != HKCategoryValueSleepAnalysis.awake.rawValue
+                }
+
+                let asleepSamples = categorySamples
+                    .filter { isAsleep($0.value) }
+                    .sorted { $0.startDate < $1.startDate }
+
+                guard !asleepSamples.isEmpty else {
+                    call.reject("No sleep sample found", "NO_SAMPLE")
                     return
                 }
-                let durationMinutes = sleepSample.endDate.timeIntervalSince(sleepSample.startDate) / 60
+
+                let maxGap: TimeInterval = 90 * 60 // 90 minutes separates sessions
+                var sessions: [(start: Date, end: Date, duration: TimeInterval)] = []
+                var currentStart: Date?
+                var currentEnd: Date?
+                var currentDuration: TimeInterval = 0
+
+                for sample in asleepSamples {
+                    if let lastEnd = currentEnd, sample.startDate.timeIntervalSince(lastEnd) > maxGap {
+                        sessions.append((start: currentStart ?? lastEnd, end: lastEnd, duration: currentDuration))
+                        currentStart = nil
+                        currentEnd = nil
+                        currentDuration = 0
+                    }
+                    if currentStart == nil { currentStart = sample.startDate }
+                    currentEnd = sample.endDate
+                    currentDuration += sample.endDate.timeIntervalSince(sample.startDate)
+                }
+                if let start = currentStart, let end = currentEnd {
+                    sessions.append((start: start, end: end, duration: currentDuration))
+                }
+
+                guard !sessions.isEmpty else {
+                    call.reject("No sleep sample found", "NO_SAMPLE")
+                    return
+                }
+
+                let minSessionDuration: TimeInterval = 3 * 3600 // prefer sessions 3h+
+                let preferredSession = sessions.reversed().first { $0.duration >= minSessionDuration } ?? sessions.last!
+
                 call.resolve([
-                    "value": durationMinutes,
-                    "timestamp": sleepSample.startDate.timeIntervalSince1970 * 1000,
-                    "endTimestamp": sleepSample.endDate.timeIntervalSince1970 * 1000,
-                    "unit": "min",
-                    "metadata": ["state": sleepSample.value]
+                    "value": preferredSession.duration / 60,
+                    "timestamp": preferredSession.start.timeIntervalSince1970 * 1000,
+                    "endTimestamp": preferredSession.end.timeIntervalSince1970 * 1000,
+                    "unit": "min"
                 ])
             }
             healthStore.execute(query)
@@ -725,8 +784,9 @@ public class HealthPlugin: CAPPlugin, CAPBridgedPlugin {
             let calendar = Calendar.current
             if let categorySamples = samples as? [HKCategorySample], error == nil {
                 for sample in categorySamples {
-                    // Ignore in-bed samples; we care about actual sleep
+                    // Ignore in-bed and awake samples; we care about actual sleep
                     if sample.value == HKCategoryValueSleepAnalysis.inBed.rawValue { continue }
+                    if sample.value == HKCategoryValueSleepAnalysis.awake.rawValue { continue }
                     let startOfDay = calendar.startOfDay(for: sample.startDate)
                     let duration = sample.endDate.timeIntervalSince(sample.startDate)
                     dailyDurations[startOfDay, default: 0] += duration
@@ -821,52 +881,55 @@ public class HealthPlugin: CAPPlugin, CAPBridgedPlugin {
         healthStore.execute(query)
     }
 
+    private func sumEnergy(
+        _ identifier: HKQuantityTypeIdentifier,
+        startDate: Date,
+        endDate: Date,
+        completion: @escaping (Double?, Error?) -> Void
+    ) {
+        guard let type = HKObjectType.quantityType(forIdentifier: identifier) else {
+            completion(nil, NSError(domain: "HealthKit", code: -1, userInfo: [NSLocalizedDescriptionKey: "Quantity type unavailable"]))
+            return
+        }
+        let predicate = HKQuery.predicateForSamples(withStart: startDate, end: endDate, options: .strictStartDate)
+        let query = HKStatisticsQuery(
+            quantityType: type,
+            quantitySamplePredicate: predicate,
+            options: .cumulativeSum
+        ) { _, result, error in
+            if let error = error {
+                completion(nil, error)
+                return
+            }
+            let value = result?.sumQuantity()?.doubleValue(for: HKUnit.kilocalorie())
+            completion(value, nil)
+        }
+        healthStore.execute(query)
+    }
+
     private func queryLatestTotalCalories(_ call: CAPPluginCall) {
         let unit = HKUnit.kilocalorie()
         let group = DispatchGroup()
+        let now = Date()
+        let startOfDay = Calendar.current.startOfDay(for: now)
 
-        var activeValue: Double?
-        var basalValue: Double?
-        var activeDate: Date?
-        var basalDate: Date?
+        var activeTotal: Double?
+        var basalTotal: Double?
         var queryError: Error?
         let basalSupported = HKObjectType.quantityType(forIdentifier: .basalEnergyBurned) != nil
 
-        func fetchLatest(_ identifier: HKQuantityTypeIdentifier, completion: @escaping (Double?, Date?, Error?) -> Void) {
-            guard let type = HKObjectType.quantityType(forIdentifier: identifier) else {
-                completion(nil, nil, NSError(domain: "HealthKit", code: -1, userInfo: [NSLocalizedDescriptionKey: "Quantity type unavailable"]))
-                return
-            }
-            let predicate = HKQuery.predicateForSamples(withStart: Date.distantPast, end: Date(), options: .strictEndDate)
-            let sort = NSSortDescriptor(key: HKSampleSortIdentifierStartDate, ascending: false)
-            let query = HKSampleQuery(sampleType: type, predicate: predicate, limit: 1, sortDescriptors: [sort]) { _, samples, error in
-                if let error = error {
-                    completion(nil, nil, error)
-                    return
-                }
-                guard let sample = samples?.first as? HKQuantitySample else {
-                    completion(nil, nil, nil)
-                    return
-                }
-                completion(sample.quantity.doubleValue(for: unit), sample.startDate, nil)
-            }
-            healthStore.execute(query)
-        }
-
         group.enter()
-        fetchLatest(.activeEnergyBurned) { value, date, error in
-            activeValue = value
-            activeDate = date
-            queryError = queryError ?? error
+        sumEnergy(.activeEnergyBurned, startDate: startOfDay, endDate: now) { value, error in
+            activeTotal = value
+            if queryError == nil { queryError = error }
             group.leave()
         }
 
         if basalSupported {
             group.enter()
-            fetchLatest(.basalEnergyBurned) { value, date, error in
-                basalValue = value
-                basalDate = date
-                queryError = queryError ?? error
+            sumEnergy(.basalEnergyBurned, startDate: startOfDay, endDate: now) { value, error in
+                basalTotal = value
+                if queryError == nil { queryError = error }
                 group.leave()
             }
         }
@@ -876,15 +939,14 @@ public class HealthPlugin: CAPPlugin, CAPBridgedPlugin {
                 call.reject("Error fetching total calories: \(error.localizedDescription)")
                 return
             }
-            guard activeValue != nil || basalValue != nil else {
+            guard activeTotal != nil || basalTotal != nil else {
                 call.reject("No sample found", "NO_SAMPLE")
                 return
             }
-            let total = (activeValue ?? 0) + (basalValue ?? 0)
-            let timestamp = max(activeDate?.timeIntervalSince1970 ?? 0, basalDate?.timeIntervalSince1970 ?? 0) * 1000
+            let total = (activeTotal ?? 0) + (basalTotal ?? 0)
             call.resolve([
                 "value": total,
-                "timestamp": timestamp,
+                "timestamp": now.timeIntervalSince1970 * 1000,
                 "unit": unit.unitString
             ])
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flomentumsolutions/capacitor-health-extended",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "description": "Capacitor plugin for Apple HealthKit and Google Health Connect Platform",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",