Added the inLocalTimeZone parameter to the prepareResponse function.

android/src/main/java/com/reactnative/googlefit/GoogleFitModule.java

@@ -466,6 +466,22 @@ public void getHeartRateSamples(double startDate,
         }
     }
 
+    @ReactMethod
+    public void getAggregatedHeartRateSamples(double startDate,
+                                              double endDate,
+                                              int bucketInterval,
+                                              String bucketUnit,
+                                              Promise promise) {
+
+        try {
+            HealthHistory healthHistory = mGoogleFitManager.getHealthHistory();
+            healthHistory.setDataType(DataType.TYPE_HEART_RATE_BPM);
+            promise.resolve(healthHistory.getAggregatedHeartRateHistory((long)startDate, (long)endDate, bucketInterval, bucketUnit));
+        } catch (IllegalViewOperationException e) {
+            promise.reject(e);
+        }
+    }
+
     @ReactMethod
     public void getRestingHeartRateSamples(double startDate,
                                     double endDate,

android/src/main/java/com/reactnative/googlefit/HealthHistory.java

@@ -102,6 +102,47 @@ else if (dataReadResult.getDataSets().size() > 0) {
         return map;
     }
 
+    /**
+     * GLE added to allow us to aggregate heart rate data.
+     * It does the same as health history, but adds the aggregation.
+     * Note there are also some changes to the processDataSet method to allow for the aggregation.
+     */
+    public ReadableArray getAggregatedHeartRateHistory(long startTime, long endTime, int bucketInterval, String bucketUnit) {
+        DataReadRequest.Builder readRequestBuilder = new DataReadRequest.Builder()
+                .setTimeRange(startTime, endTime, TimeUnit.MILLISECONDS);
+
+        if (this.dataType == DataType.TYPE_HEART_RATE_BPM) {
+            readRequestBuilder
+                    .aggregate(this.dataType, DataType.AGGREGATE_HEART_RATE_SUMMARY)
+                    .bucketByTime(bucketInterval, HelperUtil.processBucketUnit(bucketUnit));
+        } else {
+            readRequestBuilder.read(this.dataType);
+        }
+
+        DataReadRequest readRequest = readRequestBuilder.build();
+
+        DataReadResult dataReadResult = Fitness.HistoryApi.readData(googleFitManager.getGoogleApiClient(), readRequest).await(1, TimeUnit.MINUTES);
+
+        WritableArray map = Arguments.createArray();
+
+        //Used for aggregated data
+        if (dataReadResult.getBuckets().size() > 0) {
+            for (Bucket bucket : dataReadResult.getBuckets()) {
+                List<DataSet> dataSets = bucket.getDataSets();
+                for (DataSet dataSet : dataSets) {
+                    processDataSet(dataSet, map);
+                }
+            }
+        }
+        //Used for non-aggregated data
+        else if (dataReadResult.getDataSets().size() > 0) {
+            for (DataSet dataSet : dataReadResult.getDataSets()) {
+                processDataSet(dataSet, map);
+            }
+        }
+        return map;
+    }
+
     public ReadableArray getRestingHeartRateHistory(long startTime, long endTime, int bucketInterval, String bucketUnit) {
         DataReadRequest.Builder readRequestBuilder = new DataReadRequest.Builder()
                 .aggregate(new DataSource.Builder()
@@ -283,6 +324,10 @@ private void processDataSet(DataSet dataSet, WritableArray map) {
                 if (this.dataType == HealthDataTypes.TYPE_BLOOD_PRESSURE) {
                     stepMap.putDouble("diastolic", dp.getValue(HealthFields.FIELD_BLOOD_PRESSURE_DIASTOLIC).asFloat());
                     stepMap.putDouble("systolic", dp.getValue(HealthFields.FIELD_BLOOD_PRESSURE_SYSTOLIC).asFloat());
+                } else if (this.dataType == DataType.TYPE_HEART_RATE_BPM && field.toString().startsWith("average")) {
+                    stepMap.putDouble("average", dp.getValue(Field.FIELD_AVERAGE).asFloat());
+                    stepMap.putDouble("min", dp.getValue(Field.FIELD_MIN).asFloat());
+                    stepMap.putDouble("max", dp.getValue(Field.FIELD_MAX).asFloat());
                 } else {
                   stepMap.putDouble("value", dp.getValue(field).asFloat());
                 }

index.android.d.ts

@@ -111,6 +111,11 @@ declare module 'react-native-google-fit' {
       options: StartAndEndDate & Partial<BucketOptions>
     ) => Promise<HeartRateResponse[]>;
 
+    getAggregatedHeartRateSamples: (
+      options: StartAndEndDate & Partial<BucketOptions>,
+      inLocalTimeZone: boolean
+    ) => Promise<AggregatedHeartRateResponse[]>;
+
     /**
      * Query for getting resting heart rate samples. the options object is used to setup a query to retrieve relevant samples.
      * @param {Object} options  getRestingHeartRateSamples accepts an options object startDate: ISO8601Timestamp and endDate: ISO8601Timestamp.
@@ -181,9 +186,11 @@ declare module 'react-native-google-fit' {
     /**
      * Get the sleep sessions over a specified date range.
      * @param {Object} options getSleepData accepts an options object containing required startDate: ISO8601Timestamp and endDate: ISO8601Timestamp.
+     * @param inLocalTimeZone return start and end dates in local time zone rather than converting to UTC.
      */
     getSleepSamples: (
-      options: Partial<StartAndEndDate>
+      options: Partial<StartAndEndDate>,
+      inLocalTimeZone: boolean
     ) => Promise<SleepSampleResponse[]>
 
     saveSleep: (
@@ -340,6 +347,15 @@ declare module 'react-native-google-fit' {
     wasManuallyEntered: boolean
   };
 
+  export type AggregatedHeartRateResponse = {
+    startDate: string,
+    endDate: string,
+    min: number,
+    average: number,
+    max: number,
+    day: Day,
+  }
+
   export type BloodPressureResponse = {
     startDate: string,
     endDate: string,

index.android.js

@@ -567,6 +567,20 @@ class RNGoogleFit {
     return result;
   }
 
+  getAggregatedHeartRateSamples = async (options, inLocalTimeZone = false) => {
+    const { startDate, endDate, bucketInterval, bucketUnit } = prepareInput(options);
+    const result = await googleFit.getAggregatedHeartRateSamples(
+      startDate,
+      endDate,
+      bucketInterval,
+      bucketUnit
+    );
+    if (result.length > 0) {
+      return prepareResponse(result, 'average', inLocalTimeZone);
+    }
+    return result;
+  }
+
   getRestingHeartRateSamples = async (options) => {
     const { startDate, endDate, bucketInterval, bucketUnit } = prepareInput(options);
     const result = await googleFit.getRestingHeartRateSamples(
@@ -689,17 +703,18 @@ class RNGoogleFit {
   /**
    * Get the sleep sessions over a specified date range.
    * @param {Object} options getSleepData accepts an options object containing required startDate: ISO8601Timestamp and endDate: ISO8601Timestamp.
+   * @param inLocalTimeZone return start and end dates in local time zone rather than converting to UTC
    */
 
-  getSleepSamples = async (options) => {
+  getSleepSamples = async (options, inLocalTimeZone = false) => {
     const { startDate, endDate } = prepareInput(options);
 
     const result = await googleFit.getSleepSamples(
       startDate,
       endDate
     );
 
-    return prepareResponse(result, "addedBy");
+    return prepareResponse(result, "addedBy", inLocalTimeZone);
   }
 
   saveSleep = async (options) => {

src/utils.js

@@ -48,7 +48,7 @@ export function prepareInput(options) {
   return { startDate, endDate, bucketInterval, bucketUnit };
 }
 
-export function prepareResponse(response, byKey = 'value') {
+export function prepareResponse(response, byKey = 'value', inLocalTimeZone = false) {
   return response
     .map(el => {
       if (!isNil(el[byKey])) {
@@ -57,8 +57,13 @@ export function prepareResponse(response, byKey = 'value') {
         // the Chrome V8 debugger, but not on device. Using momentJS here to get around this issue.
         // el.startDate = new Date(el.startDate).toISOString()
         // el.endDate = new Date(el.endDate).toISOString()
-        el.startDate = moment(el.startDate).toISOString()
-        el.endDate = moment(el.endDate).toISOString()
+        if (inLocalTimeZone) {
+          el.startDate = moment.parseZone(el.startDate).toISOString(true)
+          el.endDate = moment.parseZone(el.endDate).toISOString(true)
+        } else {
+          el.startDate = moment(el.startDate).toISOString()
+          el.endDate = moment(el.endDate).toISOString()
+        }
         return el
       }
     })