Synheart Wear Overview - Synheart Documentation

What is Synheart Wear?

Synheart Wear is a unified wearable SDK ecosystem that streams biometric data (HR, HRV, steps, calories, distance) from Apple Health, Health Connect, WHOOP, Garmin, Fitbit, Oura and BLE heart-rate straps through a single, standardized API across Flutter, Android, and iOS applications.

Wondering what data you actually get from each device — and what you don’t? Wearable signals is the reality check: the access gates, the raw signals, and what the data becomes downstream.

Key Features

Cross-Platform Support

Flutter: Cross-platform mobile apps (iOS 16+ / Android API 28+, Flutter 3.32+)
Native Android: Kotlin SDK with Health Connect integration (Android API 21+, compileSdk 34)
Native iOS: Swift SDK with HealthKit integration (iOS 13+, watchOS 8+, macOS 13+)

Multi-Device Support

Device	Flutter	Android	iOS	Status
Apple Watch	✅	—	✅ (via HealthKit)	Ready
Health Connect	✅	✅ (Native)	❌	Ready
WHOOP	✅	✅	✅	Ready
BLE Heart Rate Monitors	✅	✅	✅	Ready
Fitbit (Cloud OAuth)	✅	✅	✅	Ready
Garmin (Cloud)	✅	✅	✅	Ready
Garmin (Native RTS)	✅	✅	✅	On demand (licensed)
Samsung Health	📋	📋	❌	Planned
Oura Ring (Cloud OAuth)	✅	✅	✅	Ready

Garmin Native RTS: The Garmin Health SDK Real-Time Streaming (RTS) capability requires a separate license from Garmin. The GarminHealth 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. For cloud-based Garmin data (OAuth + webhooks), use GarminProvider.

Legend: ✅ Ready | 📋 Planned

BLE Heart Rate Monitor Support

Direct Bluetooth LE connection to any standard heart rate monitor — no cloud API required. Works with devices implementing the standard BLE Heart Rate Profile (0x180D), including:

WHOOP (Broadcast Heart Rate mode)
Polar chest straps (H10, OH1)
Wahoo TICKR
Garmin HRM-Pro / HRM-Dual

Unified data shape

Every SDK reports readings as WearMetrics. The Flutter SDK serializes it with WearMetrics.toJson():

{
  "timestamp": "2025-10-20T18:30:00Z",
  "device_id": "applewatch_1234",
  "source": "apple_healthkit",
  "metrics": {
    "hr": 72,
    "hrv_rmssd": 45,
    "hrv_sdnn": 62,
    "steps": 1045,
    "calories": 120.4,
    "distance": 2.5
  },
  "meta": {
    "battery": 0.82
  },
  "rr_ms": [800, 850, 820]
}

timestamp, device_id, source, metrics, and meta are required. metrics keys are scoped by the MetricType enum (hr, hrv_rmssd, hrv_sdnn, steps, calories, distance, stress); adapters set the keys they actually have. meta is a free-form Map<String, Object?> — meta.battery and meta.synced are read back by the SDK (WearMetrics.batteryLevel, WearMetrics.isSynced). The native SDKs differ in a few places:

	Flutter	Kotlin	Swift
Serializer	`toJson()`	`toMap()`	`toDict()`
RR intervals	`rrIntervalsMs` (`rr_ms`)	`rrIntervals`	`rrIntervals`
`meta`	`Map<String, Object?>`	`Map<String, String>`	`[String: String]`
Battery	`meta.battery`	`MetricType.BATTERY`	`.battery`
`distance`	km	meters	not read from HealthKit

The two HRV keys usually hold the same value: each platform reports one HRV figure (SDNN from HealthKit, RMSSD from Health Connect), and the SDK stores it under both.

Privacy & security

Consent-first design — reads are gated by the permissions the user granted. On Flutter, requestPermissions is all-or-nothing: every requested type gets the same status.
Local cache encryption — on Flutter (0.7.0+), each cached session is sealed with AES-256-GCM under a key kept in the iOS Keychain or Android secure storage when enableEncryption is set; tampered records are dropped. Swift (0.4.3+) does the same with a Keychain key. The Kotlin SDK accepts enableEncryption but currently writes the cache unencrypted.
No persistent IDs — the SDK does not generate or persist a user-level identifier; integrations supply their own pseudonymous ID.
Right to revoke — Kotlin and Swift purgeAllData() clears the local cache and revokes consents. On Flutter, revokeAllPermissions() revokes grants and clearOldCache() clears the cache; they are separate calls.

Architecture

┌──────────────────────────────────────────────────────┐
│              Synheart Wear Ecosystem                 │
└──────────────────────────────────────────────────────┘
                         │
        ┌────────────────┼────────────────┐
        │                │                │
┌───────▼────────┐ ┌─────▼─────┐ ┌───────▼────────┐
│ synheart-wear- │ │synheart-  │ │ synheart-wear- │
│    flutter     │ │wear-kotlin│ │     swift      │
│  (Flutter)     │ │ (Android) │ │     (iOS)      │
└────────────────┘ └───────────┘ └────────────────┘

SDK Architecture

Each SDK implements a consistent architecture:

┌─────────────────────────┐
│   synheart_wear SDK     │
├─────────────────────────┤
│ Device Adapters Layer   │
│ (Apple, Fitbit, etc.)   │
├─────────────────────────┤
│ Normalization Engine    │
│ (standard output schema)│
├─────────────────────────┤
│   Local Cache & Storage │
│   (encrypted, offline)  │
└─────────────────────────┘

Available SDKs

Flutter SDK

Cross-platform SDK for iOS and Android apps.

Flutter SDK Documentation

Complete guide for Flutter integration

Installation:

dependencies:
  synheart_wear: ^0.7.0

Repository: synheart-wear-flutter · runnable example

Android (Kotlin) SDK

Native Android SDK with Health Connect integration.

Kotlin SDK Documentation

Complete guide for Android integration

Installation:

implementation("ai.synheart:synheart-wear:0.4.2")

Repository: synheart-wear-kotlin

iOS (Swift) SDK

Native iOS SDK with HealthKit integration.

Swift SDK Documentation

Complete guide for iOS integration

Installation:

.package(url: "https://github.com/synheart-ai/synheart-wear-swift.git", from: "0.4.3")

Repository: synheart-wear-swift

Stability

Synheart Wear is pre-1.0. Minor version bumps may include breaking API changes — pin exact versions (or a tight constraint like ^0.7.0) in production, and read each SDK’s CHANGELOG before upgrading. Individual wearable adapters are versioned independently of the SDK; adapter-specific changes are called out in the Adapters page.

Use Cases

Wellness Apps

Monitor heart rate, HRV, and activity metrics for wellness coaching:

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

synheart.streamHR(interval: Duration(seconds: 5))
  .listen((metrics) {
    final hr = metrics.getMetric(MetricType.hr);
    if (hr != null && hr > 120) {
      showAlert('High heart rate detected!');
    }
  });

Mental Health Platforms

Stream biosignals into Synheart Core for HSI fusion (focus, capacity, recovery, strain):

synheart.streamHRV(windowSize: Duration(seconds: 60))
  .listen((metrics) {
    // Forward to Synheart Core for on-device HSI computation
  });

Research Applications

Collect biometric data for scientific studies:

final synheart = SynheartWear(
  config: SynheartWearConfig(
    enableLocalCaching: true,
    enableEncryption: true,
  ),
);

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

Next Steps

Quick Start

Get started in 5 minutes

Flutter SDK

Flutter integration guide

Kotlin SDK

Android integration guide

Swift SDK

iOS integration guide

Community

GitHub: github.com/synheart-ai — every Wear SDK lives in its per-language repo (synheart-wear-flutter, synheart-wear-kotlin, synheart-wear-swift).
Issues: file against the relevant per-language repo.