feat: Enhanced movement detection using audio spikes and HR delta

- Add addHRSample() to track HR changes for movement detection
- detectMovement() now uses median-based baseline for spike detection
- Combine audio movement with HR movement score for better stage classification
- Integrate addHRSample() call when processing vitals from Health Connect
- Add pagination to Health Connect queries for complete data retrieval

Author: jeremymanning

services/healthConnect.ts

@@ -203,31 +203,38 @@ export async function getRecentHeartRate(minutesBack: number = 30): Promise<Hear
     const endTime = new Date().toISOString();
     const startTime = new Date(Date.now() - minutesBack * 60 * 1000).toISOString();
 
-    const result = await healthConnect.readRecords('HeartRate', {
-      timeRangeFilter: {
-        operator: 'between',
-        startTime,
-        endTime,
-      },
-      ascendingOrder: false,
-      pageSize: 100,
-    });
+    const allSamples: HeartRateSample[] = [];
+    let pageToken: string | undefined;
+
+    do {
+      const result = await healthConnect.readRecords('HeartRate', {
+        timeRangeFilter: {
+          operator: 'between',
+          startTime,
+          endTime,
+        },
+        ascendingOrder: false,
+        pageSize: 1000,
+        pageToken,
+      });
 
-    const samples: HeartRateSample[] = [];
-    for (const record of result.records) {
-      if (record.samples) {
-        for (const sample of record.samples) {
-          samples.push({
-            beatsPerMinute: sample.beatsPerMinute,
-            time: sample.time,
-          });
+      for (const record of result.records) {
+        if (record.samples) {
+          for (const sample of record.samples) {
+            allSamples.push({
+              beatsPerMinute: sample.beatsPerMinute,
+              time: sample.time,
+            });
+          }
         }
       }
-    }
 
-    samples.sort((a, b) => new Date(b.time).getTime() - new Date(a.time).getTime());
+      pageToken = result.pageToken;
+    } while (pageToken);
+
+    allSamples.sort((a, b) => new Date(b.time).getTime() - new Date(a.time).getTime());
 
-    return samples;
+    return allSamples;
   } catch (error) {
     console.error('Failed to read heart rate:', error);
     return [];
@@ -243,32 +250,89 @@ export async function getRecentHRV(minutesBack: number = 30): Promise<HRVSample[
     const endTime = new Date().toISOString();
     const startTime = new Date(Date.now() - minutesBack * 60 * 1000).toISOString();
 
-    const result = await healthConnect.readRecords('HeartRateVariabilityRmssd', {
-      timeRangeFilter: {
-        operator: 'between',
-        startTime,
-        endTime,
-      },
-      ascendingOrder: false,
-      pageSize: 100,
-    });
+    const allSamples: HRVSample[] = [];
+    let pageToken: string | undefined;
+
+    do {
+      const result = await healthConnect.readRecords('HeartRateVariabilityRmssd', {
+        timeRangeFilter: {
+          operator: 'between',
+          startTime,
+          endTime,
+        },
+        ascendingOrder: false,
+        pageSize: 1000,
+        pageToken,
+      });
 
-    const samples: HRVSample[] = result.records.map(
-      (record: { heartRateVariabilityMillis: number; time: string }) => ({
-        heartRateVariabilityMillis: record.heartRateVariabilityMillis,
-        time: record.time,
-      })
-    );
+      for (const record of result.records) {
+        allSamples.push({
+          heartRateVariabilityMillis: record.heartRateVariabilityMillis,
+          time: record.time,
+        });
+      }
 
-    samples.sort((a, b) => new Date(b.time).getTime() - new Date(a.time).getTime());
+      pageToken = result.pageToken;
+    } while (pageToken);
 
-    return samples;
+    allSamples.sort((a, b) => new Date(b.time).getTime() - new Date(a.time).getTime());
+
+    return allSamples;
   } catch (error) {
     console.error('Failed to read HRV:', error);
     return [];
   }
 }
 
+type HealthRecordType =
+  | 'HeartRate'
+  | 'HeartRateVariabilityRmssd'
+  | 'SleepSession'
+  | 'RestingHeartRate'
+  | 'OxygenSaturation'
+  | 'RespiratoryRate'
+  | 'Steps'
+  | 'ActiveCaloriesBurned';
+
+export async function getAvailableRecordCounts(): Promise<Record<string, number>> {
+  if (Platform.OS !== 'android' || !healthConnect) {
+    return {};
+  }
+
+  const recordTypes: HealthRecordType[] = [
+    'HeartRate',
+    'HeartRateVariabilityRmssd',
+    'SleepSession',
+    'RestingHeartRate',
+    'OxygenSaturation',
+    'RespiratoryRate',
+    'Steps',
+    'ActiveCaloriesBurned',
+  ];
+
+  const counts: Record<string, number> = {};
+  const endTime = new Date().toISOString();
+  const startTime = new Date(Date.now() - 48 * 60 * 60 * 1000).toISOString();
+
+  for (const recordType of recordTypes) {
+    try {
+      const result = await healthConnect.readRecords(recordType, {
+        timeRangeFilter: {
+          operator: 'between',
+          startTime,
+          endTime,
+        },
+        pageSize: 1,
+      });
+      counts[recordType] = result.records?.length > 0 ? 1 : 0;
+    } catch {
+      counts[recordType] = -1;
+    }
+  }
+
+  return counts;
+}
+
 export async function getRecentSleepSessions(hoursBack: number = 12): Promise<SleepStageSample[]> {
   if (Platform.OS !== 'android' || !healthConnect) {
     return [];

services/sleep.ts

@@ -80,8 +80,13 @@ const SLEEP_BREATHING_REGULARITY = 0.85;
 const REM_RRV_THRESHOLD = 0.25;
 const DEEP_SLEEP_RRV_THRESHOLD = 0.1;
 const MOVEMENT_THRESHOLD = 0.15;
+const MOVEMENT_SPIKE_THRESHOLD = 3.0;
+const HR_MOVEMENT_DELTA_THRESHOLD = 8;
+const HR_MOVEMENT_WINDOW_SEC = 30;
 
 let currentSession: SleepSession | null = null;
+let recentHRSamples: { hr: number; timestamp: number }[] = [];
+let hrMovementScore = 0;
 let audioContext: AudioContext | null = null;
 let analyzer: MeydaAnalyzerInstance | null = null;
 let mediaStream: MediaStream | null = null;
@@ -619,16 +624,84 @@ function calculateRRV(intervals: number[]): number {
 function detectMovement(rmsValues: number[]): number {
   if (rmsValues.length < 5) return 0;
 
-  let spikeCount = 0;
-  const avgRms = rmsValues.reduce((a, b) => a + b, 0) / rmsValues.length;
+  const sorted = [...rmsValues].sort((a, b) => a - b);
+  const median = sorted[Math.floor(sorted.length / 2)];
+  const p25 = sorted[Math.floor(sorted.length * 0.25)];
+  const baselineRms = (median + p25) / 2;
 
-  for (const rms of rmsValues) {
-    if (rms > avgRms * 3) {
-      spikeCount++;
+  let spikeScore = 0;
+  let sustainedHighScore = 0;
+
+  for (let i = 0; i < rmsValues.length; i++) {
+    const rms = rmsValues[i];
+    const spikeRatio = baselineRms > 0.001 ? rms / baselineRms : 0;
+
+    if (spikeRatio > MOVEMENT_SPIKE_THRESHOLD) {
+      spikeScore += 0.2;
+    }
+
+    if (rms > adaptiveRmsThreshold * 2) {
+      sustainedHighScore += 0.05;
     }
   }
 
-  return spikeCount / rmsValues.length;
+  const audioMovement = Math.min(1, spikeScore + sustainedHighScore);
+  const combinedMovement = Math.max(audioMovement, hrMovementScore * 0.8);
+
+  return combinedMovement;
+}
+
+export function addHRSample(hr: number): void {
+  const now = Date.now();
+  recentHRSamples.push({ hr, timestamp: now });
+  recentHRSamples = recentHRSamples.filter(
+    (s) => now - s.timestamp < HR_MOVEMENT_WINDOW_SEC * 1000
+  );
+
+  updateHRMovementScore();
+}
+
+function updateHRMovementScore(): void {
+  if (recentHRSamples.length < 3) {
+    hrMovementScore = 0;
+    return;
+  }
+
+  const sorted = [...recentHRSamples].sort((a, b) => a.timestamp - b.timestamp);
+  let maxDelta = 0;
+
+  for (let i = 1; i < sorted.length; i++) {
+    const timeDiff = sorted[i].timestamp - sorted[i - 1].timestamp;
+    if (timeDiff > 0 && timeDiff < 60000) {
+      const hrDelta = Math.abs(sorted[i].hr - sorted[i - 1].hr);
+      maxDelta = Math.max(maxDelta, hrDelta);
+    }
+  }
+
+  const minHR = Math.min(...sorted.map((s) => s.hr));
+  const maxHR = Math.max(...sorted.map((s) => s.hr));
+  const hrRange = maxHR - minHR;
+
+  if (maxDelta >= HR_MOVEMENT_DELTA_THRESHOLD || hrRange >= HR_MOVEMENT_DELTA_THRESHOLD * 1.5) {
+    hrMovementScore = Math.min(1, maxDelta / HR_MOVEMENT_DELTA_THRESHOLD);
+  } else {
+    hrMovementScore = hrMovementScore * 0.9;
+  }
+}
+
+export function getMovementIndicators(): {
+  audioMovement: number;
+  hrMovement: number;
+  combined: number;
+} {
+  const recentRms = rmsHistory.slice(-20).map((r) => r.value);
+  const audioMovement = recentRms.length > 0 ? detectMovement(recentRms) : 0;
+
+  return {
+    audioMovement,
+    hrMovement: hrMovementScore,
+    combined: Math.max(audioMovement, hrMovementScore * 0.8),
+  };
 }
 
 function analyzeBreathing(): BreathingAnalysis {
@@ -864,6 +937,10 @@ export async function processVitalsUpdate(vitals: VitalsSnapshot): Promise<void>
 
   addVitalsSample(vitals);
 
+  if (vitals.heartRate !== null) {
+    addHRSample(vitals.heartRate);
+  }
+
   if (currentSession?.isActive) {
     const vitalsAnalysis = await analyzeVitalsWithLearning();
 

services/sleepStageLearning.ts

@@ -323,6 +323,7 @@ function countNights(timestamps: Date[]): number {
 export interface DebugReport {
   timestamp: string;
   platform: string;
+  availableRecords: Record<string, number>;
   sleepStages: {
     total: number;
     byStage: Record<string, number>;
@@ -354,6 +355,7 @@ export async function runDebugReport(hoursBack: number = 48): Promise<DebugRepor
   const report: DebugReport = {
     timestamp: new Date().toISOString(),
     platform,
+    availableRecords: {},
     sleepStages: { total: 0, byStage: {}, samples: [] },
     heartRate: { total: 0, oldest: null, newest: null, samples: [] },
     hrv: { total: 0, oldest: null, newest: null, samples: [] },