@flomentumsolutions/capacitor-health-extended 0.1.0 → 0.4.1

package/ios/Sources/HealthPluginPlugin/HealthPlugin.swift

@@ -1,4 +1,5 @@
 import Foundation
+import UIKit
 import Capacitor
 import HealthKit
 
@@ -17,17 +18,13 @@ public class HealthPlugin: CAPPlugin, CAPBridgedPlugin {
         CAPPluginMethod(name: "openAppleHealthSettings", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "queryAggregated", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "queryWorkouts", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "queryLatestSample", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "queryWeight", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "queryHeight", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "queryHeartRate", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "querySteps", returnType: CAPPluginReturnPromise)
+        CAPPluginMethod(name: "queryLatestSample", returnType: CAPPluginReturnPromise)
     ]
     
     let healthStore = HKHealthStore()
     
     /// Serial queue to make route‑location mutations thread‑safe without locks
-    private let routeSyncQueue = DispatchQueue(label: "com.flomentum.healthplugin.routeSync")
+    private let routeSyncQueue = DispatchQueue(label: "com.flomentumsolutions.healthplugin.routeSync")
     
     @objc func isHealthAvailable(_ call: CAPPluginCall) {
         let isAvailable = HKHealthStore.isHealthDataAvailable()
@@ -153,6 +150,73 @@ public class HealthPlugin: CAPPlugin, CAPBridgedPlugin {
             healthStore.execute(query)
             return
         }
+        // ---- Derived total calories (active + basal) ----
+        if dataTypeString == "total-calories" {
+            queryLatestTotalCalories(call)
+            return
+        }
+        // ---- Special handling for sleep sessions (category samples) ----
+        if dataTypeString == "sleep" {
+            guard let sleepType = HKObjectType.categoryType(forIdentifier: .sleepAnalysis) else {
+                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")
+                    }
+                    return
+                }
+                let durationMinutes = sleepSample.endDate.timeIntervalSince(sleepSample.startDate) / 60
+                call.resolve([
+                    "value": durationMinutes,
+                    "timestamp": sleepSample.startDate.timeIntervalSince1970 * 1000,
+                    "endTimestamp": sleepSample.endDate.timeIntervalSince1970 * 1000,
+                    "unit": "min",
+                    "metadata": ["state": sleepSample.value]
+                ])
+            }
+            healthStore.execute(query)
+            return
+        }
+        // ---- Special handling for mindfulness sessions (category samples) ----
+        if dataTypeString == "mindfulness" {
+            guard let mindfulType = HKObjectType.categoryType(forIdentifier: .mindfulSession) else {
+                call.reject("Mindfulness 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: mindfulType, predicate: predicate, limit: 1, sortDescriptors: [sortDescriptor]) { _, samples, error in
+                guard let mindfulSample = samples?.first as? HKCategorySample else {
+                    if let error = error {
+                        call.reject("Error fetching latest mindfulness sample", "NO_SAMPLE", error)
+                    } else {
+                        call.reject("No mindfulness sample found", "NO_SAMPLE")
+                    }
+                    return
+                }
+                let durationMinutes = mindfulSample.endDate.timeIntervalSince(mindfulSample.startDate) / 60
+                call.resolve([
+                    "value": durationMinutes,
+                    "timestamp": mindfulSample.startDate.timeIntervalSince1970 * 1000,
+                    "endTimestamp": mindfulSample.endDate.timeIntervalSince1970 * 1000,
+                    "unit": "min",
+                    "metadata": ["value": mindfulSample.value]
+                ])
+            }
+            healthStore.execute(query)
+            return
+        }
         guard aggregateTypeToHKQuantityType(dataTypeString) != nil else {
             call.reject("Invalid data type")
             return
@@ -162,6 +226,10 @@ public class HealthPlugin: CAPPlugin, CAPBridgedPlugin {
             switch dataTypeString {
             case "heart-rate":
                 return HKObjectType.quantityType(forIdentifier: .heartRate)
+            case "resting-heart-rate":
+                return HKObjectType.quantityType(forIdentifier: .restingHeartRate)
+            case "respiratory-rate":
+                return HKObjectType.quantityType(forIdentifier: .respiratoryRate)
             case "weight":
                 return HKObjectType.quantityType(forIdentifier: .bodyMass)
             case "steps":
@@ -172,12 +240,28 @@ public class HealthPlugin: CAPPlugin, CAPBridgedPlugin {
                 return HKObjectType.quantityType(forIdentifier: .height)
             case "distance":
                 return HKObjectType.quantityType(forIdentifier: .distanceWalkingRunning)
-            case "active-calories":
-                return HKObjectType.quantityType(forIdentifier: .activeEnergyBurned)
-            case "total-calories":
-                return HKObjectType.quantityType(forIdentifier: .activeEnergyBurned)
-            case "blood-pressure":
-                return nil // handled above
+        case "distance-cycling":
+            return HKObjectType.quantityType(forIdentifier: .distanceCycling)
+        case "active-calories":
+            return HKObjectType.quantityType(forIdentifier: .activeEnergyBurned)
+        case "basal-calories":
+            return HKObjectType.quantityType(forIdentifier: .basalEnergyBurned)
+        case "blood-pressure":
+            return nil // handled above
+        case "oxygen-saturation":
+                return HKObjectType.quantityType(forIdentifier: .oxygenSaturation)
+            case "blood-glucose":
+                return HKObjectType.quantityType(forIdentifier: .bloodGlucose)
+            case "body-temperature":
+                return HKObjectType.quantityType(forIdentifier: .bodyTemperature)
+            case "basal-body-temperature":
+                return HKObjectType.quantityType(forIdentifier: .basalBodyTemperature)
+            case "body-fat":
+                return HKObjectType.quantityType(forIdentifier: .bodyFatPercentage)
+            case "flights-climbed":
+                return HKObjectType.quantityType(forIdentifier: .flightsClimbed)
+            case "exercise-time":
+                return HKObjectType.quantityType(forIdentifier: .appleExerciseTime)
             default:
                 return nil
             }
@@ -209,16 +293,36 @@ public class HealthPlugin: CAPPlugin, CAPBridgedPlugin {
             var unit: HKUnit = .count()
             if dataTypeString == "heart-rate" {
                 unit = HKUnit.count().unitDivided(by: HKUnit.minute())
+            } else if dataTypeString == "resting-heart-rate" {
+                unit = HKUnit.count().unitDivided(by: HKUnit.minute())
             } else if dataTypeString == "weight" {
                 unit = .gramUnit(with: .kilo)
             } else if dataTypeString == "hrv" {
                 unit = HKUnit.secondUnit(with: .milli)
             } else if dataTypeString == "distance" {
                 unit = HKUnit.meter()
+            } else if dataTypeString == "distance-cycling" {
+                unit = HKUnit.meter()
             } else if dataTypeString == "active-calories" || dataTypeString == "total-calories" {
                 unit = HKUnit.kilocalorie()
+            } else if dataTypeString == "basal-calories" {
+                unit = HKUnit.kilocalorie()
             } else if dataTypeString == "height" {
                 unit = HKUnit.meter()
+            } else if dataTypeString == "oxygen-saturation" {
+                unit = HKUnit.percent()
+            } else if dataTypeString == "blood-glucose" {
+                unit = HKUnit(from: "mg/dL")
+            } else if dataTypeString == "body-temperature" || dataTypeString == "basal-body-temperature" {
+                unit = HKUnit.degreeCelsius()
+            } else if dataTypeString == "body-fat" {
+                unit = HKUnit.percent()
+            } else if dataTypeString == "flights-climbed" {
+                unit = HKUnit.count()
+            } else if dataTypeString == "exercise-time" {
+                unit = HKUnit.minute()
+            } else if dataTypeString == "respiratory-rate" {
+                unit = HKUnit.count().unitDivided(by: HKUnit.minute())
             }
             let value = quantitySample.quantity.doubleValue(for: unit)
             let timestamp = quantitySample.startDate.timeIntervalSince1970 * 1000
@@ -235,57 +339,6 @@ public class HealthPlugin: CAPPlugin, CAPBridgedPlugin {
         healthStore.execute(query)
     }
     
-    // Convenience methods for specific data types
-    @objc func queryWeight(_ call: CAPPluginCall) {
-        queryLatestSampleWithType(call, dataType: "weight")
-    }
-    
-    @objc func queryHeight(_ call: CAPPluginCall) {
-        queryLatestSampleWithType(call, dataType: "height")
-    }
-    
-    @objc func queryHeartRate(_ call: CAPPluginCall) {
-        queryLatestSampleWithType(call, dataType: "heart-rate")
-    }
-    
-    @objc func querySteps(_ call: CAPPluginCall) {
-        queryLatestSampleWithType(call, dataType: "steps")
-    }
-    
-    private func queryLatestSampleWithType(_ call: CAPPluginCall, dataType: String) {
-        // Safely coerce the original options into a [String: Any] JSObject.
-        let originalOptions = call.options as? [String: Any] ?? [:]
-        var params = originalOptions
-        params["dataType"] = dataType
-
-        // Create a proxy CAPPluginCall using the CURRENT (Capacitor 6) designated initializer.
-        // NOTE: The older init(callbackId:options:success:error:) is deprecated and *failable*,
-        // so we use the newer initializer that requires a method name. Guard against failure.
-        guard let proxyCall = CAPPluginCall(
-            callbackId: call.callbackId,
-            methodName: "queryLatestSample", // required in new API
-            options: params,
-            success: { result, _ in
-                // Forward the resolved data back to the original JS caller.
-                call.resolve(result?.data ?? [:])
-            },
-            error: { capError in
-                // Forward the error to the original call in the legacy reject format.
-                if let capError = capError {
-                    call.reject(capError.message, capError.code, capError.error, capError.data)
-                } else {
-                    call.reject("Unknown native error")
-                }
-            }
-        ) else {
-            call.reject("Failed to create proxy call")
-            return
-        }
-
-        // Delegate the actual HealthKit fetch to the common implementation.
-        queryLatestSample(proxyCall)
-    }
-    
     @objc func openAppleHealthSettings(_ call: CAPPluginCall) {
         if let url = URL(string: UIApplication.openSettingsURLString) {
             DispatchQueue.main.async {
@@ -317,6 +370,8 @@ public class HealthPlugin: CAPPlugin, CAPBridgedPlugin {
             return [HKObjectType.workoutType()].compactMap{$0}
         case "READ_HEART_RATE":
             return  [HKObjectType.quantityType(forIdentifier: .heartRate)].compactMap{$0}
+        case "READ_RESTING_HEART_RATE":
+            return [HKObjectType.quantityType(forIdentifier: .restingHeartRate)].compactMap { $0 }
         case "READ_ROUTE":
             return  [HKSeriesType.workoutRoute()].compactMap{$0}
         case "READ_DISTANCE":
@@ -335,6 +390,28 @@ public class HealthPlugin: CAPPlugin, CAPBridgedPlugin {
                 HKObjectType.quantityType(forIdentifier: .bloodPressureSystolic),
                 HKObjectType.quantityType(forIdentifier: .bloodPressureDiastolic)
             ].compactMap { $0 }
+        case "READ_RESPIRATORY_RATE":
+            return [HKObjectType.quantityType(forIdentifier: .respiratoryRate)].compactMap { $0 }
+        case "READ_OXYGEN_SATURATION":
+            return [HKObjectType.quantityType(forIdentifier: .oxygenSaturation)].compactMap { $0 }
+        case "READ_BLOOD_GLUCOSE":
+            return [HKObjectType.quantityType(forIdentifier: .bloodGlucose)].compactMap { $0 }
+        case "READ_BODY_TEMPERATURE":
+            return [HKObjectType.quantityType(forIdentifier: .bodyTemperature)].compactMap { $0 }
+        case "READ_BASAL_BODY_TEMPERATURE":
+            return [HKObjectType.quantityType(forIdentifier: .basalBodyTemperature)].compactMap { $0 }
+        case "READ_BODY_FAT":
+            return [HKObjectType.quantityType(forIdentifier: .bodyFatPercentage)].compactMap { $0 }
+        case "READ_FLOORS_CLIMBED":
+            return [HKObjectType.quantityType(forIdentifier: .flightsClimbed)].compactMap { $0 }
+        case "READ_BASAL_CALORIES":
+            return [
+                HKObjectType.quantityType(forIdentifier: .basalEnergyBurned)
+            ].compactMap { $0 }
+        case "READ_SLEEP":
+            return [HKObjectType.categoryType(forIdentifier: .sleepAnalysis)!].compactMap { $0 }
+        case "READ_EXERCISE_TIME":
+            return [HKObjectType.quantityType(forIdentifier: .appleExerciseTime)].compactMap { $0 }
         // Add common alternative permission names
         case "steps":
             return [HKObjectType.quantityType(forIdentifier: .stepCount)].compactMap{$0}
@@ -371,6 +448,26 @@ public class HealthPlugin: CAPPlugin, CAPBridgedPlugin {
                 HKObjectType.quantityType(forIdentifier: .bloodPressureSystolic),
                 HKObjectType.quantityType(forIdentifier: .bloodPressureDiastolic)
             ].compactMap { $0 }
+        case "respiratory-rate":
+            return [HKObjectType.quantityType(forIdentifier: .respiratoryRate)].compactMap { $0 }
+        case "oxygen-saturation":
+            return [HKObjectType.quantityType(forIdentifier: .oxygenSaturation)].compactMap { $0 }
+        case "blood-glucose":
+            return [HKObjectType.quantityType(forIdentifier: .bloodGlucose)].compactMap { $0 }
+        case "body-temperature":
+            return [HKObjectType.quantityType(forIdentifier: .bodyTemperature)].compactMap { $0 }
+        case "basal-body-temperature":
+            return [HKObjectType.quantityType(forIdentifier: .basalBodyTemperature)].compactMap { $0 }
+        case "body-fat":
+            return [HKObjectType.quantityType(forIdentifier: .bodyFatPercentage)].compactMap { $0 }
+        case "flights-climbed":
+            return [HKObjectType.quantityType(forIdentifier: .flightsClimbed)].compactMap { $0 }
+        case "basal-calories":
+            return [HKObjectType.quantityType(forIdentifier: .basalEnergyBurned)].compactMap { $0 }
+        case "exercise-time":
+            return [HKObjectType.quantityType(forIdentifier: .appleExerciseTime)].compactMap { $0 }
+        case "sleep":
+            return [HKObjectType.categoryType(forIdentifier: .sleepAnalysis)!].compactMap { $0 }
         default:
             print("⚡️ [HealthPlugin] Unknown permission: \(permission)")
             return []
@@ -385,16 +482,38 @@ public class HealthPlugin: CAPPlugin, CAPBridgedPlugin {
             return HKObjectType.quantityType(forIdentifier: .activeEnergyBurned)
         case "heart-rate":
             return HKObjectType.quantityType(forIdentifier: .heartRate)
+        case "resting-heart-rate":
+            return HKObjectType.quantityType(forIdentifier: .restingHeartRate)
         case "weight":
             return HKObjectType.quantityType(forIdentifier: .bodyMass)
         case "hrv":
             return HKObjectType.quantityType(forIdentifier: .heartRateVariabilitySDNN)
         case "distance":
             return HKObjectType.quantityType(forIdentifier: .distanceWalkingRunning)  // pick one rep type
+        case "distance-cycling":
+            return HKObjectType.quantityType(forIdentifier: .distanceCycling)
         case "total-calories":
             return HKObjectType.quantityType(forIdentifier: .activeEnergyBurned)
+        case "basal-calories":
+            return HKObjectType.quantityType(forIdentifier: .basalEnergyBurned)
         case "height":
             return HKObjectType.quantityType(forIdentifier: .height)
+        case "respiratory-rate":
+            return HKObjectType.quantityType(forIdentifier: .respiratoryRate)
+        case "oxygen-saturation":
+            return HKObjectType.quantityType(forIdentifier: .oxygenSaturation)
+        case "blood-glucose":
+            return HKObjectType.quantityType(forIdentifier: .bloodGlucose)
+        case "body-temperature":
+            return HKObjectType.quantityType(forIdentifier: .bodyTemperature)
+        case "basal-body-temperature":
+            return HKObjectType.quantityType(forIdentifier: .basalBodyTemperature)
+        case "body-fat":
+            return HKObjectType.quantityType(forIdentifier: .bodyFatPercentage)
+        case "flights-climbed":
+            return HKObjectType.quantityType(forIdentifier: .flightsClimbed)
+        case "exercise-time":
+            return HKObjectType.quantityType(forIdentifier: .appleExerciseTime)
         default:
             return nil
         }
@@ -406,13 +525,21 @@ public class HealthPlugin: CAPPlugin, CAPBridgedPlugin {
               let endDateString = call.getString("endDate"),
               let dataTypeString = call.getString("dataType"),
               let bucket = call.getString("bucket"),
-              let startDate = self.isoDateFormatter.date(from: startDateString),
-              let endDate = self.isoDateFormatter.date(from: endDateString) else {
+              let rawStartDate = self.isoDateFormatter.date(from: startDateString),
+              let rawEndDate = self.isoDateFormatter.date(from: endDateString) else {
             DispatchQueue.main.async {
                 call.reject("Invalid parameters")
             }
             return
         }
+        let calendar = Calendar.current
+        var startDate = rawStartDate
+        var endDate = rawEndDate
+        if bucket == "day" {
+            startDate = calendar.startOfDay(for: rawStartDate)
+            let endDayStart = calendar.startOfDay(for: rawEndDate)
+            endDate = calendar.date(byAdding: .day, to: endDayStart) ?? endDayStart
+        }
         if dataTypeString == "mindfulness" {
             self.queryMindfulnessAggregated(startDate: startDate, endDate: endDate) { result, error in
                 DispatchQueue.main.async {
@@ -423,6 +550,48 @@ public class HealthPlugin: CAPPlugin, CAPBridgedPlugin {
                     }
                 }
             }
+        } else if dataTypeString == "blood-pressure" {
+            guard bucket == "day" else {
+                DispatchQueue.main.async {
+                    call.reject("Blood pressure aggregation only supports daily buckets")
+                }
+                return
+            }
+            self.queryBloodPressureAggregated(startDate: startDate, endDate: endDate) { result, error in
+                DispatchQueue.main.async {
+                    if let error = error {
+                        call.reject(error.localizedDescription)
+                    } else if let result = result {
+                        call.resolve(["aggregatedData": result])
+                    }
+                }
+            }
+        } else if dataTypeString == "total-calories" {
+            guard let interval = calculateInterval(bucket: bucket) else {
+                DispatchQueue.main.async {
+                    call.reject("Invalid bucket")
+                }
+                return
+            }
+            self.queryTotalCaloriesAggregated(startDate: startDate, endDate: endDate, interval: interval) { result, error in
+                DispatchQueue.main.async {
+                    if let error = error {
+                        call.reject(error.localizedDescription)
+                    } else if let result = result {
+                        call.resolve(["aggregatedData": result])
+                    }
+                }
+            }
+        } else if dataTypeString == "sleep" {
+            self.querySleepAggregated(startDate: startDate, endDate: endDate) { result, error in
+                DispatchQueue.main.async {
+                    if let error = error {
+                        call.reject(error.localizedDescription)
+                    } else if let result = result {
+                        call.resolve(["aggregatedData": result])
+                    }
+                }
+            }
         } else {
             let predicate = HKQuery.predicateForSamples(withStart: startDate, end: endDate, options: .strictStartDate)
             guard let interval = calculateInterval(bucket: bucket) else {
@@ -441,7 +610,10 @@ public class HealthPlugin: CAPPlugin, CAPBridgedPlugin {
                 switch dataType.aggregationStyle {
                 case .cumulative:
                     return .cumulativeSum
-                case .discrete:
+                case .discrete,
+                     .discreteArithmetic,
+                     .discreteTemporallyWeighted,
+                     .discreteEquivalentContinuousLevel:
                     return .discreteAverage
                 @unknown default:
                     return .discreteAverage
@@ -471,12 +643,19 @@ public class HealthPlugin: CAPPlugin, CAPBridgedPlugin {
                         let unit: HKUnit = {
                             switch dataTypeString {
                             case "steps": return .count()
-                            case "active-calories", "total-calories": return .kilocalorie()
-                            case "distance": return .meter()
+                            case "active-calories", "total-calories", "basal-calories": return .kilocalorie()
+                            case "distance", "distance-cycling": return .meter()
                             case "weight": return .gramUnit(with: .kilo)
                             case "height": return .meter()
-                            case "heart-rate": return HKUnit.count().unitDivided(by: HKUnit.minute())
+                            case "heart-rate", "resting-heart-rate": return HKUnit.count().unitDivided(by: HKUnit.minute())
+                            case "respiratory-rate": return HKUnit.count().unitDivided(by: HKUnit.minute())
                             case "hrv": return HKUnit.secondUnit(with: .milli)
+                            case "oxygen-saturation": return HKUnit.percent()
+                            case "blood-glucose": return HKUnit(from: "mg/dL")
+                            case "body-temperature", "basal-body-temperature": return HKUnit.degreeCelsius()
+                            case "body-fat": return HKUnit.percent()
+                            case "flights-climbed": return .count()
+                            case "exercise-time": return HKUnit.minute()
                             case "mindfulness": return HKUnit.second()
                             default: return .count()
                             }
@@ -532,6 +711,275 @@ public class HealthPlugin: CAPPlugin, CAPBridgedPlugin {
         }
         healthStore.execute(query)
     }
+    
+    func querySleepAggregated(startDate: Date, endDate: Date, completion: @escaping ([[String: Any]]?, Error?) -> Void) {
+        guard let sleepType = HKObjectType.categoryType(forIdentifier: .sleepAnalysis) else {
+            DispatchQueue.main.async {
+                completion(nil, NSError(domain: "HealthKit", code: -1, userInfo: [NSLocalizedDescriptionKey: "SleepAnalysis type unavailable"]))
+            }
+            return
+        }
+        let predicate = HKQuery.predicateForSamples(withStart: startDate, end: endDate, options: .strictStartDate)
+        let query = HKSampleQuery(sampleType: sleepType, predicate: predicate, limit: HKObjectQueryNoLimit, sortDescriptors: nil) { _, samples, error in
+            var dailyDurations: [Date: TimeInterval] = [:]
+            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
+                    if sample.value == HKCategoryValueSleepAnalysis.inBed.rawValue { continue }
+                    let startOfDay = calendar.startOfDay(for: sample.startDate)
+                    let duration = sample.endDate.timeIntervalSince(sample.startDate)
+                    dailyDurations[startOfDay, default: 0] += duration
+                }
+                var aggregatedSamples: [[String: Any]] = []
+                let dayComponent = DateComponents(day: 1)
+                for (date, duration) in dailyDurations {
+                    aggregatedSamples.append([
+                        "startDate": date,
+                        "endDate": calendar.date(byAdding: dayComponent, to: date) as Any,
+                        "value": duration
+                    ])
+                }
+                DispatchQueue.main.async {
+                    completion(aggregatedSamples, nil)
+                }
+            } else {
+                DispatchQueue.main.async {
+                    completion(nil, error)
+                }
+            }
+        }
+        healthStore.execute(query)
+    }
+    
+    func queryBloodPressureAggregated(startDate: Date, endDate: Date, completion: @escaping ([[String: Any]]?, Error?) -> Void) {
+        guard let bpType = HKObjectType.correlationType(forIdentifier: .bloodPressure),
+              let systolicType = HKObjectType.quantityType(forIdentifier: .bloodPressureSystolic),
+              let diastolicType = HKObjectType.quantityType(forIdentifier: .bloodPressureDiastolic) else {
+            DispatchQueue.main.async {
+                completion(nil, NSError(domain: "HealthKit", code: -1, userInfo: [NSLocalizedDescriptionKey: "Blood pressure types unavailable"]))
+            }
+            return
+        }
+
+        let predicate = HKQuery.predicateForSamples(withStart: startDate, end: endDate, options: .strictStartDate)
+        let query = HKSampleQuery(sampleType: bpType, predicate: predicate, limit: HKObjectQueryNoLimit, sortDescriptors: nil) { _, samples, error in
+            if let error = error {
+                DispatchQueue.main.async {
+                    completion(nil, error)
+                }
+                return
+            }
+
+            guard let correlations = samples as? [HKCorrelation] else {
+                DispatchQueue.main.async {
+                    completion([], nil)
+                }
+                return
+            }
+
+            let calendar = Calendar.current
+            let dayComponent = DateComponents(day: 1)
+            let unit = HKUnit.millimeterOfMercury()
+
+            var grouped: [Date: [(Double, Double)]] = [:]
+            for correlation in correlations {
+                guard let systolicSample = correlation.objects(for: systolicType).first as? HKQuantitySample,
+                      let diastolicSample = correlation.objects(for: diastolicType).first as? HKQuantitySample else { continue }
+                let dayStart = calendar.startOfDay(for: correlation.startDate)
+                let systolicValue = systolicSample.quantity.doubleValue(for: unit)
+                let diastolicValue = diastolicSample.quantity.doubleValue(for: unit)
+                grouped[dayStart, default: []].append((systolicValue, diastolicValue))
+            }
+
+            var aggregatedSamples: [[String: Any]] = []
+            for (dayStart, readings) in grouped {
+                guard !readings.isEmpty else { continue }
+                let systolicAvg = readings.map { $0.0 }.reduce(0, +) / Double(readings.count)
+                let diastolicAvg = readings.map { $0.1 }.reduce(0, +) / Double(readings.count)
+                let bucketStart = dayStart.timeIntervalSince1970 * 1000
+                let bucketEnd = (calendar.date(byAdding: dayComponent, to: dayStart)?.timeIntervalSince1970 ?? dayStart.timeIntervalSince1970) * 1000
+                aggregatedSamples.append([
+                    "startDate": bucketStart,
+                    "endDate": bucketEnd,
+                    "systolic": systolicAvg,
+                    "diastolic": diastolicAvg,
+                    "value": systolicAvg,
+                    "unit": unit.unitString
+                ])
+            }
+
+            aggregatedSamples.sort { (lhs, rhs) in
+                guard let lhsStart = lhs["startDate"] as? Double, let rhsStart = rhs["startDate"] as? Double else { return false }
+                return lhsStart < rhsStart
+            }
+
+            DispatchQueue.main.async {
+                completion(aggregatedSamples, nil)
+            }
+        }
+        healthStore.execute(query)
+    }
+
+    private func queryLatestTotalCalories(_ call: CAPPluginCall) {
+        let unit = HKUnit.kilocalorie()
+        let group = DispatchGroup()
+
+        var activeValue: Double?
+        var basalValue: Double?
+        var activeDate: Date?
+        var basalDate: Date?
+        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
+            group.leave()
+        }
+
+        if basalSupported {
+            group.enter()
+            fetchLatest(.basalEnergyBurned) { value, date, error in
+                basalValue = value
+                basalDate = date
+                queryError = queryError ?? error
+                group.leave()
+            }
+        }
+
+        group.notify(queue: .main) {
+            if let error = queryError {
+                call.reject("Error fetching total calories: \(error.localizedDescription)")
+                return
+            }
+            guard activeValue != nil || basalValue != 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
+            call.resolve([
+                "value": total,
+                "timestamp": timestamp,
+                "unit": unit.unitString
+            ])
+        }
+    }
+
+    private func collectEnergyBuckets(
+        _ identifier: HKQuantityTypeIdentifier,
+        startDate: Date,
+        endDate: Date,
+        interval: DateComponents,
+        completion: @escaping ([TimeInterval: (start: TimeInterval, end: TimeInterval, value: Double)]?, Error?) -> Void
+    ) {
+        guard let type = HKObjectType.quantityType(forIdentifier: identifier) else {
+            completion([:], nil)
+            return
+        }
+        let predicate = HKQuery.predicateForSamples(withStart: startDate, end: endDate, options: .strictStartDate)
+        let query = HKStatisticsCollectionQuery(
+            quantityType: type,
+            quantitySamplePredicate: predicate,
+            options: .cumulativeSum,
+            anchorDate: startDate,
+            intervalComponents: interval
+        )
+        query.initialResultsHandler = { _, result, error in
+            if let error = error {
+                completion(nil, error)
+                return
+            }
+            var buckets: [TimeInterval: (start: TimeInterval, end: TimeInterval, value: Double)] = [:]
+            result?.enumerateStatistics(from: startDate, to: endDate) { statistics, _ in
+                guard let quantity = statistics.sumQuantity() else { return }
+                let startMs = statistics.startDate.timeIntervalSince1970 * 1000
+                let endMs = statistics.endDate.timeIntervalSince1970 * 1000
+                buckets[startMs] = (startMs, endMs, quantity.doubleValue(for: HKUnit.kilocalorie()))
+            }
+            completion(buckets, nil)
+        }
+        healthStore.execute(query)
+    }
+
+    private func queryTotalCaloriesAggregated(
+        startDate: Date,
+        endDate: Date,
+        interval: DateComponents,
+        completion: @escaping ([[String: Any]]?, Error?) -> Void
+    ) {
+        let group = DispatchGroup()
+        let basalSupported = HKObjectType.quantityType(forIdentifier: .basalEnergyBurned) != nil
+        var activeBuckets: [TimeInterval: (start: TimeInterval, end: TimeInterval, value: Double)]?
+        var basalBuckets: [TimeInterval: (start: TimeInterval, end: TimeInterval, value: Double)]?
+        var queryError: Error?
+
+        group.enter()
+        collectEnergyBuckets(.activeEnergyBurned, startDate: startDate, endDate: endDate, interval: interval) { buckets, error in
+            activeBuckets = buckets
+            queryError = queryError ?? error
+            group.leave()
+        }
+
+        if basalSupported {
+            group.enter()
+            collectEnergyBuckets(.basalEnergyBurned, startDate: startDate, endDate: endDate, interval: interval) { buckets, error in
+                basalBuckets = buckets
+                queryError = queryError ?? error
+                group.leave()
+            }
+        }
+
+        group.notify(queue: .main) {
+            if let error = queryError {
+                completion(nil, error)
+                return
+            }
+            let active = activeBuckets ?? [:]
+            let basal = basalBuckets ?? [:]
+            let allKeys = Set(active.keys).union(basal.keys).sorted()
+            var aggregated: [[String: Any]] = []
+            let calendar = Calendar.current
+            for key in allKeys {
+                let startMs = key
+                let endMs = active[key]?.end ?? basal[key]?.end ?? {
+                    let date = Date(timeIntervalSince1970: startMs / 1000)
+                    return (calendar.date(byAdding: interval, to: date) ?? date).timeIntervalSince1970 * 1000
+                }()
+                let value = (active[key]?.value ?? 0) + (basal[key]?.value ?? 0)
+                aggregated.append([
+                    "startDate": startMs,
+                    "endDate": endMs,
+                    "value": value
+                ])
+            }
+            completion(aggregated.sorted { ($0["startDate"] as? Double ?? 0) < ($1["startDate"] as? Double ?? 0) }, nil)
+        }
+    }
 
     private func queryAggregated(for startDate: Date, for endDate: Date, for dataType: HKQuantityType?, completion: @escaping (Double?) -> Void) {
         guard let quantityType = dataType else {
@@ -609,7 +1057,7 @@ public class HealthPlugin: CAPPlugin, CAPBridgedPlugin {
                 return
             }
             let outerGroup = DispatchGroup()
-            let resultsQueue = DispatchQueue(label: "com.flomentum.healthplugin.workoutResults")
+            let resultsQueue = DispatchQueue(label: "com.flomentumsolutions.healthplugin.workoutResults")
             var workoutResults: [[String: Any]] = []
             var errors: [String: String] = [:]
             
@@ -627,48 +1075,54 @@ public class HealthPlugin: CAPPlugin, CAPBridgedPlugin {
                     "distance": workout.totalDistance?.doubleValue(for: .meter()) ?? 0
                 ]
                 let innerGroup = DispatchGroup()
+                let heartRateQueue = DispatchQueue(label: "com.flomentumsolutions.healthplugin.heartRates")
+                let routeQueue = DispatchQueue(label: "com.flomentumsolutions.healthplugin.routes")
                 var localHeartRates: [[String: Any]] = []
                 var localRoutes: [[String: Any]] = []
                 
                 if includeHeartRate {
                     innerGroup.enter()
                     self.queryHeartRate(for: workout) { rates, error in
-                        localHeartRates = rates
-                        if let error = error { 
-                            resultsQueue.async {
-                                errors["heart-rate"] = error 
+                        heartRateQueue.async {
+                            localHeartRates = rates
+                            if let error = error {
+                                errors["heart-rate"] = error
                             }
+                            innerGroup.leave()
                         }
-                        innerGroup.leave()
                     }
                 }
                 if includeRoute {
                     innerGroup.enter()
                     self.queryRoute(for: workout) { routes, error in
-                        localRoutes = routes
-                        if let error = error { 
-                            resultsQueue.async {
-                                errors["route"] = error 
+                        routeQueue.async {
+                            localRoutes = routes
+                            if let error = error {
+                                errors["route"] = error
                             }
+                            innerGroup.leave()
                         }
-                        innerGroup.leave()
                     }
                 }
                 if includeSteps {
                     innerGroup.enter()
                     self.queryAggregated(for: workout.startDate, for: workout.endDate, for: HKObjectType.quantityType(forIdentifier: .stepCount)) { steps in
-                        if let steps = steps {
-                            localDict["steps"] = steps
+                        resultsQueue.async {
+                            if let steps = steps {
+                                localDict["steps"] = steps
+                            }
+                            innerGroup.leave()
                         }
-                        innerGroup.leave()
                     }
                 }
-                innerGroup.notify(queue: .main) {
-                    localDict["heartRate"] = localHeartRates
-                    localDict["route"] = localRoutes
-                    resultsQueue.async {
-                        workoutResults.append(localDict)
+                innerGroup.notify(queue: resultsQueue) {
+                    heartRateQueue.sync {
+                        localDict["heartRate"] = localHeartRates
+                    }
+                    routeQueue.sync {
+                        localDict["route"] = localRoutes
                     }
+                    workoutResults.append(localDict)
                     outerGroup.leave()
                 }
             }
@@ -721,7 +1175,7 @@ public class HealthPlugin: CAPPlugin, CAPBridgedPlugin {
             guard let self = self else { return }
             if let routes = samples as? [HKWorkoutRoute], error == nil {
                 let routeDispatchGroup = DispatchGroup()
-                let allLocationsQueue = DispatchQueue(label: "com.flomentum.healthplugin.allLocations")
+                let allLocationsQueue = DispatchQueue(label: "com.flomentumsolutions.healthplugin.allLocations")
                 var allLocations: [[String: Any]] = []
                 
                 for route in routes {
@@ -870,4 +1324,4 @@ public class HealthPlugin: CAPPlugin, CAPBridgedPlugin {
         3000 : "other"
     ]
     
-}
+}