aidlab_sdk 1.7.4

Aidlab Flutter SDK. For more information please visit https://www.aidlab.com/developer

example/lib/main.dart

import 'package:aidlab_sdk/aidlab_sdk.dart';
import 'package:flutter/material.dart';
import 'package:permission_handler/permission_handler.dart';
import 'line_chart.dart';
import 'dart:io';

AidlabManager? aidlabManager;

// In-memory connection state and device names (autopair removed)
class AutoPairService {
  static final Map<String, String> _deviceNames = {};
  static final Set<String> _connectedDevices = {};
  static final Set<String> _connectingDevices = {};

  static String getDeviceName(String address) {
    return _deviceNames[address] ?? address;
  }

  static void setDeviceName(String address, String name) {
    _deviceNames[address] = name;
  }

  static bool isConnected(String address) {
    return _connectedDevices.contains(address);
  }

  static bool isConnecting(String address) {
    return _connectingDevices.contains(address);
  }

  static void setConnected(String address, bool connected) {
    if (connected) {
      _connectedDevices.add(address);
      _connectingDevices.remove(address);
    } else {
      _connectedDevices.remove(address);
      _connectingDevices.remove(address);
    }
  }

  static void setConnecting(String address, bool connecting) {
    if (connecting) {
      _connectingDevices.add(address);
    } else {
      _connectingDevices.remove(address);
    }
  }

  static bool canConnect(String address) {
    return !isConnected(address) && !isConnecting(address);
  }
}

void main() {
  runApp(const MyApp());
}

class MyApp extends StatelessWidget {
  const MyApp({super.key});

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Aidlab Flutter SDK Example',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: const DeviceListScreen(),
    );
  }
}

class DeviceListScreen extends StatefulWidget {
  const DeviceListScreen({super.key});

  @override
  State<DeviceListScreen> createState() => _DeviceListScreenState();
}

class _DeviceListScreenState extends State<DeviceListScreen>
    implements AidlabManagerDelegate {
  final List<Device> _devices = [];
  final Map<String, Device> _discoveredDevices = {};
  bool _isScanning = false;
  bool _permissionsReady = false;

  @override
  void initState() {
    super.initState();
    _ensurePermissions();
    aidlabManager = AidlabManager(this);
  }

  /// Ask for runtime permissions required for BLE scanning.
  /// Android 12+ requires bluetoothScan and bluetoothConnect; Android 6–11 requires Location and enabled location services.
  Future<void> _ensurePermissions() async {
    // iOS: request Bluetooth permission only. Location is not required for CoreBluetooth scanning.
    if (Platform.isIOS) {
      // Request the iOS Bluetooth permission. This triggers the native prompt.
      final bluetoothStatus = await Permission.bluetooth.request();
      setState(() {
        _permissionsReady = bluetoothStatus.isGranted;
      });
      return;
    }

    // Android: request runtime permissions depending on OS version.
    final scanStatus = await Permission.bluetoothScan.request();
    final connectStatus = await Permission.bluetoothConnect.request();
    final locationStatus = await Permission.locationWhenInUse.request();

    final serviceEnabled = await Permission.location.serviceStatus.isEnabled;

    final hasBle12Plus = scanStatus.isGranted && connectStatus.isGranted;
    final hasBlePre12 = locationStatus.isGranted && serviceEnabled;

    if (!serviceEnabled && !hasBle12Plus) {
      // On Android pre-12, users must enable Location Services for BLE scanning.
      await openAppSettings();
    }

    setState(() {
      _permissionsReady = hasBle12Plus || hasBlePre12;
    });
  }

  @override
  void dispose() {
    aidlabManager?.dispose();
    aidlabManager = null;
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Devices'),
      ),
      body: Column(
        children: [
          Expanded(
            child: ListView.builder(
              itemCount: _devices.length,
              itemBuilder: (context, index) {
                final device = _devices[index];
                final deviceName =
                    AutoPairService.getDeviceName(device.address);
                final isConnected = AutoPairService.isConnected(device.address);
                final isConnecting =
                    AutoPairService.isConnecting(device.address);

                return Card(
                  margin:
                      const EdgeInsets.symmetric(horizontal: 8, vertical: 4),
                  color: isConnected
                      ? Colors.green.shade50
                      : isConnecting
                          ? Colors.orange.shade50
                          : null,
                  child: ListTile(
                    title: Text(deviceName),
                    subtitle: Column(
                      crossAxisAlignment: CrossAxisAlignment.start,
                      mainAxisSize: MainAxisSize.min,
                      children: [
                        Text(device.address),
                        if (isConnected)
                          const Text('Connected',
                              style: TextStyle(
                                  color: Colors.green,
                                  fontWeight: FontWeight.bold)),
                        if (isConnecting)
                          const Text('Connecting...',
                              style: TextStyle(
                                  color: Colors.orange,
                                  fontWeight: FontWeight.bold)),
                      ],
                    ),
                    trailing: const Row(
                      mainAxisSize: MainAxisSize.min,
                      children: [],
                    ),
                    onTap: () {
                      if (AutoPairService.canConnect(device.address)) {
                        _connectToDevice(device);
                      } else if (isConnected) {
                        // If already connected, still allow to go to detail screen
                        Navigator.push(
                          context,
                          MaterialPageRoute(
                            builder: (context) =>
                                DeviceDetailScreen(device: device),
                          ),
                        );
                      }
                    },
                  ),
                );
              },
            ),
          ),
          Padding(
            padding:
                const EdgeInsets.symmetric(horizontal: 16.0, vertical: 8.0),
            child: _isScanning
                ? ElevatedButton(
                    onPressed: () => stopScan(),
                    style:
                        ElevatedButton.styleFrom(backgroundColor: Colors.red),
                    child: const Text('Stop scan'),
                  )
                : ElevatedButton(
                    onPressed: () async {
                      // iOS: allow starting scan even if permission isn't yet granted;
                      // the system prompt appears upon first CoreBluetooth use.
                      if (Platform.isIOS) {
                        if (!_permissionsReady) {
                          await Permission.bluetooth.request();
                        }
                        startScan();
                        return;
                      }

                      // Android: gate scanning on runtime permissions.
                      await _ensurePermissions();
                      if (!context.mounted) return;
                      if (_permissionsReady) {
                        startScan();
                      } else {
                        ScaffoldMessenger.of(context).showSnackBar(
                          const SnackBar(
                            content: Text(
                                'Grant Bluetooth permission when prompted'),
                          ),
                        );
                      }
                    },
                    child: const Text('Start scan'),
                  ),
          ),
        ],
      ),
    );
  }

  void startScan() {
    aidlabManager?.scan(ScanMode.lowPower);
    setState(() {
      _isScanning = true;
    });
  }

  void stopScan() {
    aidlabManager?.stopScan();
    setState(() {
      _isScanning = false;
      _devices.clear();
    });
  }

  @override
  void didDiscover(Device device, int rssi) {
    // Store discovered devices
    _discoveredDevices[device.address] = device;

    // Save device name if not already saved
    if (!AutoPairService._deviceNames.containsKey(device.address)) {
      AutoPairService.setDeviceName(
          device.address, device.name ?? device.address);
    }

    setState(() {
      if (!_devices.any((d) => d.address == device.address)) {
        _devices.add(device);
      } else {
        _devices.removeWhere((d) => d.address == device.address);
        _devices.add(device);
      }
    });

    // Autopair removed: manual connect only by tapping on device
  }

  @override
  void onBluetoothStarted() {
    ScaffoldMessenger.of(context)
        .showSnackBar(const SnackBar(content: Text("Bluetooth started")));
  }

  @override
  void onDeviceScanStarted() {}

  @override
  void onDeviceScanStopped() {}

  @override
  void onScanFailed(int errorCode) {
    /// Show toast
    ScaffoldMessenger.of(context)
        .showSnackBar(SnackBar(content: Text("Scan failed: $errorCode")));
  }

  // Autopair monitoring removed

  void _connectToDevice(Device device) {
    // Prevent multiple simultaneous connections to same device
    if (AutoPairService.isConnecting(device.address) ||
        AutoPairService.isConnected(device.address)) {
      return;
    }

    // Open detail screen which handles connection lifecycle
    if (_isScanning) {
      stopScan();
    }
    Navigator.push(
      context,
      MaterialPageRoute(
        builder: (context) => DeviceDetailScreen(device: device),
      ),
    ).then((_) {
      // Clean up states when returning from detail screen
      AutoPairService.setConnecting(device.address, false);
      AutoPairService.setConnected(device.address, false);
    });
  }
}

class DeviceDetailScreen extends StatefulWidget {
  final Device device;

  const DeviceDetailScreen({super.key, required this.device});

  @override
  State<DeviceDetailScreen> createState() => _DeviceDetailScreenState();
}

class _DeviceDetailScreenState extends State<DeviceDetailScreen>
    implements DeviceDelegate {
  /// Device information
  String _firmwareRevision = "Unknown";
  String _hardwareRevision = "Unknown";
  String _serialNumber = "Unknown";

  String _heartRate = "Unknown";
  String _skinTemperature = "Unknown";
  String _respirationRate = "Unknown";
  String _rr = "Unknown";
  String _activity = "Unknown";
  int _steps = 0;
  String _soundVolume = "Unknown";
  String _batteryLevel = "Unknown";
  String _signalQuality = "Unknown";
  String _bodyPosition = "Unknown";
  String _wearState = "Unknown";
  String _syncState = "Unknown";
  String _exercise = "Unknown";

  bool _isConnected = false;

  final List<double> _ecg = [];
  final List<double> _respiration = [];

  // Ensures UI leaves "Connecting..." as soon as we have proof of live data.
  void _ensureConnectedUi() {
    if (!_isConnected) {
      AutoPairService.setConnected(widget.device.address, true);
      AutoPairService.setConnecting(widget.device.address, false);
      setState(() {
        _isConnected = true;
      });
    }
  }

  /// Connect to device when the screen is created
  @override
  void initState() {
    super.initState();

    // Always try to connect - let the device handle if already connected
    AutoPairService.setConnecting(widget.device.address, true);

    try {
      widget.device.connect(this);
    } catch (e) {
      AutoPairService.setConnecting(widget.device.address, false);
      setState(() {
        _isConnected = false;
      });
    }
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text(_isConnected ? 'Connected Device' : 'Connecting...'),
        backgroundColor: _isConnected ? Colors.green : Colors.orange,
      ),
      body: Column(
        children: [
          Expanded(
            child: SingleChildScrollView(
              child: Column(
                children: [
                  ListTile(
                    title: const Text('Device Address'),
                    trailing: Text(widget.device.address),
                  ),
                  ListTile(
                    title: const Text('Device Name'),
                    trailing: Text(widget.device.name ?? "Unknown"),
                  ),
                  ListTile(
                    title: const Text('Firmware revision'),
                    trailing: Text(_firmwareRevision),
                  ),
                  ListTile(
                    title: const Text('Hardware revision'),
                    trailing: Text(_hardwareRevision),
                  ),
                  ListTile(
                    title: const Text('Serial number'),
                    trailing: Text(_serialNumber),
                  ),
                  ListTile(
                    title: const Text('Battery Level'),
                    trailing: Text(_batteryLevel),
                  ),
                  ListTile(
                    title: const Text('Signal Quality'),
                    trailing: Text(_signalQuality),
                  ),
                  ListTile(
                    title: const Text('Heart Rate'),
                    trailing: Text(_heartRate),
                  ),
                  ListTile(
                    title: const Text('Skin Temperature'),
                    trailing: Text(_skinTemperature),
                  ),
                  ListTile(
                    title: const Text('Respiration Rate'),
                    trailing: Text(_respirationRate),
                  ),
                  ListTile(
                    title: const Text('RR'),
                    trailing: Text(_rr),
                  ),
                  ListTile(
                    title: const Text('Activity'),
                    trailing: Text(_activity),
                  ),
                  ListTile(
                    title: const Text('Steps'),
                    trailing: Text(_steps.toString()),
                  ),
                  ListTile(
                    title: const Text('Sound Volume'),
                    trailing: Text(_soundVolume),
                  ),
                  ListTile(
                    title: const Text('Body Position'),
                    trailing: Text(_bodyPosition),
                  ),
                  ListTile(
                    title: const Text('Wear State'),
                    trailing: Text(_wearState),
                  ),
                  ListTile(
                    title: const Text('Sync State'),
                    trailing: Text(_syncState),
                  ),
                  ListTile(
                    title: const Text('Exercise'),
                    trailing: Text(_exercise),
                  ),
                  Padding(
                    padding: const EdgeInsets.all(8.0),
                    child: SizedBox(
                        width: MediaQuery.of(context).size.width,
                        height: 100,
                        child: LineChart(_ecg)),
                  ),
                  Padding(
                    padding: const EdgeInsets.all(8.0),
                    child: SizedBox(
                        width: MediaQuery.of(context).size.width,
                        height: 100,
                        child: LineChart(_respiration)),
                  ),
                ],
              ),
            ),
          ),
          // Always visible disconnect button at the bottom
          Container(
            width: double.infinity,
            padding: const EdgeInsets.all(16),
            color: Colors.red,
            child: ElevatedButton(
              onPressed: disconnect,
              style: ElevatedButton.styleFrom(
                backgroundColor: Colors.white,
                foregroundColor: Colors.red,
                padding: const EdgeInsets.symmetric(vertical: 12),
              ),
              child: Text(
                _isConnected ? 'DISCONNECT' : 'DISCONNECT & GO BACK',
                style:
                    const TextStyle(fontSize: 16, fontWeight: FontWeight.bold),
              ),
            ),
          ),
        ],
      ),
    );
  }

  @override
  void dispose() {
    super.dispose();
  }

  void disconnect() {
    widget.device.disconnect();

    // Immediately update local state
    AutoPairService.setConnected(widget.device.address, false);
    setState(() {
      _isConnected = false;
    });
  }

  @override
  void didConnect(Device device) {
    /// Update device information and connection state
    AutoPairService.setConnected(device.address, true);
    // Clear connecting state once we are connected to avoid stale UI status
    AutoPairService.setConnecting(device.address, false);

    setState(() {
      _isConnected = true;
      _firmwareRevision = device.firmwareRevision ?? "Unknown";
      _hardwareRevision = device.hardwareRevision ?? "Unknown";
      _serialNumber = device.serialNumber ?? "Unknown";
    });
    List<DataType> dataTypes = [
      DataType.ECG,
      DataType.RESPIRATION,
      DataType.SKIN_TEMPERATURE,
      DataType.ACTIVITY,
      DataType.STEPS,
      DataType.HEART_RATE,
      DataType.RR,
      // DataType.SOUND_VOLUME,
      DataType.RESPIRATION_RATE,
      DataType.BODY_POSITION,
      DataType.PRESSURE,
    ];

    device.collect(dataTypes, []);
  }

  @override
  void didDetectUserEvent(Device device, int timestamp) {}

  @override
  void didDisconnect(Device? device, DisconnectReason reason) {
    // Update connection state
    if (device != null) {
      AutoPairService.setConnected(device.address, false);
      // Ensure connecting flag is cleared on any disconnect
      AutoPairService.setConnecting(device.address, false);
    }

    setState(() {
      _isConnected = false;
    });

    // Show disconnect reason
    ScaffoldMessenger.of(context).showSnackBar(
      SnackBar(
          content: Text('Disconnected: ${reason.toString().split('.').last}')),
    );

    // Automatically go back to scanning screen
    Navigator.pop(context);
  }

  @override
  void didDetectExercise(Device device, Exercise exercise) {
    setState(() {
      _exercise = exercise.toString().split('.').last;
    });
  }

  @override
  void didReceiveAccelerometer(
      Device device, int timestamp, double ax, double ay, double az) {}

  @override
  void didReceiveActivity(Device device, int timestamp, ActivityType activity) {
    setState(() {
      _activity = activity.toString().split('.').last;
    });
  }

  @override
  void didReceiveBatteryLevel(Device device, int stateOfCharge) {
    setState(() {
      _batteryLevel = "$stateOfCharge%";
    });
  }

  @override
  void didReceiveBodyPosition(
      Device device, int timestamp, BodyPosition bodyPosition) {
    setState(() {
      _bodyPosition = bodyPosition.toString().split('.').last;
    });
  }

  @override
  void didReceiveCommand(Device device) {}

  @override
  void didReceiveECG(Device device, int timestamp, double value) {
    _ensureConnectedUi();
    setState(() {
      _ecg.add(value);
      while (_ecg.length > 500) {
        _ecg.removeAt(0);
      }
    });
  }

  @override
  void didReceiveError(String error) {
    // If connection error, clear connecting state
    if (error.toLowerCase().contains('connect') ||
        error.toLowerCase().contains('failed') ||
        error.toLowerCase().contains('timeout')) {
      AutoPairService.setConnecting(widget.device.address, false);
      setState(() {
        _isConnected = false;
      });
    }

    /// Show toast
    ScaffoldMessenger.of(context).showSnackBar(SnackBar(content: Text(error)));
  }

  @override
  void didReceiveGyroscope(
      Device device, int timestamp, double qx, double qy, double qz) {}

  @override
  void didReceiveHeartRate(Device device, int timestamp, int heartRate) {
    _ensureConnectedUi();
    setState(() {
      _heartRate = "$heartRate";
    });
  }

  @override
  void didReceiveMagnetometer(
      Device device, int timestamp, double mx, double my, double mz) {}

  @override
  void didReceiveMessage(Device device, String process, String message) {}

  @override
  void didReceiveOrientation(
      Device device, int timestamp, double roll, double pitch, double yaw) {}

  @override
  void didReceiveQuaternion(Device device, int timestamp, double qw, double qx,
      double qy, double qz) {}

  @override
  void didReceiveRespiration(Device device, int timestamp, double value) {
    _ensureConnectedUi();
    setState(() {
      _respiration.add(value);
      while (_respiration.length > 500) {
        _respiration.removeAt(0);
      }
    });
  }

  @override
  void didReceiveRespirationRate(Device device, int timestamp, int value) {
    _ensureConnectedUi();
    setState(() {
      _respirationRate = "$value";
    });
  }

  @override
  void didReceiveRr(Device device, int timestamp, int rr) {
    setState(() {
      _rr = "$rr";
    });
  }

  @override
  void didReceiveSignalQuality(Device device, int timestamp, int value) {
    _ensureConnectedUi();
    setState(() {
      _signalQuality = "$value";
    });
  }

  @override
  void didReceiveSkinTemperature(Device device, int timestamp, double value) {
    _ensureConnectedUi();
    setState(() {
      _skinTemperature = "${value.toStringAsFixed(1)} °C";
    });
  }

  @override
  void didReceiveSoundFeatures(
      Device device, int timestamp, List<double?> values) {}

  @override
  void didReceiveSoundVolume(Device device, int timestamp, int value) {
    setState(() {
      _soundVolume = "$value dB";
    });
  }

  @override
  void didReceiveSteps(Device device, int timestamp, int steps) {
    setState(() {
      _steps += steps;
    });
  }

  @override
  void didReceivePressure(Device device, int timestamp, int value) {}

  @override
  void didReceivePressureWearState(Device device, WearState wearState) {}

  @override
  void didReceiveUnsynchronizedSize(
      Device device, int unsynchronizedSize, double syncBytesPerSecond) {}

  @override
  void syncStateDidChange(Device device, SyncState state) {
    setState(() {
      _syncState = state.toString().split('.').last;
    });
  }

  @override
  void wearStateDidChange(Device device, WearState wearState) {
    setState(() {
      _wearState = wearState.toString().split('.').last;
    });
  }

  @override
  void didReceivePastAccelerometer(
      Device device, int timestamp, double ax, double ay, double az) {}

  @override
  void didReceivePastActivity(
      Device device, int timestamp, ActivityType activity) {}

  @override
  void didReceivePastBodyPosition(
      Device device, int timestamp, BodyPosition bodyPosition) {}

  @override
  void didReceivePastECG(Device device, int timestamp, double value) {}

  @override
  void didReceivePastGyroscope(
      Device device, int timestamp, double qx, double qy, double qz) {}

  @override
  void didReceivePastHeartRate(Device device, int timestamp, int heartRate) {}

  @override
  void didReceivePastMagnetometer(
      Device device, int timestamp, double mx, double my, double mz) {}

  @override
  void didReceivePastOrientation(
      Device device, int timestamp, double roll, double pitch, double yaw) {}

  @override
  void didReceivePastPressure(Device device, int timestamp, int values) {}

  @override
  void didReceivePastQuaternion(Device device, int timestamp, double qw,
      double qx, double qy, double qz) {}

  @override
  void didReceivePastRespiration(Device device, int timestamp, double value) {}

  @override
  void didReceivePastRespirationRate(Device device, int timestamp, int value) {}

  @override
  void didReceivePastRr(Device device, int timestamp, int rr) {}

  @override
  void didReceivePastSignalQuality(Device device, int timestamp, int value) {}

  @override
  void didReceivePastSkinTemperature(
      Device device, int timestamp, double value) {}

  @override
  void didReceivePastSoundFeatures(
      Device device, int timestamp, List<double?> values) {}

  @override
  void didReceivePastSoundVolume(
      Device device, int timestamp, int soundVolume) {}

  @override
  void didReceivePastSteps(Device device, int timestamp, int value) {}

  @override
  void didReceivePastUserEvent(Device device, int timestamp) {}
}