@capgo/capacitor-health 8.2.7 → 8.2.9

package/README.md

@@ -60,7 +60,7 @@ npx cap sync
 This plugin now uses [Health Connect](https://developer.android.com/health-and-fitness/guides/health-connect) instead of Google Fit. Make sure your app meets the requirements below:
 
 1. **Min SDK 26+.** Health Connect is only available on Android 8.0 (API 26) and above. The plugin's Gradle setup already targets this level.
-2. **Declare Health permissions.** The plugin manifest ships with the required `<uses-permission>` declarations (`READ_/WRITE_STEPS`, `READ_/WRITE_DISTANCE`, `READ_/WRITE_ACTIVE_CALORIES_BURNED`, `READ_/WRITE_HEART_RATE`, `READ_/WRITE_WEIGHT`). Your app does not need to duplicate them, but you must surface a user-facing rationale because the permissions are considered health sensitive.
+2. **Declare Health permissions.** The plugin manifest ships with the required `<uses-permission>` declarations for basic data types (`READ_/WRITE_STEPS`, `READ_/WRITE_DISTANCE`, `READ_/WRITE_ACTIVE_CALORIES_BURNED`, `READ_/WRITE_HEART_RATE`, `READ_/WRITE_WEIGHT`, `READ_/WRITE_SLEEP`, `READ_/WRITE_RESPIRATORY_RATE`, `READ_/WRITE_OXYGEN_SATURATION`, `READ_/WRITE_RESTING_HEART_RATE`, `READ_/WRITE_HEART_RATE_VARIABILITY`). Your app does not need to duplicate them, but you must surface a user-facing rationale because the permissions are considered health sensitive.
 3. **Ensure Health Connect is installed.** Devices on Android 14+ include it by default. For earlier versions the user must install _Health Connect by Android_ from the Play Store. The `Health.isAvailable()` helper exposes the current status so you can prompt accordingly.
 4. **Request runtime access.** The plugin opens the Health Connect permission UI when you call `requestAuthorization`. You should still handle denial flows (e.g., show a message if `checkAuthorization` reports missing scopes).
 5. **Provide a Privacy Policy.** Health Connect requires apps to display a privacy policy explaining how health data is used. See the [Privacy Policy Setup](#privacy-policy-setup) section below.
@@ -151,14 +151,19 @@ await Health.saveSample({
 
 ### Supported data types
 
-| Identifier  | Default unit  | Notes                                                    |
-| ----------- | ------------- | -------------------------------------------------------- |
-| `steps`     | `count`       | Step count deltas                                        |
-| `distance`  | `meter`       | Walking / running distance                               |
-| `calories`  | `kilocalorie` | Active energy burned                                     |
-| `heartRate` | `bpm`         | Beats per minute                                         |
-| `weight`    | `kilogram`    | Body mass                                                |
-| `workouts`  | N/A           | Workout sessions (read-only, use with `queryWorkouts()`) |
+| Identifier              | Default unit  | Notes                                                    |
+| ----------------------- | ------------- | -------------------------------------------------------- |
+| `steps`                 | `count`       | Step count deltas                                        |
+| `distance`              | `meter`       | Walking / running distance                               |
+| `calories`              | `kilocalorie` | Active energy burned                                     |
+| `heartRate`             | `bpm`         | Beats per minute                                         |
+| `weight`                | `kilogram`    | Body mass                                                |
+| `sleep`                 | `minute`      | Sleep sessions with duration and states                  |
+| `respiratoryRate`       | `bpm`         | Breaths per minute                                       |
+| `oxygenSaturation`      | `percent`     | Blood oxygen saturation (SpO2)                           |
+| `restingHeartRate`      | `bpm`         | Resting heart rate                                       |
+| `heartRateVariability`  | `millisecond` | Heart rate variability (HRV)                             |
+| `workouts`              | N/A           | Workout sessions (read-only, use with `queryWorkouts()`) |
 
 All write operations expect the default unit shown above. On Android the `metadata` option is currently ignored by Health Connect.
 
@@ -196,6 +201,79 @@ while (result.anchor) {
 }
 ```
 
+### New Data Types Examples
+
+**Sleep data:**
+```ts
+// Request permission for sleep data
+await Health.requestAuthorization({
+  read: ['sleep'],
+});
+
+// Read sleep sessions from the past week
+const { samples } = await Health.readSamples({
+  dataType: 'sleep',
+  startDate: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString(),
+  endDate: new Date().toISOString(),
+});
+
+samples.forEach(sample => {
+  console.log(`Sleep: ${sample.value} minutes, state: ${sample.sleepState}`);
+});
+```
+
+**Respiratory rate, oxygen saturation, and HRV:**
+```ts
+// Request permission
+await Health.requestAuthorization({
+  read: ['respiratoryRate', 'oxygenSaturation', 'restingHeartRate', 'heartRateVariability'],
+});
+
+// Read respiratory rate
+const { samples: respiratoryRate } = await Health.readSamples({
+  dataType: 'respiratoryRate',
+  startDate: new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString(),
+  endDate: new Date().toISOString(),
+});
+
+// Read oxygen saturation (SpO2)
+const { samples: oxygenSat } = await Health.readSamples({
+  dataType: 'oxygenSaturation',
+  startDate: new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString(),
+  endDate: new Date().toISOString(),
+});
+```
+
+### Aggregated Queries
+
+For large date ranges, use `queryAggregated()` to get aggregated data efficiently instead of fetching individual samples:
+
+```ts
+// Get daily step totals for the past month
+const { samples } = await Health.queryAggregated({
+  dataType: 'steps',
+  startDate: new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString(),
+  endDate: new Date().toISOString(),
+  bucket: 'day',        // Options: 'hour', 'day', 'week', 'month'
+  aggregation: 'sum',   // Options: 'sum', 'average', 'min', 'max'
+});
+
+samples.forEach(sample => {
+  console.log(`${sample.startDate}: ${sample.value} ${sample.unit}`);
+});
+
+// Get average heart rate by day
+const { samples: avgHR } = await Health.queryAggregated({
+  dataType: 'heartRate',
+  startDate: new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString(),
+  endDate: new Date().toISOString(),
+  bucket: 'day',
+  aggregation: 'average',
+});
+```
+
+**Note:** Aggregated queries are not supported for sleep, respiratory rate, oxygen saturation, and heart rate variability data types. These are instantaneous measurements and should use `readSamples()` instead. Aggregation is supported for: steps, distance, calories, heart rate, weight, and resting heart rate.
+
 ## API
 
 <docgen-index>
@@ -209,6 +287,7 @@ while (result.anchor) {
 * [`openHealthConnectSettings()`](#openhealthconnectsettings)
 * [`showPrivacyPolicy()`](#showprivacypolicy)
 * [`queryWorkouts(...)`](#queryworkouts)
+* [`queryAggregated(...)`](#queryaggregated)
 * [Interfaces](#interfaces)
 * [Type Aliases](#type-aliases)
 
@@ -361,6 +440,27 @@ Supported on iOS (HealthKit) and Android (Health Connect).
 --------------------
 
 
+### queryAggregated(...)
+
+```typescript
+queryAggregated(options: QueryAggregatedOptions) => Promise<QueryAggregatedResult>
+```
+
+Queries aggregated health data from the native health store.
+Aggregates data into time buckets (hour, day, week, month) with operations like sum, average, min, or max.
+This is more efficient than fetching individual samples for large date ranges.
+
+Supported on iOS (HealthKit) and Android (Health Connect).
+
+| Param         | Type                                                                      | Description                                                                      |
+| ------------- | ------------------------------------------------------------------------- | -------------------------------------------------------------------------------- |
+| **`options`** | <code><a href="#queryaggregatedoptions">QueryAggregatedOptions</a></code> | Query options including data type, date range, bucket size, and aggregation type |
+
+**Returns:** <code>Promise&lt;<a href="#queryaggregatedresult">QueryAggregatedResult</a>&gt;</code>
+
+--------------------
+
+
 ### Interfaces
 
 
@@ -400,15 +500,16 @@ Supported on iOS (HealthKit) and Android (Health Connect).
 
 #### HealthSample
 
-| Prop             | Type                                                      |
-| ---------------- | --------------------------------------------------------- |
-| **`dataType`**   | <code><a href="#healthdatatype">HealthDataType</a></code> |
-| **`value`**      | <code>number</code>                                       |
-| **`unit`**       | <code><a href="#healthunit">HealthUnit</a></code>         |
-| **`startDate`**  | <code>string</code>                                       |
-| **`endDate`**    | <code>string</code>                                       |
-| **`sourceName`** | <code>string</code>                                       |
-| **`sourceId`**   | <code>string</code>                                       |
+| Prop             | Type                                                      | Description                                                                                  |
+| ---------------- | --------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
+| **`dataType`**   | <code><a href="#healthdatatype">HealthDataType</a></code> |                                                                                              |
+| **`value`**      | <code>number</code>                                       |                                                                                              |
+| **`unit`**       | <code><a href="#healthunit">HealthUnit</a></code>         |                                                                                              |
+| **`startDate`**  | <code>string</code>                                       |                                                                                              |
+| **`endDate`**    | <code>string</code>                                       |                                                                                              |
+| **`sourceName`** | <code>string</code>                                       |                                                                                              |
+| **`sourceId`**   | <code>string</code>                                       |                                                                                              |
+| **`sleepState`** | <code><a href="#sleepstate">SleepState</a></code>         | For sleep data, indicates the sleep state (e.g., 'asleep', 'awake', 'rem', 'deep', 'light'). |
 
 
 #### QueryOptions
@@ -469,17 +570,50 @@ Supported on iOS (HealthKit) and Android (Health Connect).
 | **`anchor`**      | <code>string</code>                                 | Anchor for pagination. Use the anchor returned from a previous query to continue from that point. On iOS, this uses HKQueryAnchor. On Android, this uses Health Connect's pageToken. Omit this parameter to start from the beginning. |
 
 
+#### QueryAggregatedResult
+
+| Prop          | Type                            |
+| ------------- | ------------------------------- |
+| **`samples`** | <code>AggregatedSample[]</code> |
+
+
+#### AggregatedSample
+
+| Prop            | Type                                              | Description                        |
+| --------------- | ------------------------------------------------- | ---------------------------------- |
+| **`startDate`** | <code>string</code>                               | ISO 8601 start date of the bucket. |
+| **`endDate`**   | <code>string</code>                               | ISO 8601 end date of the bucket.   |
+| **`value`**     | <code>number</code>                               | Aggregated value for the bucket.   |
+| **`unit`**      | <code><a href="#healthunit">HealthUnit</a></code> | Unit of the aggregated value.      |
+
+
+#### QueryAggregatedOptions
+
+| Prop              | Type                                                        | Description                                              |
+| ----------------- | ----------------------------------------------------------- | -------------------------------------------------------- |
+| **`dataType`**    | <code><a href="#healthdatatype">HealthDataType</a></code>   | The type of data to aggregate from the health store.     |
+| **`startDate`**   | <code>string</code>                                         | Inclusive ISO 8601 start date (defaults to now - 1 day). |
+| **`endDate`**     | <code>string</code>                                         | Exclusive ISO 8601 end date (defaults to now).           |
+| **`bucket`**      | <code><a href="#buckettype">BucketType</a></code>           | Time bucket for aggregation (defaults to 'day').         |
+| **`aggregation`** | <code><a href="#aggregationtype">AggregationType</a></code> | Aggregation operation to perform (defaults to 'sum').    |
+
+
 ### Type Aliases
 
 
 #### HealthDataType
 
-<code>'steps' | 'distance' | 'calories' | 'heartRate' | 'weight'</code>
+<code>'steps' | 'distance' | 'calories' | 'heartRate' | 'weight' | 'sleep' | 'respiratoryRate' | 'oxygenSaturation' | 'restingHeartRate' | 'heartRateVariability'</code>
 
 
 #### HealthUnit
 
-<code>'count' | 'meter' | 'kilocalorie' | 'bpm' | 'kilogram'</code>
+<code>'count' | 'meter' | 'kilocalorie' | 'bpm' | 'kilogram' | 'minute' | 'percent' | 'millisecond'</code>
+
+
+#### SleepState
+
+<code>'inBed' | 'asleep' | 'awake' | 'rem' | 'deep' | 'light'</code>
 
 
 #### Record
@@ -493,6 +627,16 @@ Construct a type with a set of properties K of type T
 
 <code>'running' | 'cycling' | 'walking' | 'swimming' | 'yoga' | 'strengthTraining' | 'hiking' | 'tennis' | 'basketball' | 'soccer' | 'americanFootball' | 'baseball' | 'crossTraining' | 'elliptical' | 'rowing' | 'stairClimbing' | 'traditionalStrengthTraining' | 'waterFitness' | 'waterPolo' | 'waterSports' | 'wrestling' | 'other'</code>
 
+
+#### BucketType
+
+<code>'hour' | 'day' | 'week' | 'month'</code>
+
+
+#### AggregationType
+
+<code>'sum' | 'average' | 'min' | 'max'</code>
+
 </docgen-api>
 
 ### Credits:

package/android/src/main/AndroidManifest.xml

@@ -9,6 +9,17 @@
     <uses-permission android:name="android.permission.health.WRITE_HEART_RATE" />
     <uses-permission android:name="android.permission.health.READ_WEIGHT" />
     <uses-permission android:name="android.permission.health.WRITE_WEIGHT" />
+    <uses-permission android:name="android.permission.health.READ_SLEEP" />
+    <uses-permission android:name="android.permission.health.WRITE_SLEEP" />
+    <uses-permission android:name="android.permission.health.READ_RESPIRATORY_RATE" />
+    <uses-permission android:name="android.permission.health.WRITE_RESPIRATORY_RATE" />
+    <uses-permission android:name="android.permission.health.READ_OXYGEN_SATURATION" />
+    <uses-permission android:name="android.permission.health.WRITE_OXYGEN_SATURATION" />
+    <uses-permission android:name="android.permission.health.READ_RESTING_HEART_RATE" />
+    <uses-permission android:name="android.permission.health.WRITE_RESTING_HEART_RATE" />
+    <uses-permission android:name="android.permission.health.READ_HEART_RATE_VARIABILITY" />
+    <uses-permission android:name="android.permission.health.WRITE_HEART_RATE_VARIABILITY" />
+    <uses-permission android:name="android.permission.health.READ_EXERCISE" />
 
     <!-- Query for Health Connect availability -->
     <queries>

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

@@ -4,7 +4,12 @@ import androidx.health.connect.client.permission.HealthPermission
 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.HeartRateVariabilityRmssdRecord
+import androidx.health.connect.client.records.OxygenSaturationRecord
 import androidx.health.connect.client.records.Record
+import androidx.health.connect.client.records.RespiratoryRateRecord
+import androidx.health.connect.client.records.RestingHeartRateRecord
+import androidx.health.connect.client.records.SleepSessionRecord
 import androidx.health.connect.client.records.StepsRecord
 import androidx.health.connect.client.records.WeightRecord
 import kotlin.reflect.KClass
@@ -18,7 +23,12 @@ enum class HealthDataType(
     DISTANCE("distance", DistanceRecord::class, "meter"),
     CALORIES("calories", ActiveCaloriesBurnedRecord::class, "kilocalorie"),
     HEART_RATE("heartRate", HeartRateRecord::class, "bpm"),
-    WEIGHT("weight", WeightRecord::class, "kilogram");
+    WEIGHT("weight", WeightRecord::class, "kilogram"),
+    SLEEP("sleep", SleepSessionRecord::class, "minute"),
+    RESPIRATORY_RATE("respiratoryRate", RespiratoryRateRecord::class, "bpm"),
+    OXYGEN_SATURATION("oxygenSaturation", OxygenSaturationRecord::class, "percent"),
+    RESTING_HEART_RATE("restingHeartRate", RestingHeartRateRecord::class, "bpm"),
+    HEART_RATE_VARIABILITY("heartRateVariability", HeartRateVariabilityRmssdRecord::class, "millisecond");
 
     val readPermission: String
         get() = HealthPermission.getReadPermission(recordClass)

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

@@ -7,7 +7,12 @@ import androidx.health.connect.client.records.ActiveCaloriesBurnedRecord
 import androidx.health.connect.client.records.DistanceRecord
 import androidx.health.connect.client.records.ExerciseSessionRecord
 import androidx.health.connect.client.records.HeartRateRecord
+import androidx.health.connect.client.records.HeartRateVariabilityRmssdRecord
+import androidx.health.connect.client.records.OxygenSaturationRecord
 import androidx.health.connect.client.records.Record
+import androidx.health.connect.client.records.RespiratoryRateRecord
+import androidx.health.connect.client.records.RestingHeartRateRecord
+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.request.ReadRecordsRequest
@@ -15,6 +20,8 @@ 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.units.Percentage
+import androidx.health.connect.client.units.Power
 import androidx.health.connect.client.records.metadata.Metadata
 import java.time.Duration
 import com.getcapacitor.JSArray
@@ -148,6 +155,62 @@ class HealthManager {
                     samples.add(sample.time to payload)
                 }
             }
+            HealthDataType.SLEEP -> readRecords(client, SleepSessionRecord::class, startTime, endTime, limit) { record ->
+                // For sleep sessions, calculate duration in minutes
+                val durationMinutes = Duration.between(record.startTime, record.endTime).toMinutes().toDouble()
+                val payload = createSamplePayload(
+                    dataType,
+                    record.startTime,
+                    record.endTime,
+                    durationMinutes,
+                    record.metadata
+                )
+                // Add sleep stage if available (map from sleep session stages)
+                // Note: SleepSessionRecord doesn't have individual stages in the main record
+                // Individual sleep stages would be in SleepStageRecord, but for simplicity
+                // we'll just return the session duration
+                samples.add(record.startTime to payload)
+            }
+            HealthDataType.RESPIRATORY_RATE -> readRecords(client, RespiratoryRateRecord::class, startTime, endTime, limit) { record ->
+                val payload = createSamplePayload(
+                    dataType,
+                    record.time,
+                    record.time,
+                    record.rate,
+                    record.metadata
+                )
+                samples.add(record.time to payload)
+            }
+            HealthDataType.OXYGEN_SATURATION -> readRecords(client, OxygenSaturationRecord::class, startTime, endTime, limit) { record ->
+                val payload = createSamplePayload(
+                    dataType,
+                    record.time,
+                    record.time,
+                    record.percentage.value,
+                    record.metadata
+                )
+                samples.add(record.time to payload)
+            }
+            HealthDataType.RESTING_HEART_RATE -> readRecords(client, RestingHeartRateRecord::class, startTime, endTime, limit) { record ->
+                val payload = createSamplePayload(
+                    dataType,
+                    record.time,
+                    record.time,
+                    record.beatsPerMinute.toDouble(),
+                    record.metadata
+                )
+                samples.add(record.time to payload)
+            }
+            HealthDataType.HEART_RATE_VARIABILITY -> readRecords(client, HeartRateVariabilityRmssdRecord::class, startTime, endTime, limit) { record ->
+                val payload = createSamplePayload(
+                    dataType,
+                    record.time,
+                    record.time,
+                    record.heartRateVariabilityMillis,
+                    record.metadata
+                )
+                samples.add(record.time to payload)
+            }
         }
 
         val sorted = samples.sortedBy { it.first }
@@ -246,6 +309,47 @@ class HealthManager {
                 )
                 client.insertRecords(listOf(record))
             }
+            HealthDataType.SLEEP -> {
+                val record = SleepSessionRecord(
+                    startTime = startTime,
+                    startZoneOffset = zoneOffset(startTime),
+                    endTime = endTime,
+                    endZoneOffset = zoneOffset(endTime)
+                )
+                client.insertRecords(listOf(record))
+            }
+            HealthDataType.RESPIRATORY_RATE -> {
+                val record = RespiratoryRateRecord(
+                    time = startTime,
+                    zoneOffset = zoneOffset(startTime),
+                    rate = value
+                )
+                client.insertRecords(listOf(record))
+            }
+            HealthDataType.OXYGEN_SATURATION -> {
+                val record = OxygenSaturationRecord(
+                    time = startTime,
+                    zoneOffset = zoneOffset(startTime),
+                    percentage = Percentage(value)
+                )
+                client.insertRecords(listOf(record))
+            }
+            HealthDataType.RESTING_HEART_RATE -> {
+                val record = RestingHeartRateRecord(
+                    time = startTime,
+                    zoneOffset = zoneOffset(startTime),
+                    beatsPerMinute = value.toBpmLong()
+                )
+                client.insertRecords(listOf(record))
+            }
+            HealthDataType.HEART_RATE_VARIABILITY -> {
+                val record = HeartRateVariabilityRmssdRecord(
+                    time = startTime,
+                    zoneOffset = zoneOffset(startTime),
+                    heartRateVariabilityMillis = value
+                )
+                client.insertRecords(listOf(record))
+            }
         }
     }
 
@@ -293,6 +397,127 @@ class HealthManager {
         return java.lang.Math.round(this.coerceAtLeast(0.0))
     }
 
+    suspend fun queryAggregated(
+        client: HealthConnectClient,
+        dataType: HealthDataType,
+        startTime: Instant,
+        endTime: Instant,
+        bucket: String,
+        aggregation: String
+    ): JSObject {
+        // Sleep aggregation is not directly supported like other metrics
+        if (dataType == HealthDataType.SLEEP) {
+            throw IllegalArgumentException("Aggregated queries are not supported for sleep data. Use readSamples instead.")
+        }
+        
+        // Instantaneous measurement records don't support aggregation in Health Connect
+        // These data types should use readSamples instead
+        if (dataType == HealthDataType.RESPIRATORY_RATE || 
+            dataType == HealthDataType.OXYGEN_SATURATION || 
+            dataType == HealthDataType.HEART_RATE_VARIABILITY) {
+            throw IllegalArgumentException("Aggregated queries are not supported for ${dataType.identifier}. Use readSamples instead.")
+        }
+
+        val samples = JSArray()
+        
+        // Determine bucket size
+        // Note: Monthly buckets use 30 days as an approximation, which may not align exactly
+        // with calendar months. This provides consistent bucket sizes but users should be aware
+        // that "month" buckets don't correspond to actual calendar months (Jan, Feb, etc.).
+        val bucketDuration = when (bucket) {
+            "hour" -> Duration.ofHours(1)
+            "day" -> Duration.ofDays(1)
+            "week" -> Duration.ofDays(7)
+            "month" -> Duration.ofDays(30) // Approximation: not calendar months
+            else -> Duration.ofDays(1)
+        }
+        
+        // Create time buckets
+        var currentStart = startTime
+        while (currentStart.isBefore(endTime)) {
+            val currentEnd = currentStart.plus(bucketDuration).let {
+                if (it.isAfter(endTime)) endTime else it
+            }
+            
+            try {
+                val metrics = when (dataType) {
+                    HealthDataType.STEPS -> setOf(StepsRecord.COUNT_TOTAL)
+                    HealthDataType.DISTANCE -> setOf(DistanceRecord.DISTANCE_TOTAL)
+                    HealthDataType.CALORIES -> setOf(ActiveCaloriesBurnedRecord.ACTIVE_CALORIES_TOTAL)
+                    HealthDataType.HEART_RATE -> setOf(HeartRateRecord.BPM_AVG, HeartRateRecord.BPM_MAX, HeartRateRecord.BPM_MIN)
+                    HealthDataType.WEIGHT -> setOf(WeightRecord.WEIGHT_AVG, WeightRecord.WEIGHT_MAX, WeightRecord.WEIGHT_MIN)
+                    HealthDataType.RESTING_HEART_RATE -> setOf(RestingHeartRateRecord.BPM_AVG, RestingHeartRateRecord.BPM_MAX, RestingHeartRateRecord.BPM_MIN)
+                    else -> throw IllegalArgumentException("Unsupported data type for aggregation: ${dataType.identifier}")
+                }
+                
+                val aggregateRequest = AggregateRequest(
+                    metrics = metrics,
+                    timeRangeFilter = TimeRangeFilter.between(currentStart, currentEnd)
+                )
+                
+                val result = client.aggregate(aggregateRequest)
+                
+                // Extract the appropriate aggregated value based on the aggregation type and data type
+                val value: Double? = when (dataType) {
+                    HealthDataType.STEPS -> when (aggregation) {
+                        "sum" -> result[StepsRecord.COUNT_TOTAL]?.toDouble()
+                        else -> result[StepsRecord.COUNT_TOTAL]?.toDouble()
+                    }
+                    HealthDataType.DISTANCE -> when (aggregation) {
+                        "sum" -> result[DistanceRecord.DISTANCE_TOTAL]?.inMeters
+                        else -> result[DistanceRecord.DISTANCE_TOTAL]?.inMeters
+                    }
+                    HealthDataType.CALORIES -> when (aggregation) {
+                        "sum" -> result[ActiveCaloriesBurnedRecord.ACTIVE_CALORIES_TOTAL]?.inKilocalories
+                        else -> result[ActiveCaloriesBurnedRecord.ACTIVE_CALORIES_TOTAL]?.inKilocalories
+                    }
+                    HealthDataType.HEART_RATE -> when (aggregation) {
+                        "average" -> result[HeartRateRecord.BPM_AVG]?.toDouble()
+                        "max" -> result[HeartRateRecord.BPM_MAX]?.toDouble()
+                        "min" -> result[HeartRateRecord.BPM_MIN]?.toDouble()
+                        else -> result[HeartRateRecord.BPM_AVG]?.toDouble()
+                    }
+                    HealthDataType.WEIGHT -> when (aggregation) {
+                        "average" -> result[WeightRecord.WEIGHT_AVG]?.inKilograms
+                        "max" -> result[WeightRecord.WEIGHT_MAX]?.inKilograms
+                        "min" -> result[WeightRecord.WEIGHT_MIN]?.inKilograms
+                        else -> result[WeightRecord.WEIGHT_AVG]?.inKilograms
+                    }
+                    HealthDataType.RESTING_HEART_RATE -> when (aggregation) {
+                        "average" -> result[RestingHeartRateRecord.BPM_AVG]?.toDouble()
+                        "max" -> result[RestingHeartRateRecord.BPM_MAX]?.toDouble()
+                        "min" -> result[RestingHeartRateRecord.BPM_MIN]?.toDouble()
+                        else -> result[RestingHeartRateRecord.BPM_AVG]?.toDouble()
+                    }
+                    else -> null
+                }
+                
+                // Only add the sample if we have a value
+                if (value != null) {
+                    val sample = JSObject().apply {
+                        put("startDate", formatter.format(currentStart))
+                        put("endDate", formatter.format(currentEnd))
+                        put("value", value)
+                        put("unit", dataType.unit)
+                    }
+                    samples.put(sample)
+                }
+            } catch (e: CancellationException) {
+                throw e
+            } catch (e: SecurityException) {
+                android.util.Log.d("HealthManager", "Permission denied for aggregation: ${e.message}", e)
+            } catch (e: Exception) {
+                android.util.Log.d("HealthManager", "Aggregation failed for bucket: ${e.message}", e)
+            }
+            
+            currentStart = currentEnd
+        }
+        
+        return JSObject().apply {
+            put("samples", samples)
+        }
+    }
+
     suspend fun queryWorkouts(
         client: HealthConnectClient,
         workoutType: String?,

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

@@ -385,6 +385,55 @@ class HealthPlugin : Plugin() {
         }
     }
 
+    @PluginMethod
+    fun queryAggregated(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 bucket = call.getString("bucket") ?: "day"
+        val aggregation = call.getString("aggregation") ?: "sum"
+
+        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 result = manager.queryAggregated(client, dataType, startInstant, endInstant, bucket, aggregation)
+                call.resolve(result)
+            } catch (e: IllegalArgumentException) {
+                call.reject(e.message ?: "Unsupported aggregation.", null, e)
+            } catch (e: Exception) {
+                call.reject(e.message ?: "Failed to query aggregated data.", null, e)
+            }
+        }
+    }
+
     companion object {
         private const val DEFAULT_LIMIT = 100
         private val DEFAULT_PAST_DURATION: Duration = Duration.ofDays(1)