Package visibility in Android 11 for Expo projects

.github/workflows/npm-publish.yml

@@ -0,0 +1,15 @@
+on:
+  push:
+    branches: master
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v3
+        with:
+          node-version: "18"
+      - uses: JS-DevTools/npm-publish@v3
+        with:
+          token: ${{ secrets.NPM_TOKEN }}

README.md

@@ -288,6 +288,9 @@ async function fetchData() {
   const heartrate = await GoogleFit.getHeartRateSamples(opt)；
   console.log(heartrate);
 
+  const restingheartrate = await GoogleFit.getRestingHeartRateSamples(opt)；
+  console.log(restingheartrate);
+
   const bloodpressure = await GoogleFit.getBloodPressureSamples(opt)；
   console.log(bloodpressure);
 }
@@ -318,6 +321,30 @@ async function fetchData() {
   }
 ]
 ```
+Getting aggregated heart rate samples:
+
+```typescript
+/**
+ * Query for getting aggregated heart rate samples.
+ * @param options
+ * @param inLocalTimeZone
+ */
+getAggregatedHeartRateSamples: (
+  options: StartAndEndDate & Partial<BucketOptions>,
+  inLocalTimeZone: boolean
+) => Promise<AggregatedHeartRateResponse[]>;
+```
+Response:
+```typescript
+[{
+  startDate: string,
+  endDate: string,
+  min: number,
+  average: number,
+  max: number,
+  day: Day,
+}]
+```
 
 #### 8. Get all activities
 <br/>Require scopes: `Scopes.FITNESS_ACTIVITY_READ` & `Scopes.FITNESS_LOCATION_READ`

android/build.gradle

@@ -7,7 +7,7 @@ buildscript {
     }
 
     dependencies {
-        classpath 'com.android.tools.build:gradle:3.3.1'
+        classpath 'com.android.tools.build:gradle:8.0.2'
     }
 }
 
@@ -17,8 +17,30 @@ def safeExtGet(prop, fallback) {
     rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
 }
 
+def supportsNamespace() {
+    def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
+    def major = parsed[0].toInteger()
+    def minor = parsed[1].toInteger()
+
+    // Namespace support was added in 7.3.0
+    if (major == 7 && minor >= 3) {
+        return true
+    }
+
+    return major >= 8
+}
+
 android {
-    compileSdkVersion safeExtGet('compileSdkVersion', 27)
+    if (supportsNamespace()) {
+        namespace "com.reactnative.googlefit"
+    } else {
+        sourceSets {
+            main {
+                manifest.srcFile "src/main/AndroidManifest.xml"
+            }
+        }
+    }
+    compileSdkVersion safeExtGet('compileSdkVersion', 28)
     // buildToolsVersion safeExtGet('buildToolsVersion', '27.0.3')
 
     compileOptions {
@@ -28,7 +50,7 @@ android {
 
     defaultConfig {
         minSdkVersion safeExtGet('minSdkVersion', 16)
-        targetSdkVersion safeExtGet('targetSdkVersion', 27)
+        targetSdkVersion safeExtGet('targetSdkVersion', 28)
         versionCode 1
         versionName "1.0"
     }
@@ -48,11 +70,19 @@ repositories {
 }
 
 dependencies {
+    def supportLibVersion = safeExtGet('supportLibVersion', null)
+    def androidXVersion = safeExtGet('androidXVersion', null)
+
     implementation fileTree(include: ['*.jar'], dir: 'libs')
     implementation('com.facebook.react:react-native:+') {
         exclude group: 'com.android.support'
     }
-    implementation "com.android.support:appcompat-v7:${safeExtGet('supportLibVersion', '27.0.0')}"
+    if (supportLibVersion && androidXVersion == null) {
+        implementation "com.android.support:appcompat-v7:$supportLibVersion"
+    } else {
+        def defaultAndroidXVersion = "1.+"
+        implementation "androidx.appcompat:appcompat:${safeExtGet(androidXVersion, defaultAndroidXVersion)}"
+    }
     implementation "com.google.android.gms:play-services-auth:${safeExtGet('authVersion', '+')}"
     implementation "com.google.android.gms:play-services-fitness:${safeExtGet('fitnessVersion', '+')}"
 }

android/gradle.properties

@@ -0,0 +1,15 @@
+## For more details on how to configure your build environment visit
+# http://www.gradle.org/docs/current/userguide/build_environment.html
+#
+# Specifies the JVM arguments used for the daemon process.
+# The setting is particularly useful for tweaking memory settings.
+# Default value: -Xmx1024m -XX:MaxPermSize=256m
+# org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
+#
+# When configured, Gradle will run in incubating parallel mode.
+# This option should only be used with decoupled projects. More details, visit
+# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
+# org.gradle.parallel=true
+#Wed Oct 11 13:41:26 CEST 2023
+android.enableJetifier=true
+android.useAndroidX=true

android/src/main/AndroidManifest.xml

@@ -1,3 +1,8 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
           package="com.reactnative.googlefit">
+
+    <queries>
+      <package android:name="com.google.android.apps.fitness" />
+    </queries>
+
 </manifest>

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

@@ -369,6 +369,23 @@ public void saveWorkout(long startTime, long endTime, ReadableMap options, final
             fitnessOptionsBuilder.addDataType(DataType.TYPE_STEP_COUNT_DELTA, FitnessOptions.ACCESS_WRITE);
         }
 
+        if (options.hasKey(DISTANCE_FIELD_NAME)) {
+            float distance = (float) options.getDouble(DISTANCE_FIELD_NAME);
+            DataSource distanceDataSource = createWorkoutDataSource(DataType.TYPE_DISTANCE_DELTA);
+
+            DataPoint distanceDataPoint = DataPoint.builder(distanceDataSource)
+                    .setTimeInterval(startTime, endTime, TimeUnit.MILLISECONDS)
+                    .setField(Field.FIELD_DISTANCE, distance)
+                    .build();
+
+            DataSet distanceDataSet = DataSet.builder(distanceDataSource)
+                    .add(distanceDataPoint)
+                    .build();
+
+            sessionInsertBuilder.addDataSet(distanceDataSet);
+            fitnessOptionsBuilder.addDataType(DataType.TYPE_DISTANCE_DELTA, FitnessOptions.ACCESS_WRITE);
+        }
+
         // add dataSet into session
         SessionInsertRequest insertRequest = sessionInsertBuilder.build();
 

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

@@ -164,6 +164,16 @@ private void processDataSet(DataSet dataSet, WritableArray map, boolean basalCal
                     }
                 }
                 stepMap.putDouble("calorie", dp.getValue(field).asFloat() - basal);
+
+                /** Checks if data point was added manually by user */
+                DataSource ds = dp.getOriginalDataSource();
+                String streamId = ds.getStreamIdentifier();
+                if (streamId.toLowerCase().indexOf("user_input") != -1) {
+                    stepMap.putBoolean("wasManuallyEntered", true);
+                } else {
+                    stepMap.putBoolean("wasManuallyEntered", false);
+                }
+
                 map.pushMap(stepMap);
             }
         }

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

@@ -187,7 +187,7 @@ public void onConnectionFailed(@NonNull ConnectionResult connectionResult) {
                                     try {
                                         mAuthInProgress = true;
                                         connectionResult.startResolutionForResult(mActivity, REQUEST_OAUTH);
-                                    } catch (IntentSender.SendIntentException e) {
+                                    } catch (IntentSender.SendIntentException | NullPointerException e) {
                                         Log.i(TAG, "Authorization - Failed again: " + e);
                                         mApiClient.connect();
                                     }

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

@@ -466,6 +466,38 @@ 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,
+                                    int bucketInterval,
+                                    String bucketUnit,
+                                    Promise promise) {
+
+        try {
+            HealthHistory healthHistory = mGoogleFitManager.getHealthHistory();
+            healthHistory.setDataType(DataType.TYPE_HEART_RATE_BPM);
+            promise.resolve(healthHistory.getRestingHeartRateHistory((long)startDate, (long)endDate, bucketInterval, bucketUnit));
+        } catch (IllegalViewOperationException e) {
+            promise.reject(e);
+        }
+    }
+
     @ReactMethod
     public void getHydrationSamples(double startDate,
                                     double endDate,

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

@@ -102,6 +102,84 @@ 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()
+                .setType(DataSource.TYPE_DERIVED)
+                .setDataType(DataType.TYPE_HEART_RATE_BPM)
+                .setAppPackageName("com.google.android.gms")
+                .setStreamName("resting_heart_rate<-merge_heart_rate_bpm")
+                .build())
+                .read(this.dataType)
+                .bucketByTime(1, TimeUnit.DAYS)
+                .setTimeRange(startTime, endTime, TimeUnit.MILLISECONDS);
+
+
+        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 boolean saveBloodGlucose(ReadableMap sample) {
         this.Dataset = createDataForRequest(
                 this.dataType,
@@ -246,10 +324,22 @@ 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());
                 }
 
+                /** Checks if data point was added manually by user */
+                DataSource ds = dp.getOriginalDataSource();
+                String streamId = ds.getStreamIdentifier();
+                if (streamId.toLowerCase().indexOf("user_input") != -1) {
+                    stepMap.putBoolean("wasManuallyEntered", true);
+                } else {
+                    stepMap.putBoolean("wasManuallyEntered", false);
+                }
 
                 map.pushMap(stepMap);
             }

docs/CHANGELOG.md

@@ -1,7 +1,9 @@
 ### Changelog:
 
 ```
-0.19.0 ~ Relax dependency version (#313, kudos to @matiaskorhonen)
+0.19.1  + Add Resting Heart Rate (#325, kudos to @AaronDsilva97)
+
+0.19.0  ~ Relax dependency version (#313, kudos to @matiaskorhonen)
 
 0.18.3  + Add device Info to step history data (#279, kudos to @kristerkari)
         ~ Update typescript definitions

docs/INSTALLATION.md

@@ -29,6 +29,10 @@ https://developers.google.com/fit/android/get-api-key
    https://developers.google.com/fit/android/get-api-key
 ```
 
+After that, when you have the client_secrets.json file from OAuth 2.0 Client IDs, you must rename and copy this file to path:
+**app/android/app/src/main/resources/client_secrets.json**
+
+
 ### Mostly Automatic installation
 
 `$ react-native link react-native-google-fit`