Synheart Wear - Flutter SDK - Synheart Documentation

Overview

The Synheart Wear Flutter SDK provides a unified API for streaming biometric data from Apple Health, Health Connect, WHOOP, Garmin, Fitbit, Oura and BLE heart-rate straps in Flutter applications. Key Features:

Cross-platform support (iOS + Android)
Real-time HR and HRV streaming
Unified data schema across all devices
Optional encrypted local cache (AES-256-GCM, key in the Keychain / Android secure storage)
Consent-based permissions

Installation

Add to your pubspec.yaml:

dependencies:
  synheart_wear: ^0.7.0

Install dependencies:

flutter pub get

Requirements: Flutter 3.32+ (Dart 3.8+), iOS 16.0+, Android minSdk 28.

Platform Configuration

iOS Configuration

Add to ios/Runner/Info.plist:

<key>NSHealthShareUsageDescription</key>
<string>This app needs access to your health data to provide insights.</string>

Since 0.6.1 the SDK only reads health data, so NSHealthUpdateUsageDescription is not needed.

Android Configuration

Add to android/app/src/main/AndroidManifest.xml. The Flutter plugin’s own manifest declares no health permissions, so your app must declare every type it reads; a type that isn’t declared can’t be granted, and its reads come back empty. (The Kotlin SDK is different: its manifest declares them for you.)

<!-- Health Connect Permissions: read only, the SDK never writes (0.6.1+) -->
<uses-permission android:name="android.permission.health.READ_HEART_RATE"/>
<!-- Resting HR: without it, fetchOvernightPhysiology reports no resting HR -->
<uses-permission android:name="android.permission.health.READ_RESTING_HEART_RATE"/>
<!-- Exercise sessions (fetchActiveMinutes) -->
<uses-permission android:name="android.permission.health.READ_EXERCISE"/>
<uses-permission android:name="android.permission.health.READ_TOTAL_CALORIES_BURNED"/>
<uses-permission android:name="android.permission.health.READ_HEART_RATE_VARIABILITY"/>
<uses-permission android:name="android.permission.health.READ_STEPS"/>
<uses-permission android:name="android.permission.health.READ_ACTIVE_CALORIES_BURNED"/>
<uses-permission android:name="android.permission.health.READ_DISTANCE"/>
<!-- Sleep sessions and stages (fetchSleepNights) -->
<uses-permission android:name="android.permission.health.READ_SLEEP"/>
<!-- History older than 30 days; needs its own prompt, see Health backfill -->
<uses-permission android:name="android.permission.health.READ_HEALTH_DATA_HISTORY"/>

<!-- Health Connect Package Query -->
<queries>
    <package android:name="com.google.android.apps.healthdata" />
    <intent>
        <action android:name="androidx.health.ACTION_SHOW_PERMISSIONS_RATIONALE" />
    </intent>
</queries>

<application>
    <activity android:name=".MainActivity">
        <intent-filter>
            <action android:name="androidx.health.ACTION_SHOW_PERMISSIONS_RATIONALE" />
        </intent-filter>
    </activity>

    <!-- Required: Privacy Policy Activity Alias -->
    <activity-alias
        android:name="ViewPermissionUsageActivity"
        android:exported="true"
        android:targetActivity=".MainActivity"
        android:permission="android.permission.START_VIEW_PERMISSION_USAGE">
        <intent-filter>
            <action android:name="android.intent.action.VIEW_PERMISSION_USAGE" />
            <category android:name="android.intent.category.HEALTH_PERMISSIONS" />
        </intent-filter>
    </activity-alias>
</application>

Important: Your MainActivity must extend FlutterFragmentActivity (not FlutterActivity) for Android 14+.

Basic Usage

Recommended Pattern (Explicit Permission Control):

import 'dart:io';
import 'package:flutter/widgets.dart';
import 'package:synheart_wear/synheart_wear.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();

  // Step 1: Create SDK instance
  final adapters = <DeviceAdapter>{
    DeviceAdapter.platformHealth, // Apple HealthKit on iOS, Health Connect on Android
  };

  // Use withAdapters() to explicitly specify which adapters to enable
  // Note: Default constructor includes fitbit by default, so use withAdapters() for clarity
  final synheart = SynheartWear(
    config: SynheartWearConfig.withAdapters(adapters),
  );

  // Step 2: Request permissions
  final result = await synheart.requestPermissions(
    permissions: {
      PermissionType.heartRate,
      PermissionType.steps,
      PermissionType.calories,
    },
  );

  // Step 3: Initialize SDK (validates permissions and data availability)
  if (result.values.any((s) => s == ConsentStatus.granted)) {
    try {
      await synheart.initialize();
      
      // Step 4: Read metrics
      final metrics = await synheart.readMetrics();
      print('HR: ${metrics.getMetric(MetricType.hr)} bpm');
      print('Steps: ${metrics.getMetric(MetricType.steps)}');
    } on SynheartWearError catch (e) {
      print('Initialization failed: $e');
      // Handle errors: NO_WEARABLE_DATA, STALE_DATA, etc.
    }
  }
}

Alternative Pattern (Simplified): If you don’t need to control when the permission prompt appears, let initialize() request permissions itself:

final synheart = SynheartWear(
  config: SynheartWearConfig.withAdapters({DeviceAdapter.platformHealth}),
);

// Initialize will request permissions internally if needed
await synheart.initialize();
final metrics = await synheart.readMetrics();

Note: initialize() validates that wearable data is available and not stale (>24 hours old). If no data is available or data is too old, it will throw a SynheartWearError with codes NO_WEARABLE_DATA or STALE_DATA.

Sleep and overnight history

HealthAdapter reads finished nights and their overnight physiology from HealthKit or Health Connect. Results are keyed by the local day each night ended on (midnight of the wake day).

import 'package:synheart_wear/synheart_wear.dart';

if (!await HealthAdapter.isAvailable()) return;

final now = DateTime.now();
final start = now.subtract(const Duration(days: 30));

final nights = await HealthAdapter.fetchSleepNights(start: start, end: now);
final physiology = await HealthAdapter.fetchOvernightPhysiology(
  start: start,
  end: now,
  sleepNights: nights, // scopes HRV and HR to each night's asleep span
);
final activeMinutes = await HealthAdapter.fetchActiveMinutes(start: start, end: now);

Pass sleepNights to fetchOvernightPhysiology. Without it, HRV and HR spread come from the whole day, and overnightHrBpm stays null.
HRV is SDNN on iOS (hrvSdnnMs) and RMSSD on Android (hrvRmssdMs); the other field is null.
A night crossing midnight stays whole; when a day has more than one sleep (a nap), the longest is kept.
Days with no record are absent from the map, never zero.
On Android, reads are throttled to one per 10 seconds to stay under Health Connect’s quota; a throttled call returns an empty map. Pass bypassThrottle: true for a user-initiated refresh.
Android reads reach about 30 days unless the app holds the history permission. Request it with HealthAdapter.requestHistoryAuthorization(); see Reading past 30 days.

Reading past 30 days (Android)

Health Connect lets an app read only the 30 days before it was first granted access, for every record type, unless it also holds READ_HEALTH_DATA_HISTORY. Declare it in the manifest (see Android Configuration), then ask for it; it is its own prompt:

if (await HealthAdapter.isHistoryAvailable() &&
    !await HealthAdapter.isHistoryAuthorized()) {
  await HealthAdapter.requestHistoryAuthorization();
}

isHistoryAvailable() is false where the device’s Health Connect doesn’t offer the permission; those devices stay at 30 days. On iOS there is no such limit: the checks report authorized and make no platform call.

`SleepNightSummary`
`totalAsleepMinutes`	Asleep total: deep + light + REM when stages exist, otherwise the asleep or in-bed time.
`deepMinutes`, `lightMinutes`, `remMinutes`	Stage minutes; null when the writing app recorded no stages.
`awakeMinutes`	Minutes awake during the night.
`sleepLatencyMinutes`	Time from getting into bed to first sleep; null when it can’t be derived.
`sleepStart`, `sleepEnd`	The night’s asleep span.

`OvernightPhysiologySummary`
`hrvRmssdMs` / `hrvSdnnMs`	Median HRV (Android / iOS).
`hrStdBpm`	Spread of heart rate.
`restingHrBpm`	The platform’s resting-HR record; null without one.
`overnightHrBpm`	Mean HR asleep; only when `sleepNights` was passed.
`stepsCount`	The day’s step total.

fetchActiveMinutes needs PermissionType.exercise, and on Android the READ_EXERCISE permission. To push this history into the personal baselines, see Health backfill.

Real-Time Streaming

// Stream heart rate every 5 seconds
// Note: Streams are created lazily when first listener subscribes
// Multiple calls to streamHR() return the same stream controller
final hrSubscription = synheart.streamHR(interval: Duration(seconds: 5))
  .listen((metrics) {
    final hr = metrics.getMetric(MetricType.hr);
    if (hr != null) print('Current HR: $hr bpm');
  }, onError: (error) {
    print('Stream error: $error');
  });

// Stream HRV in 5-second windows
final hrvSubscription = synheart.streamHRV(windowSize: Duration(seconds: 5))
  .listen((metrics) {
    final hrv = metrics.getMetric(MetricType.hrvRmssd);
    if (hrv != null) print('HRV RMSSD: $hrv ms');
  }, onError: (error) {
    print('HRV stream error: $error');
  });

// Don't forget to cancel subscriptions when done
// hrSubscription.cancel();
// hrvSubscription.cancel();

Complete Example

import 'dart:async';
import 'package:flutter/material.dart';
import 'package:synheart_wear/synheart_wear.dart';

class HealthMonitor extends StatefulWidget {
  @override
  _HealthMonitorState createState() => _HealthMonitorState();
}

class _HealthMonitorState extends State<HealthMonitor> {
  late SynheartWear _sdk;
  StreamSubscription<WearMetrics>? _hrSubscription;
  WearMetrics? _latestMetrics;
  bool _isConnected = false;

  @override
  void initState() {
    super.initState();
    _sdk = SynheartWear(
      config: SynheartWearConfig.withAdapters({
        DeviceAdapter.platformHealth,
      }),
    );
  }

  Future<void> _connect() async {
    try {
      // Step 1: Request permissions
      final result = await _sdk.requestPermissions(
        permissions: {
          PermissionType.heartRate,
          PermissionType.steps,
          PermissionType.calories,
        },
      );

      // Step 2: Initialize if permissions granted
      if (result.values.any((s) => s == ConsentStatus.granted)) {
        await _sdk.initialize();
        
        // Step 3: Read initial metrics
        final metrics = await _sdk.readMetrics();
        setState(() {
          _isConnected = true;
          _latestMetrics = metrics;
        });
      } else {
        setState(() {
          _isConnected = false;
          // Show error: permissions denied
        });
      }
    } on SynheartWearError catch (e) {
      // Handle SDK-specific errors (NO_WEARABLE_DATA, STALE_DATA, etc.)
      print('SDK Error: $e');
      setState(() {
        _isConnected = false;
        // Show error message
      });
    } catch (e) {
      // Handle other errors
      print('Error: $e');
      setState(() {
        _isConnected = false;
      });
    }
  }

  void _startStreaming() {
    _hrSubscription = _sdk
        .streamHR(interval: Duration(seconds: 3))
        .listen(
      (metrics) {
        setState(() => _latestMetrics = metrics);
      },
      onError: (error) {
        print('Stream error: $error');
        // Handle stream errors
      },
    );
  }

  void _stopStreaming() {
    _hrSubscription?.cancel();
    _hrSubscription = null;
  }

  @override
  void dispose() {
    _hrSubscription?.cancel();
    _sdk.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text('Health Monitor')),
      body: _isConnected
          ? Column(
              mainAxisAlignment: MainAxisAlignment.center,
              children: [
                if (_latestMetrics != null) ...[
                  Text(
                    'HR: ${_latestMetrics!.getMetric(MetricType.hr) ?? "--"} bpm',
                    style: TextStyle(fontSize: 32),
                  ),
                  SizedBox(height: 16),
                  Text('Steps: ${_latestMetrics!.getMetric(MetricType.steps) ?? "--"}'),
                  Text('Calories: ${_latestMetrics!.getMetric(MetricType.calories) ?? "--"} kcal'),
                  SizedBox(height: 24),
                ],
                ElevatedButton(
                  onPressed: _hrSubscription == null ? _startStreaming : _stopStreaming,
                  child: Text(_hrSubscription == null ? 'Start Streaming' : 'Stop Streaming'),
                ),
              ],
            )
          : Center(
              child: ElevatedButton(
                onPressed: _connect,
                child: Text('Connect to Health'),
              ),
            ),
    );
  }
}

Data Schema

Access metrics using the WearMetrics object:

final metrics = await synheart.readMetrics();

// Basic metrics
final hr = metrics.getMetric(MetricType.hr);           // Heart rate (bpm)
final steps = metrics.getMetric(MetricType.steps);     // Steps
final calories = metrics.getMetric(MetricType.calories); // Calories (kcal)
final distance = metrics.getMetric(MetricType.distance); // Distance (km)

// HRV metrics: the platform gives one HRV figure (SDNN on iOS, RMSSD on
// Health Connect), and the SDK stores it under both keys
final hrvRmssd = metrics.getMetric(MetricType.hrvRmssd); // HRV (ms)
final hrvSdnn = metrics.getMetric(MetricType.hrvSdnn);   // same value

// RR intervals (nullable; non-null only when the adapter exposes RR samples)
final rrIntervals = metrics.rrIntervalsMs; // List<double>?

// Metadata
final batteryLevel = metrics.batteryLevel;     // 0.0-1.0
final synced = metrics.isSynced;               // true for vendor sync/backfill data
final deviceId = metrics.deviceId;             // String
final source = metrics.source;                 // String
final timestamp = metrics.timestamp;           // DateTime

Error Handling

try {
  // Request permissions
  final result = await synheart.requestPermissions(
    permissions: {PermissionType.heartRate, PermissionType.steps},
  );

  if (result.values.any((s) => s == ConsentStatus.granted)) {
    // Initialize (may throw if no data or stale data)
    await synheart.initialize();
    
    // Read metrics
    final metrics = await synheart.readMetrics();
    if (metrics.hasValidData) {
      print('Data available');
    }
  }
} on PermissionDeniedError catch (e) {
  print('Permission denied: ${e.message}');
  // User denied permissions - show message or retry
} on SynheartWearError catch (e) {
  // Handle SDK-specific errors
  if (e.code == 'NO_WEARABLE_DATA') {
    print('No wearable data available. Please check device connection.');
  } else if (e.code == 'STALE_DATA') {
    print('Data is stale. Please sync your wearable device.');
  } else {
    print('SDK error: ${e.message}');
  }
} catch (e) {
  print('Unexpected error: $e');
}

Common Error Codes:

NO_WEARABLE_DATA: No health data available from connected devices
STALE_DATA: Latest data is older than 24 hours
PERMISSION_DENIED: User denied required permissions (thrown as PermissionDeniedError)

requestPermissions() accepts a reason: argument, but the SDK doesn’t show it anywhere; explain the request in your own UI before calling it.

BLE Heart Rate Monitor

Connect directly to any standard Bluetooth LE heart rate monitor (WHOOP Broadcast, Polar, Wahoo, Garmin HRM straps) for real-time HR streaming. No cloud backend needed.

Platform Setup

Android — Add to AndroidManifest.xml:

<uses-permission android:name="android.permission.BLUETOOTH_SCAN" android:usesPermissionFlags="neverForLocation" />
<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
<!-- Android 9-11 (the plugin's minSdk is 28) -->
<uses-permission android:name="android.permission.BLUETOOTH" android:maxSdkVersion="30" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" android:maxSdkVersion="30" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" android:maxSdkVersion="30" />
<!-- The plugin keeps streaming alive with a dataSync foreground service -->
<uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
<uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
<uses-permission android:name="android.permission.POST_NOTIFICATIONS" />

On Android, request BLUETOOTH_SCAN and BLUETOOTH_CONNECT at runtime yourself (for example with permission_handler). BleHrmProvider.requestPermission() is iOS-only; on Android it throws MissingPluginException. iOS — Add to Info.plist:

<key>NSBluetoothAlwaysUsageDescription</key>
<string>This app uses Bluetooth to connect to heart rate monitors.</string>

Usage

import 'dart:io';
import 'package:synheart_wear/synheart_wear.dart';

final bleHrm = BleHrmProvider();

// iOS only: show the Bluetooth permission prompt
if (Platform.isIOS) await bleHrm.requestPermission();

// Scan for nearby HR monitors (default timeout 5 s; optional name prefix)
final devices = await bleHrm.scan(timeoutMs: 10000, namePrefix: 'Polar');
if (devices.isEmpty) return;

await bleHrm.connect(
  deviceId: devices.first.deviceId,
  sessionId: 'my-session',
);

// Listen to heart rate samples
final sub = bleHrm.onHeartRate.listen((sample) {
  print('BPM: ${sample.bpm}');
  if (sample.rrIntervalsMs.isNotEmpty) {
    print('RR intervals: ${sample.rrIntervalsMs}');
  }
});

// Check connection status
final connected = await bleHrm.isConnected();

// Disconnect when done
await sub.cancel();
await bleHrm.disconnect();

Polar H10 straps can also stream their accelerometer: pass enableMotion: true (and optionally motionSampleRateHz, default 50) to connect() and listen to bleHrm.onMotion. getBondedHrDevices() lists already-bonded straps without scanning.

HeartRateSample

Each sample from the stream contains:

Field	Type	Description
`tsMs`	`int`	Phone receipt timestamp (ms since epoch)
`bpm`	`double`	Heart rate in beats per minute
`source`	`String`	Always `"ble_hrm"`
`deviceId`	`String?`	BLE MAC address on Android, CoreBluetooth peripheral UUID on iOS
`deviceName`	`String?`	Device advertised name
`sessionId`	`String?`	Optional session tag
`rrIntervalsMs`	`List<double>`	RR intervals in milliseconds (empty when device doesn’t expose RR)

Error Handling

BLE calls throw BleHrmError, whose code is a BleHrmErrorCode. Errors on the onHeartRate stream use the same type:

try {
  await bleHrm.connect(deviceId: id);
} on BleHrmError catch (e) {
  switch (e.code) {
    case BleHrmErrorCode.permissionDenied: // Bluetooth permission not granted
    case BleHrmErrorCode.bluetoothOff:     // Bluetooth adapter is disabled
    case BleHrmErrorCode.deviceNotFound:   // not found, or connection timed out
    case BleHrmErrorCode.subscribeFailed:  // HR notifications failed (also unknown native errors)
    case BleHrmErrorCode.disconnected:     // device disconnected
  }
}

Notes

WHOOP devices require “Broadcast Heart Rate” enabled in the WHOOP app settings
RR intervals are available on some devices (e.g. Polar chest straps) but not all
Reconnection is automatic. Android retries 5 times, 3 s apart; iOS waits up to 30 s for CoreBluetooth to reconnect. After that disconnected is reported
Only one BLE HRM device can be connected at a time

Cloud Providers

WhoopProvider

final whoopProvider = WhoopProvider(
  appId: 'your-app-id',
  userId: 'user-123',
);

// Historical data methods
final recovery = await whoopProvider.fetchRecovery(
  start: DateTime.now().subtract(Duration(days: 7)),
  end: DateTime.now(),
);
final sleep = await whoopProvider.fetchSleep(
  start: DateTime.now().subtract(Duration(days: 7)),
  end: DateTime.now(),
);
final workouts = await whoopProvider.fetchWorkouts(
  start: DateTime.now().subtract(Duration(days: 7)),
  end: DateTime.now(),
);
final cycles = await whoopProvider.fetchCycles(
  start: DateTime.now().subtract(Duration(days: 7)),
  end: DateTime.now(),
);

GarminProvider (Cloud)

Full Garmin Connect integration via OAuth PKCE. Supports 12 summary types through the Garmin Health API backfill endpoint, plus activities (fetchActivities()): dailies, epochs, sleeps, stressDetails, hrv, userMetrics, bodyComps, pulseox, respiration, healthSnapshot, bloodPressures, and skinTemp.

final garminProvider = GarminProvider(
  appId: 'your-app-id',
  userId: 'user-123',
);

// Backfill API — fetch any of the 12 summary types
final dailies = await garminProvider.fetchDailies(
  start: DateTime.now().subtract(Duration(days: 7)),
  end: DateTime.now(),
);
final sleeps = await garminProvider.fetchSleeps(
  start: DateTime.now().subtract(Duration(days: 7)),
  end: DateTime.now(),
);
final hrv = await garminProvider.fetchHRV(
  start: DateTime.now().subtract(Duration(days: 7)),
  end: DateTime.now(),
);
final stress = await garminProvider.fetchStressDetails(
  start: DateTime.now().subtract(Duration(days: 7)),
  end: DateTime.now(),
);

// Additional methods: fetchEpochs(), fetchUserMetrics(), fetchBodyComps(),
// fetchPulseOx(), fetchRespiration(), fetchHealthSnapshot(),
// fetchBloodPressures(), fetchSkinTemp()

GarminHealth (Native RTS)

The GarminHealth facade provides native Garmin device integration for scanning, pairing, and real-time streaming. All method signatures use generic SDK-owned types (ScannedDevice, PairedDevice, WearMetrics), never Garmin-specific types.

Important: The Garmin Health SDK Real-Time Streaming (RTS) capability requires a separate license from Garmin. This facade is available on demand for licensed integrations. The underlying Garmin Health SDK code is proprietary to Garmin and is not distributed as open source.

final garmin = GarminHealth(licenseKey: 'your-garmin-sdk-key');
await garmin.initialize();

// Scan for devices
garmin.scannedDevicesStream.listen((devices) {
  print('Found ${devices.length} devices');
});
await garmin.startScanning();

// Pair with a device
final paired = await garmin.pairDevice(scannedDevice);

// Stream real-time metrics
garmin.realTimeStream.listen((metrics) {
  final hr = metrics.getMetric(MetricType.hr);
  print('HR: $hr bpm');
});
await garmin.startStreaming(device: paired);

// Read unified metrics
final metrics = await garmin.readMetrics();

Platform-Specific Notes

Android

HRV: Health Connect reports RMSSD only, as hrv_rmssd; hrv_sdnn stays null
Distance: Uses DISTANCE_DELTA type
readMetrics() calls are spaced at least 10 seconds apart to stay under Health Connect’s read quota. A call for the same data inside that gap gets the previous result; any other call waits out the gap, then reads.
Requires Health Connect app installed
MainActivity must extend FlutterFragmentActivity

iOS

Requires iOS 16+ and the HealthKit capability enabled in Xcode
HRV: HealthKit reports SDNN only, as hrv_sdnn; hrv_rmssd stays null
No HealthKit background delivery: reads happen when your app calls the SDK
Real-time reads look back 2 minutes and run at most every 10 s; calls in between return no new data

API Reference

`SynheartWear`

Main SDK class for interacting with wearable devices. Constructor:

SynheartWear({
  SynheartWearConfig? config,                    // defaults to SynheartWearConfig()
  Map<DeviceAdapter, WearAdapter>? adapters,     // custom adapter overrides
  GarminHealth? garminHealth,
})

Methods:

Method	Description	Returns
`requestPermissions()`	Request health data permissions	`Future<Map<PermissionType, ConsentStatus>>`
`initialize()`	Initialize the SDK	`Future<void>`
`getPermissionStatus()`	Current grant per permission	`Map<PermissionType, ConsentStatus>`
`revokeAllPermissions()`	Revoke the SDK’s grants (does not clear the cache)	`Future<void>`
`readMetrics({isRealTime, startTime, endTime})`	Read latest metrics	`Future<WearMetrics>`
`streamHR({interval})`	Stream heart rate	`Stream<WearMetrics>`
`streamHRV({windowSize})`	Stream HRV	`Stream<WearMetrics>`
`getCachedSessions()` / `getCacheStats()` / `clearOldCache()`	Local cache	`Future<…>`
`garminHealth`	The `GarminHealth` passed to the constructor	`GarminHealth?`
`dispose()`	Cleanup resources	`void`

`SynheartWearConfig`

Configuration for the SDK. Constructor:

const SynheartWearConfig({
  Set<DeviceAdapter> enabledAdapters,     // default includes platformHealth
  Duration streamInterval = const Duration(seconds: 2),
  Duration hrvWindowSize = const Duration(seconds: 5),
  bool enableLocalCaching = true,
  bool enableEncryption = true,
  String? encryptionKeyPath,
  Map<String, Object?> adapterConfig = const {},
})

SynheartWearConfig.withAdapters(Set<DeviceAdapter> adapters) // other fields default
SynheartWearConfig.development()
SynheartWearConfig.production()
config.copyWith(...)

`WearMetrics`

Biometric data container. Methods:

Method	Description	Returns
`getMetric(MetricType type)`	Get specific metric	`num?`
`hasValidData`	Check if data is valid	`bool`

Properties:

Property	Type	Description
`timestamp`	`DateTime`	When data was recorded
`deviceId`	`String`	Device identifier
`source`	`String`	Data source
`rrIntervalsMs`	`List<double>?`	RR intervals (ms); non-null only when the adapter exposes them
`batteryLevel`	`double?`	Battery level (0.0-1.0); pulled from `meta.battery`
`isSynced`	`bool`	`true` when the sample came from a vendor sync or backfill (`meta.synced`)

`HealthAdapter`

Static reads from HealthKit / Health Connect. See Sleep and overnight history.

Method	Returns
`isAvailable()`	`Future<bool>`: whether HealthKit or Health Connect can be used
`fetchSleepNights({start, end, bypassThrottle})`	`Future<Map<DateTime, SleepNightSummary>>`
`fetchOvernightPhysiology({start, end, sleepNights, bypassThrottle})`	`Future<Map<DateTime, OvernightPhysiologySummary>>`
`fetchActiveMinutes({start, end, bypassThrottle})`	`Future<Map<DateTime, double>>`: active minutes per local day
`isHistoryAvailable()`	`Future<bool>`: whether Health Connect offers `READ_HEALTH_DATA_HISTORY` (always `false` off Android)
`isHistoryAuthorized()`	`Future<bool>`: whether the history permission is granted (always `true` off Android)
`requestHistoryAuthorization()`	`Future<bool>`: asks for the history permission; its own prompt

Resources

Repository: synheart-wear-flutter
pub.dev: synheart_wear
API Docs: API Reference
Issues: GitHub Issues