@robinhealth/health-sdk 0.0.1

package/src/providers/healthconnect.ts

@@ -0,0 +1,725 @@
+import {
+  initialize,
+  getSdkStatus,
+  requestPermission,
+  getGrantedPermissions,
+  readRecords,
+  aggregateRecord,
+  SdkAvailabilityStatus,
+  type RecordType,
+  type HeartRateRecord,
+  type BloodPressureRecord,
+  type SleepSessionRecord,
+  type StepsRecord,
+  type FloorsClimbedRecord,
+  type RestingHeartRateRecord,
+  type OxygenSaturationRecord,
+  type RespiratoryRateRecord,
+  type ExerciseSessionRecord,
+} from 'react-native-health-connect';
+import {
+  HealthDataType,
+  WorkoutActivityType,
+  PermissionStatus,
+  SleepStage,
+  type HealthProvider,
+  type HealthSample,
+  type HealthAggregate,
+  type Workout,
+  type SleepStageSample,
+  type SleepSession,
+} from '../types';
+import { getPermissionsRequested, setPermissionsRequested } from '../storage';
+
+interface HCTypeMapping {
+  recordType: RecordType;
+  unit: string;
+  supportsAggregation: boolean;
+  field?: string;
+  isSession?: boolean;
+}
+
+const TYPE_MAP: Partial<Record<HealthDataType, HCTypeMapping>> = {
+  [HealthDataType.Steps]: {
+    recordType: 'Steps',
+    unit: 'count',
+    supportsAggregation: true,
+  },
+  [HealthDataType.DistanceWalkingRunning]: {
+    recordType: 'Distance',
+    unit: 'm',
+    supportsAggregation: true,
+  },
+  [HealthDataType.ActiveEnergyBurned]: {
+    recordType: 'ActiveCaloriesBurned',
+    unit: 'kcal',
+    supportsAggregation: true,
+  },
+  [HealthDataType.FlightsClimbed]: {
+    recordType: 'FloorsClimbed',
+    unit: 'count',
+    supportsAggregation: true,
+  },
+  [HealthDataType.HeartRate]: {
+    recordType: 'HeartRate',
+    unit: 'bpm',
+    supportsAggregation: true,
+  },
+  [HealthDataType.RestingHeartRate]: {
+    recordType: 'RestingHeartRate',
+    unit: 'bpm',
+    supportsAggregation: false,
+  },
+  [HealthDataType.BloodPressureSystolic]: {
+    recordType: 'BloodPressure',
+    unit: 'mmHg',
+    supportsAggregation: false,
+    field: 'systolic',
+  },
+  [HealthDataType.BloodPressureDiastolic]: {
+    recordType: 'BloodPressure',
+    unit: 'mmHg',
+    supportsAggregation: false,
+    field: 'diastolic',
+  },
+  [HealthDataType.BloodOxygen]: {
+    recordType: 'OxygenSaturation',
+    unit: '%',
+    supportsAggregation: false,
+  },
+  [HealthDataType.RespiratoryRate]: {
+    recordType: 'RespiratoryRate',
+    unit: 'breaths/min',
+    supportsAggregation: false,
+  },
+  [HealthDataType.SleepAnalysis]: {
+    recordType: 'SleepSession',
+    unit: 'hr',
+    supportsAggregation: false,
+    isSession: true,
+  },
+  [HealthDataType.BodyFatPercentage]: {
+    recordType: 'BodyFat' as RecordType,
+    unit: '%',
+    supportsAggregation: false,
+  },
+  [HealthDataType.BasalEnergyBurned]: {
+    recordType: 'BasalMetabolicRate' as RecordType,
+    unit: 'kcal/day',
+    supportsAggregation: false,
+  },
+  [HealthDataType.Water]: {
+    recordType: 'Hydration' as RecordType,
+    unit: 'mL',
+    supportsAggregation: false,
+  },
+};
+
+const HC_SLEEP_STAGE_MAP: Record<number, SleepStage> = {
+  0: SleepStage.Unknown,  // STAGE_TYPE_UNKNOWN
+  1: SleepStage.Awake,    // STAGE_TYPE_AWAKE
+  2: SleepStage.Unknown,  // STAGE_TYPE_SLEEPING (generic)
+  3: SleepStage.Unknown,  // STAGE_TYPE_OUT_OF_BED
+  4: SleepStage.Light,    // STAGE_TYPE_LIGHT
+  5: SleepStage.Deep,     // STAGE_TYPE_DEEP
+  6: SleepStage.REM,      // STAGE_TYPE_REM
+};
+
+// Health Connect ExerciseType numeric constants → SDK WorkoutActivityType
+const EXERCISE_TYPE_MAP: Record<number, WorkoutActivityType> = {
+  2: WorkoutActivityType.badminton,
+  4: WorkoutActivityType.baseball,
+  5: WorkoutActivityType.basketball,
+  8: WorkoutActivityType.cycling,
+  11: WorkoutActivityType.boxing,
+  14: WorkoutActivityType.cricket,
+  16: WorkoutActivityType.dance,
+  25: WorkoutActivityType.elliptical,
+  27: WorkoutActivityType.fencing,
+  28: WorkoutActivityType.americanFootball,
+  29: WorkoutActivityType.australianFootball,
+  32: WorkoutActivityType.golf,
+  34: WorkoutActivityType.gymnastics,
+  35: WorkoutActivityType.handball,
+  36: WorkoutActivityType.highIntensityIntervalTraining,
+  37: WorkoutActivityType.hiking,
+  38: WorkoutActivityType.hockey,
+  41: WorkoutActivityType.jumpRope,
+  44: WorkoutActivityType.martialArts,
+  48: WorkoutActivityType.pilates,
+  50: WorkoutActivityType.racquetball,
+  51: WorkoutActivityType.climbing,
+  53: WorkoutActivityType.rowing,
+  54: WorkoutActivityType.rowing,
+  55: WorkoutActivityType.rugby,
+  56: WorkoutActivityType.running,
+  58: WorkoutActivityType.sailing,
+  59: WorkoutActivityType.underwaterDiving,
+  60: WorkoutActivityType.skatingSports,
+  61: WorkoutActivityType.snowSports,
+  62: WorkoutActivityType.snowboarding,
+  64: WorkoutActivityType.soccer,
+  65: WorkoutActivityType.softball,
+  66: WorkoutActivityType.squash,
+  68: WorkoutActivityType.stairClimbing,
+  70: WorkoutActivityType.traditionalStrengthTraining,
+  71: WorkoutActivityType.flexibility,
+  72: WorkoutActivityType.surfingSports,
+  73: WorkoutActivityType.swimming,
+  74: WorkoutActivityType.swimming,
+  75: WorkoutActivityType.tableTennis,
+  76: WorkoutActivityType.tennis,
+  78: WorkoutActivityType.volleyball,
+  79: WorkoutActivityType.walking,
+  80: WorkoutActivityType.waterPolo,
+  81: WorkoutActivityType.traditionalStrengthTraining,
+  82: WorkoutActivityType.wheelchairWalkPace,
+  83: WorkoutActivityType.yoga,
+};
+
+export class HealthConnectProvider implements HealthProvider {
+  private initPromise: Promise<boolean> | null = null;
+
+  private async ensureInitialized(): Promise<void> {
+    if (!this.initPromise) {
+      this.initPromise = initialize().catch((e) => {
+        this.initPromise = null;
+        throw e;
+      });
+    }
+    await this.initPromise;
+  }
+
+  async isAvailable(): Promise<boolean> {
+    try {
+      await this.ensureInitialized();
+      const status = await getSdkStatus();
+      return status === SdkAvailabilityStatus.SDK_AVAILABLE;
+    } catch {
+      return false;
+    }
+  }
+
+  async shouldRequestAuthorization(dataTypes: HealthDataType[]): Promise<boolean> {
+    try {
+      await this.ensureInitialized();
+      const granted = await getGrantedPermissions();
+      const grantedSet = new Set(
+        granted
+          .filter((p: { accessType: string }) => p.accessType === 'read')
+          .map((p: { recordType: string }) => p.recordType),
+      );
+
+      const requiredRecordTypes = new Set<RecordType>();
+      for (const dt of dataTypes) {
+        const mapping = TYPE_MAP[dt];
+        if (mapping) {
+          requiredRecordTypes.add(mapping.recordType);
+        }
+      }
+      if (dataTypes.includes(HealthDataType.BodyMassIndex)) {
+        requiredRecordTypes.add('Height' as RecordType);
+        requiredRecordTypes.add('Weight' as RecordType);
+      }
+      requiredRecordTypes.add('ExerciseSession');
+      requiredRecordTypes.add('TotalCaloriesBurned' as RecordType);
+
+      for (const rt of requiredRecordTypes) {
+        if (!grantedSet.has(rt)) {
+          return true;
+        }
+      }
+      return false;
+    } catch {
+      return true;
+    }
+  }
+
+  async requestAuthorization(dataTypes: HealthDataType[]): Promise<boolean> {
+    try {
+      await this.ensureInitialized();
+
+      const recordTypes = new Set<RecordType>();
+      for (const dt of dataTypes) {
+        const mapping = TYPE_MAP[dt];
+        if (mapping) {
+          recordTypes.add(mapping.recordType);
+        }
+      }
+      recordTypes.add('ExerciseSession');
+      recordTypes.add('TotalCaloriesBurned' as RecordType);
+
+      const permissions = Array.from(recordTypes).map((rt) => ({
+        accessType: 'read' as const,
+        recordType: rt,
+      }));
+
+      // When BodyMassIndex is requested, also request Height and Weight permissions
+      if (dataTypes.includes(HealthDataType.BodyMassIndex)) {
+        permissions.push(
+          { accessType: 'read', recordType: 'Height' },
+          { accessType: 'read', recordType: 'Weight' },
+        );
+      }
+
+      const granted = await requestPermission(permissions);
+      return granted.length > 0;
+    } catch {
+      return false;
+    } finally {
+      await setPermissionsRequested();
+    }
+  }
+
+  async getPermissionStatus(): Promise<PermissionStatus> {
+    try {
+      const wasRequested = await getPermissionsRequested();
+      if (!wasRequested) return PermissionStatus.UNKNOWN;
+
+      await this.ensureInitialized();
+      const granted = await getGrantedPermissions();
+      return granted.length > 0 ? PermissionStatus.GRANTED : PermissionStatus.DECLINED;
+    } catch {
+      return PermissionStatus.UNKNOWN;
+    }
+  }
+
+  async querySamples(
+    type: HealthDataType,
+    startDate: Date,
+    endDate: Date,
+  ): Promise<HealthSample[]> {
+    await this.ensureInitialized();
+
+    // BMI has no native Health Connect record type — derive from Height + Weight
+    if (type === HealthDataType.BodyMassIndex) {
+      return this.deriveBMISamples(startDate, endDate);
+    }
+
+    const mapping = TYPE_MAP[type];
+    if (!mapping) return [];
+
+    const timeRangeFilter = {
+      operator: 'between' as const,
+      startTime: startDate.toISOString(),
+      endTime: endDate.toISOString(),
+    };
+
+    const { records } = await readRecords(mapping.recordType, { timeRangeFilter });
+
+    // HeartRate: flatten nested samples
+    if (mapping.recordType === 'HeartRate') {
+      const samples: HealthSample[] = [];
+      for (const record of records as HeartRateRecord[]) {
+        for (const s of record.samples) {
+          samples.push({
+            type,
+            value: s.beatsPerMinute,
+            unit: mapping.unit,
+            startDate: new Date(s.time),
+            endDate: new Date(s.time),
+            sourceName: record.metadata?.dataOrigin ?? undefined,
+          });
+        }
+      }
+      return samples;
+    }
+
+    // BloodPressure: extract systolic or diastolic field
+    if (mapping.recordType === 'BloodPressure') {
+      const field = mapping.field as 'systolic' | 'diastolic';
+      return (records as BloodPressureRecord[]).map((record) => ({
+        type,
+        value: record[field].value,
+        unit: mapping.unit,
+        startDate: new Date(record.time),
+        endDate: new Date(record.time),
+        sourceName: record.metadata?.dataOrigin ?? undefined,
+      }));
+    }
+
+    // SleepSession: calculate duration in hours, with per-stage samples when available
+    if (mapping.recordType === 'SleepSession') {
+      const sleepSamples: SleepStageSample[] = [];
+
+      for (const record of records as SleepSessionRecord[]) {
+        const stages = (record as any).stages;
+
+        if (stages && stages.length > 0) {
+          for (const stage of stages) {
+            const start = new Date(stage.startTime);
+            const end = new Date(stage.endTime);
+            const durationHours =
+              (end.getTime() - start.getTime()) / (1000 * 60 * 60);
+
+            sleepSamples.push({
+              type,
+              value: durationHours,
+              unit: mapping.unit,
+              startDate: start,
+              endDate: end,
+              sourceName: record.metadata?.dataOrigin ?? undefined,
+              stage: HC_SLEEP_STAGE_MAP[stage.type] ?? SleepStage.Unknown,
+            });
+          }
+        } else {
+          const start = new Date(record.startTime);
+          const end = new Date(record.endTime);
+          const durationHours =
+            (end.getTime() - start.getTime()) / (1000 * 60 * 60);
+
+          sleepSamples.push({
+            type,
+            value: durationHours,
+            unit: mapping.unit,
+            startDate: start,
+            endDate: end,
+            sourceName: record.metadata?.dataOrigin ?? undefined,
+            stage: SleepStage.Unknown,
+          });
+        }
+      }
+
+      return sleepSamples;
+    }
+
+    // BasalMetabolicRate: rate stored as kcal/day
+    if (mapping.recordType === 'BasalMetabolicRate') {
+      return records.map((record: any) => ({
+        type,
+        value: record.basalMetabolicRate?.inKilocaloriesPerDay ?? 0,
+        unit: mapping.unit,
+        startDate: new Date(record.time),
+        endDate: new Date(record.time),
+        sourceName: record.metadata?.dataOrigin ?? undefined,
+      }));
+    }
+
+    // BodyFat: percentage value
+    if (mapping.recordType === 'BodyFat') {
+      return records.map((record: any) => ({
+        type,
+        value: record.percentage ?? 0,
+        unit: mapping.unit,
+        startDate: new Date(record.time),
+        endDate: new Date(record.time),
+        sourceName: record.metadata?.dataOrigin ?? undefined,
+      }));
+    }
+
+    // Hydration: volume stored as volume.inMilliliters
+    if (mapping.recordType === 'Hydration') {
+      return records.map((record: any) => ({
+        type,
+        value: record.volume?.inMilliliters ?? 0,
+        unit: mapping.unit,
+        startDate: new Date(record.startTime),
+        endDate: new Date(record.endTime),
+        sourceName: record.metadata?.dataOrigin ?? undefined,
+      }));
+    }
+
+    // Default: single-value records with known shapes
+    return records.map((record) => {
+      let value = 0;
+      switch (mapping.recordType) {
+        case 'Steps':
+          value = (record as StepsRecord).count;
+          break;
+        case 'Distance':
+          value = (record as any).distance.inMeters;
+          break;
+        case 'ActiveCaloriesBurned':
+          value = (record as any).energy.inKilocalories;
+          break;
+        case 'FloorsClimbed':
+          value = (record as FloorsClimbedRecord).floors;
+          break;
+        case 'RestingHeartRate':
+          value = (record as RestingHeartRateRecord).beatsPerMinute;
+          break;
+        case 'OxygenSaturation':
+          value = (record as OxygenSaturationRecord).percentage;
+          break;
+        case 'RespiratoryRate':
+          value = (record as RespiratoryRateRecord).rate;
+          break;
+      }
+      const isInterval = 'startTime' in record;
+      const startTime = isInterval ? (record as StepsRecord).startTime : (record as RestingHeartRateRecord).time;
+      const endTime = isInterval ? (record as StepsRecord).endTime : (record as RestingHeartRateRecord).time;
+      return {
+        type,
+        value,
+        unit: mapping.unit,
+        startDate: new Date(startTime),
+        endDate: new Date(endTime),
+        sourceName: record.metadata?.dataOrigin ?? undefined,
+      };
+    });
+  }
+
+  async queryAggregated(
+    type: HealthDataType,
+    startDate: Date,
+    endDate: Date,
+  ): Promise<HealthAggregate> {
+    await this.ensureInitialized();
+    const mapping = TYPE_MAP[type];
+    if (!mapping) {
+      return { type, unit: '', startDate, endDate };
+    }
+
+    // Manual aggregation path for types that don't support aggregateRecord
+    if (!mapping.supportsAggregation) {
+      return this.manualAggregate(type, startDate, endDate);
+    }
+
+    const timeRangeFilter = {
+      operator: 'between' as const,
+      startTime: startDate.toISOString(),
+      endTime: endDate.toISOString(),
+    };
+
+    let sum: number | undefined;
+    let avg: number | undefined;
+    let min: number | undefined;
+    let max: number | undefined;
+
+    switch (mapping.recordType) {
+      case 'Steps': {
+        const result = await aggregateRecord({ recordType: 'Steps', timeRangeFilter });
+        sum = result.COUNT_TOTAL;
+        break;
+      }
+      case 'FloorsClimbed': {
+        const result = await aggregateRecord({ recordType: 'FloorsClimbed', timeRangeFilter });
+        sum = result.FLOORS_CLIMBED_TOTAL;
+        break;
+      }
+      case 'Distance': {
+        const result = await aggregateRecord({ recordType: 'Distance', timeRangeFilter });
+        sum = result.DISTANCE.inMeters;
+        break;
+      }
+      case 'ActiveCaloriesBurned': {
+        const result = await aggregateRecord({ recordType: 'ActiveCaloriesBurned', timeRangeFilter });
+        sum = result.ACTIVE_CALORIES_TOTAL.inKilocalories;
+        break;
+      }
+      case 'HeartRate': {
+        const result = await aggregateRecord({ recordType: 'HeartRate', timeRangeFilter });
+        avg = result.BPM_AVG;
+        min = result.BPM_MIN;
+        max = result.BPM_MAX;
+        break;
+      }
+    }
+
+    return { type, sum, avg, min, max, unit: mapping.unit, startDate, endDate };
+  }
+
+  async querySleepSessions(
+    startDate: Date,
+    endDate: Date,
+  ): Promise<SleepSession[]> {
+    await this.ensureInitialized();
+
+    const timeRangeFilter = {
+      operator: 'between' as const,
+      startTime: startDate.toISOString(),
+      endTime: endDate.toISOString(),
+    };
+
+    const { records } = await readRecords('SleepSession', { timeRangeFilter });
+
+    return (records as SleepSessionRecord[]).map((record) => {
+      const stages = {
+        awake: 0,
+        light: 0,
+        deep: 0,
+        rem: 0,
+        unknown: 0,
+      };
+
+      const recordStages = (record as any).stages;
+      if (recordStages) {
+        for (const stage of recordStages) {
+          const start = new Date(stage.startTime);
+          const end = new Date(stage.endTime);
+          const hours = (end.getTime() - start.getTime()) / (1000 * 60 * 60);
+          const mapped = HC_SLEEP_STAGE_MAP[stage.type] ?? SleepStage.Unknown;
+
+          switch (mapped) {
+            case SleepStage.Awake:
+              stages.awake += hours;
+              break;
+            case SleepStage.Light:
+              stages.light += hours;
+              break;
+            case SleepStage.Deep:
+              stages.deep += hours;
+              break;
+            case SleepStage.REM:
+              stages.rem += hours;
+              break;
+            default:
+              stages.unknown += hours;
+              break;
+          }
+        }
+      } else {
+        const start = new Date(record.startTime);
+        const end = new Date(record.endTime);
+        stages.unknown =
+          (end.getTime() - start.getTime()) / (1000 * 60 * 60);
+      }
+
+      const totalDuration =
+        stages.light + stages.deep + stages.rem + stages.unknown;
+
+      return {
+        startDate: new Date(record.startTime),
+        endDate: new Date(record.endTime),
+        totalDuration,
+        stages,
+        sourceName: record.metadata?.dataOrigin ?? 'Unknown',
+      };
+    });
+  }
+
+  async queryWorkouts(startDate: Date, endDate: Date): Promise<Workout[]> {
+    await this.ensureInitialized();
+
+    const timeRangeFilter = {
+      operator: 'between' as const,
+      startTime: startDate.toISOString(),
+      endTime: endDate.toISOString(),
+    };
+
+    const { records } = await readRecords('ExerciseSession', { timeRangeFilter });
+
+    const workouts = await Promise.all(
+      (records as ExerciseSessionRecord[]).map(async (session) => {
+        const workoutType =
+          EXERCISE_TYPE_MAP[session.exerciseType] ?? WorkoutActivityType.other;
+        const sessionStart = new Date(session.startTime);
+        const sessionEnd = new Date(session.endTime);
+        const duration = (sessionEnd.getTime() - sessionStart.getTime()) / 1000;
+
+        const sessionTimeRange = {
+          operator: 'between' as const,
+          startTime: session.startTime,
+          endTime: session.endTime,
+        };
+
+        // Scope enrichment to the same app that created the session
+        const dataOriginFilter = session.metadata?.dataOrigin
+          ? [session.metadata.dataOrigin]
+          : undefined;
+
+        // Parallel enrichment queries using aggregation
+        const [caloriesAgg, distanceAgg, hrAgg] = await Promise.all([
+          aggregateRecord({ recordType: 'TotalCaloriesBurned', timeRangeFilter: sessionTimeRange, dataOriginFilter }).catch(() => null),
+          aggregateRecord({ recordType: 'Distance', timeRangeFilter: sessionTimeRange, dataOriginFilter }).catch(() => null),
+          aggregateRecord({ recordType: 'HeartRate', timeRangeFilter: sessionTimeRange, dataOriginFilter }).catch(() => null),
+        ]);
+
+        // Extract aggregated calories
+        const energyBurned = caloriesAgg?.ENERGY_TOTAL?.inKilocalories ?? null;
+
+        // Extract aggregated distance
+        const distance = distanceAgg?.DISTANCE?.inMeters ?? null;
+
+        // Extract HR avg/max from aggregation
+        const heartRateAvg = hrAgg?.BPM_AVG ?? null;
+        const heartRateMax = hrAgg?.BPM_MAX ?? null;
+
+        return {
+          workoutType,
+          duration,
+          energyBurned,
+          distance,
+          heartRateAvg,
+          heartRateMax,
+          startDate: sessionStart,
+          endDate: sessionEnd,
+          sourceName: session.metadata?.dataOrigin ?? 'Unknown',
+        };
+      }),
+    );
+
+    // Sort by start time descending (most recent first)
+    workouts.sort((a, b) => b.startDate.getTime() - a.startDate.getTime());
+    return workouts;
+  }
+
+  private async deriveBMISamples(
+    startDate: Date,
+    endDate: Date,
+  ): Promise<HealthSample[]> {
+    const timeRangeFilter = {
+      operator: 'between' as const,
+      startTime: startDate.toISOString(),
+      endTime: endDate.toISOString(),
+    };
+
+    const { records: heightRecords } = await readRecords('Height', {
+      timeRangeFilter,
+    });
+
+    if (heightRecords.length === 0) return [];
+
+    const latestHeight = (heightRecords as any[]).sort(
+      (a, b) => new Date(b.time).getTime() - new Date(a.time).getTime(),
+    )[0];
+    const heightMeters = latestHeight.height?.inMeters ?? 0;
+
+    if (heightMeters === 0) return [];
+
+    const { records: weightRecords } = await readRecords('Weight', {
+      timeRangeFilter,
+    });
+
+    return (weightRecords as any[]).map((record) => {
+      const weightKg = record.weight?.inKilograms ?? 0;
+      const bmi = weightKg / (heightMeters * heightMeters);
+
+      return {
+        type: HealthDataType.BodyMassIndex,
+        value: Math.round(bmi * 10) / 10,
+        unit: 'kg/m²',
+        startDate: new Date(record.time),
+        endDate: new Date(record.time),
+        sourceName: record.metadata?.dataOrigin ?? undefined,
+      };
+    });
+  }
+
+  private async manualAggregate(
+    type: HealthDataType,
+    startDate: Date,
+    endDate: Date,
+  ): Promise<HealthAggregate> {
+    const mapping = TYPE_MAP[type];
+    const samples = await this.querySamples(type, startDate, endDate);
+    const values = samples.map((s) => s.value);
+    const unit = mapping?.unit ?? '';
+
+    if (values.length === 0) {
+      return { type, unit, startDate, endDate };
+    }
+
+    const sum = values.reduce((a, b) => a + b, 0);
+    return {
+      type,
+      sum,
+      avg: sum / values.length,
+      min: values.reduce((a, b) => a < b ? a : b),
+      max: values.reduce((a, b) => a > b ? a : b),
+      unit,
+      startDate,
+      endDate,
+    };
+  }
+}