Manage unnecessary permission data for android

packages/health/android/src/main/kotlin/cachet/plugins/health/HealthDataReader.kt

@@ -29,6 +29,7 @@ class HealthDataReader(
     private val dataConverter: HealthDataConverter
 ) {
     private val recordingFilter = HealthRecordingFilter()
+    private val permissionChecker = HealthPermissionChecker(context)
 
     /**
      * Retrieves all health data points of a specified type within a given time range.
@@ -105,7 +106,7 @@ class HealthDataReader(
                     "Unable to return $dataType due to the following exception:"
                 )
                 Log.e("FLUTTER_HEALTH::ERROR", Log.getStackTraceString(e))
-                result.success(null)
+                result.error("UNAVAILABLE", "Data not available", null)
             }
         }
     }
@@ -306,49 +307,73 @@ class HealthDataReader(
             val record = rec as ExerciseSessionRecord
 
             // Get distance data
-            val distanceRequest = healthConnectClient.readRecords(
-                ReadRecordsRequest(
-                    recordType = DistanceRecord::class,
-                    timeRangeFilter = TimeRangeFilter.between(
-                        record.startTime,
-                        record.endTime,
-                    ),
-                ),
-            )
             var totalDistance = 0.0
-            for (distanceRec in distanceRequest.records) {
-                totalDistance += distanceRec.distance.inMeters
+            if (permissionChecker.isLocationPermissionGranted() && permissionChecker.isHealthDistancePermissionGranted()) {
+                val distanceRequest = healthConnectClient.readRecords(
+                    ReadRecordsRequest(
+                        recordType = DistanceRecord::class,
+                        timeRangeFilter = TimeRangeFilter.between(
+                            record.startTime,
+                            record.endTime,
+                        ),
+                    ),
+                )
+                for (distanceRec in distanceRequest.records) {
+                    totalDistance += distanceRec.distance.inMeters
+                }
+            } else {
+                Log.i(
+                    "FLUTTER_HEALTH",
+                    "Skipping distance data retrieval for workout due to missing permissions (location or health distance)"
+                )
             }
 
             // Get energy burned data
-            val energyBurnedRequest = healthConnectClient.readRecords(
-                ReadRecordsRequest(
-                    recordType = TotalCaloriesBurnedRecord::class,
-                    timeRangeFilter = TimeRangeFilter.between(
-                        record.startTime,
-                        record.endTime,
-                    ),
-                ),
-            )
             var totalEnergyBurned = 0.0
-            for (energyBurnedRec in energyBurnedRequest.records) {
-                totalEnergyBurned += energyBurnedRec.energy.inKilocalories
+            if (permissionChecker.isHealthTotalCaloriesBurnedPermissionGranted()) {
+                val energyBurnedRequest = healthConnectClient.readRecords(
+                    ReadRecordsRequest(
+                        recordType = TotalCaloriesBurnedRecord::class,
+                        timeRangeFilter = TimeRangeFilter.between(
+                            record.startTime,
+                            record.endTime,
+                        ),
+                    ),
+                )
+                for (energyBurnedRec in energyBurnedRequest.records) {
+                    totalEnergyBurned += energyBurnedRec.energy.inKilocalories
+                }
+            } else {
+                Log.i(
+                    "FLUTTER_HEALTH",
+                    "Skipping total calories burned data retrieval for workout due to missing permissions"
+                )
             }
 
+
             // Get steps data
-            val stepRequest = healthConnectClient.readRecords(
-                ReadRecordsRequest(
-                    recordType = StepsRecord::class,
-                    timeRangeFilter = TimeRangeFilter.between(
-                        record.startTime,
-                        record.endTime
-                    ),
-                ),
-            )
             var totalSteps = 0.0
+            if (permissionChecker.isHealthStepsPermissionGranted()) {
+                val stepRequest = healthConnectClient.readRecords(
+                    ReadRecordsRequest(
+                        recordType = StepsRecord::class,
+                        timeRangeFilter = TimeRangeFilter.between(
+                            record.startTime,
+                            record.endTime
+                        ),
+                    ),
+                )
+
             for (stepRec in stepRequest.records) {
                 totalSteps += stepRec.count
             }
+
+            } else {
+                Log.i(
+                    "FLUTTER_HEALTH",
+                    "Skipping steps data retrieval for workout due to missing permissions"
+                )
+            }
 
             // Add final datapoint
             healthConnectData.add(

packages/health/android/src/main/kotlin/cachet/plugins/health/HealthPermissionChecker.kt

@@ -0,0 +1,47 @@
+package cachet.plugins.health
+
+import android.Manifest
+import android.content.Context
+import android.content.pm.PackageManager
+import androidx.core.content.ContextCompat
+
+class HealthPermissionChecker(private val context: Context) {
+
+    fun isLocationPermissionGranted(): Boolean {
+        val fineLocationGranted = ContextCompat.checkSelfPermission(
+            context,
+            Manifest.permission.ACCESS_FINE_LOCATION
+        ) == PackageManager.PERMISSION_GRANTED
+
+        val coarseLocationGranted = ContextCompat.checkSelfPermission(
+            context,
+            Manifest.permission.ACCESS_COARSE_LOCATION
+        ) == PackageManager.PERMISSION_GRANTED
+
+        return fineLocationGranted || coarseLocationGranted
+    }
+
+    fun isHealthDistancePermissionGranted(): Boolean {
+        val healthDistancePermission = "android.permission.health.READ_DISTANCE"
+        return ContextCompat.checkSelfPermission(
+            context,
+            healthDistancePermission
+        ) == PackageManager.PERMISSION_GRANTED
+    }
+
+    fun isHealthTotalCaloriesBurnedPermissionGranted(): Boolean {
+        val healthCaloriesPermission = "android.permission.health.READ_TOTAL_CALORIES_BURNED"
+        return ContextCompat.checkSelfPermission(
+            context,
+            healthCaloriesPermission
+        ) == PackageManager.PERMISSION_GRANTED
+    }
+
+    fun isHealthStepsPermissionGranted(): Boolean {
+        val healthStepsPermission = "android.permission.health.READ_STEPS"
+        return ContextCompat.checkSelfPermission(
+            context,
+            healthStepsPermission
+        ) == PackageManager.PERMISSION_GRANTED
+    }
+}

packages/health/lib/src/health_value_types.dart

@@ -144,19 +144,24 @@ class WorkoutHealthValue extends HealthValue {
   /// Might not be available for all workouts.
   HealthDataUnit? totalStepsUnit;
 
-  WorkoutHealthValue({
-    required this.workoutActivityType,
-    this.totalEnergyBurned,
-    this.totalEnergyBurnedUnit,
-    this.totalDistance,
-    this.totalDistanceUnit,
-    this.totalSteps,
-    this.totalStepsUnit,
+  /// Raw workoutActivityType from native data format.
+  String? rawWorkoutActivityType;
+
+  WorkoutHealthValue(
+      {required this.workoutActivityType,
+      this.totalEnergyBurned,
+      this.totalEnergyBurnedUnit,
+      this.totalDistance,
+      this.totalDistanceUnit,
+      this.totalSteps,
+      this.totalStepsUnit,
+      this.rawWorkoutActivityType,
   });
 
   /// Create a [WorkoutHealthValue] based on a health data point from native data format.
   factory WorkoutHealthValue.fromHealthDataPoint(dynamic dataPoint) =>
       WorkoutHealthValue(
+        rawWorkoutActivityType: dataPoint['workoutActivityType'] as String?,
         workoutActivityType: HealthWorkoutActivityType.values.firstWhere(
           (element) => element.name == dataPoint['workoutActivityType'],
           orElse: () => HealthWorkoutActivityType.OTHER,
@@ -197,6 +202,7 @@ class WorkoutHealthValue extends HealthValue {
   @override
   String toString() =>
       """$runtimeType - workoutActivityType: ${workoutActivityType.name},
+           rawWorkoutActivityType: $rawWorkoutActivityType,
            totalEnergyBurned: $totalEnergyBurned,
            totalEnergyBurnedUnit: ${totalEnergyBurnedUnit?.name},
            totalDistance: $totalDistance,
@@ -207,6 +213,7 @@ class WorkoutHealthValue extends HealthValue {
   @override
   bool operator ==(Object other) =>
       other is WorkoutHealthValue &&
+      rawWorkoutActivityType == other.rawWorkoutActivityType &&
       workoutActivityType == other.workoutActivityType &&
       totalEnergyBurned == other.totalEnergyBurned &&
       totalEnergyBurnedUnit == other.totalEnergyBurnedUnit &&
@@ -218,6 +225,7 @@ class WorkoutHealthValue extends HealthValue {
   @override
   int get hashCode => Object.hash(
     workoutActivityType,
+    rawWorkoutActivityType,
     totalEnergyBurned,
     totalEnergyBurnedUnit,
     totalDistance,