Synheart Focus

On-device cognitive concentration inference from biosignals and behavioral patterns for Flutter applications

🚀 Features

📱 Cross-Platform: Works on iOS and Android
🔄 Real-Time Inference: Live focus state detection from biosignals and behavior
🧠 On-Device Processing: All computations happen locally for privacy
📊 Unified Output: Consistent focus scores (0-100) with state labels
🔒 Privacy-First: No raw biometric data leaves your device
⚡ High Performance: Optimized for real-time processing on mobile devices

📦 Installation

Add synheart_focus to your pubspec.yaml:

dependencies:
  synheart_focus: ^0.0.1

Then run:

flutter pub get

🎯 Quick Start

Basic Usage

import 'package:synheart_focus/synheart_focus.dart';

void main() async {
  // Initialize the focus engine
  final engine = await FocusEngine.initialize(
    config: FocusConfig(),
  );

  // Subscribe to focus updates
  engine.onUpdate.listen((result) {
    print('Focus Score: ${result.focusScore}');
    print('Focus State: ${result.focusState}');
    print('Confidence: ${result.confidence}');
  });

  // Provide biosignal data
  final hsiData = HSIData(
    hr: 72.0,
    hrvRmssd: 45.0,
    stressIndex: 0.3,
    motionIntensity: 0.1,
  );

  // Provide behavioral data
  final behaviorData = BehaviorData(
    taskSwitchRate: 0.2,
    interactionBurstiness: 0.15,
    idleRatio: 0.1,
  );

  // Run inference
  final result = await engine.infer(hsiData, behaviorData);
  print('Focus Score: ${result.focusScore}');
}

Integration with synheart-wear

synheart_focus works independently but integrates seamlessly with synheart-wear for real wearable data.

First, add both to your pubspec.yaml:

dependencies:
  synheart_wear: ^0.1.0    # For wearable data
  synheart_focus: ^0.0.1   # For focus inference

Then integrate in your app:

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

// Initialize both SDKs
final wear = SynheartWear();
final focusEngine = await FocusEngine.initialize(
  config: FocusConfig(),
);

await wear.initialize();

// Stream wearable data to focus engine
wear.streamHR(interval: Duration(seconds: 1)).listen((metrics) {
  final hsiData = HSIData(
    hr: metrics.getMetric(MetricType.hr),
    hrvRmssd: calculateRMSSD(metrics.getMetric(MetricType.rrIntervals)),
    stressIndex: calculateStress(metrics),
    motionIntensity: metrics.getMetric(MetricType.motion),
  );

  // Add behavioral data from your app
  final behaviorData = BehaviorData(
    taskSwitchRate: appMetrics.taskSwitchRate,
    interactionBurstiness: appMetrics.interactionBurstiness,
    idleRatio: appMetrics.idleRatio,
  );

  // Get focus state
  focusEngine.infer(hsiData, behaviorData).then((result) {
    updateUI(result);
  });
});

📊 Supported Focus States

The library currently supports three focus state categories:

🎯 Focused: High concentration, productive state
⏱️ Time Pressure: Moderate focus with elevated stress
😵 Distracted: Low concentration, fragmented attention

Focus Scores:

70-100: Focused (optimal concentration)
40-70: Time Pressure (stressed but engaged)
0-40: Distracted (low concentration)

🔧 API Reference

FocusEngine

The main class for focus inference:

class FocusEngine {
  // Initialize engine with config
  static Future<FocusEngine> initialize({
    required FocusConfig config,
  });

  // Stream of focus updates
  Stream<FocusResult> get onUpdate;

  // Run inference on current data
  Future<FocusResult> infer(HSIData hsiData, BehaviorData behaviorData);

  // Dispose resources
  Future<void> dispose();
}

FocusConfig

Configuration for the focus engine:

class FocusConfig {
  final Duration window;                // Rolling window size
  final Duration step;                  // Emission cadence
  final bool enableAdaptiveBaseline;    // Adaptive personalization
  final double smoothingFactor;         // Result smoothing (0.0-1.0)
}

FocusResult

Result of focus inference:

class FocusResult {
  final DateTime timestamp;                // When inference was performed
  final String focusState;                 // "Focused", "time pressure", or "Distracted"
  final double focusScore;                 // 0-100 focus score
  final double confidence;                 // Confidence score (0.0-1.0)
  final Map<String, double> probabilities; // All state probabilities
  final Map<String, double> features;      // Extracted features
  final Map<String, dynamic> model;        // Model metadata
}

HSIData

Heart Signal Intelligence data:

class HSIData {
  final double hr;                // Heart rate (BPM)
  final double hrvRmssd;          // HRV RMSSD (ms)
  final double stressIndex;       // Stress index (0.0-1.0)
  final double motionIntensity;   // Motion intensity (0.0-1.0)
}

BehaviorData

Behavioral pattern data:

class BehaviorData {
  final double taskSwitchRate;        // Task switching frequency
  final double interactionBurstiness; // Interaction pattern metric
  final double idleRatio;             // Idle time ratio
}

🔒 Privacy & Security

On-Device Processing: All focus inference happens locally
No Data Retention: Raw biometric data is not retained after processing
No Network Calls: No data is sent to external servers
Privacy-First Design: No built-in storage - you control what gets persisted
Real Trained Models: Uses SWELL-trained models with validated accuracy

📱 Example App

Check out the complete examples in the synheart-focus repository:

# Clone the main repository for examples
git clone https://github.com/synheart-ai/synheart-focus.git
cd synheart-focus/examples
flutter pub get
flutter run

The example demonstrates:

Real-time focus detection
Probability visualization
Multi-modal data integration
Adaptive baseline tracking

🧪 Testing

Run the test suite:

flutter test

Tests cover:

Feature extraction accuracy
Model inference performance
Edge case handling
Multi-modal fusion

📊 Performance

Target Performance (mid-range phone):

Latency: < 10ms per inference
Model Size: < 2 MB (ONNX model)
CPU Usage: < 3% during active streaming
Memory: < 5 MB (engine + buffers)
Accuracy: Validated on SWELL dataset

🏗️ Architecture

Biosignals (HR, HRV) + Behavior Data
         │
         ▼
┌─────────────────────┐
│   FocusEngine       │
│  [Feature Extract]  │
│  [Adaptive Baseline]│
│  [Model Inference]  │
└─────────────────────┘
         │
         ▼
   FocusResult
         │
         ▼
    Your App

🔗 Integration

With synheart-wear

Perfect integration with the Synheart Wear SDK for real wearable data:

// Stream from Apple Watch, Fitbit, etc.
final wearStream = synheartWear.streamHR();
final focusStream = focusEngine.onUpdate;

With synheart-emotion

Combine with emotion detection for comprehensive mental state tracking:

// Use both emotion and focus together
final emotionResult = emotionEngine.consumeReady();
final focusResult = await focusEngine.infer(hsiData, behaviorData);

// Combined mental state
print('Emotion: ${emotionResult.emotion}, Focus: ${focusResult.focusState}');

📄 License

This project is licensed under the Apache License 2.0 - see the LICENSE file for details.

🤝 Contributing

We welcome contributions! See our Contributing Guidelines for details.

👥 Authors

Synheart AI Team - Initial work, Architecture & Design

Made with ❤️ by the Synheart AI Team

Technology with a heartbeat.

Patent Pending Notice

This project is provided under an open-source license. Certain underlying systems, methods, and architectures described or implemented herein may be covered by one or more pending patent applications.

Nothing in this repository grants any license, express or implied, to any patents or patent applications, except as provided by the applicable open-source license.