Serial

mobile/android/app/src/main/AndroidManifest.xml

@@ -33,9 +33,14 @@
               android:name="io.flutter.embedding.android.SplashScreenDrawable"
               android:resource="@drawable/launch_background"
               />
+            <meta-data
+              android:name="android.hardware.usb.action.USB_DEVICE_ATTACHED"
+		          android:resource="@xml/device_filter"
+            />
             <intent-filter>
                 <action android:name="android.intent.action.MAIN"/>
                 <category android:name="android.intent.category.LAUNCHER"/>
+                <action android:name="android.hardware.usb.action.USB_DEVICE_ATTACHED" />
             </intent-filter>
         </activity>
         <!-- Don't delete the meta-data below.

mobile/android/app/src/main/res/xml/device_filter.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+
+    <!-- 0x0403 / FTDI -->
+    <usb-device vendor-id="1027" />
+
+</resources>

mobile/lib/src/application/device/device_selector_cubit.dart

@@ -4,12 +4,15 @@ import 'package:bloc/bloc.dart';
 import 'package:flutter_bloc/flutter_bloc.dart';
 import 'package:polydodo/src/domain/acquisition_device/acquisition_device.dart';
 import 'package:polydodo/src/domain/acquisition_device/i_acquisition_device_repository.dart';
+import 'package:streaming_shared_preferences/streaming_shared_preferences.dart';
 import 'device_selector_state.dart';
 
 class DeviceSelectorCubit extends Cubit<DeviceState> {
   final IAcquisitionDeviceRepository _deviceRepository;
 
   StreamSubscription<List<AcquisitionDevice>> _acquisitionDeviceStream;
+  // todo: remove this variable, also test that switch works correctly once UI is done
+  bool usingBluetooth = true;
 
   DeviceSelectorCubit(this._deviceRepository) : super(DeviceInitial()) {
     startSearching();
@@ -47,4 +50,14 @@ class DeviceSelectorCubit extends Cubit<DeviceState> {
     _deviceRepository.disconnect();
     startSearching();
   }
+
+  // todo: change bluetooth preferences in the preference section of the app
+  void swapBluetooth() async {
+    print("swap");
+    usingBluetooth = !usingBluetooth;
+    StreamingSharedPreferences _prefs =
+        await StreamingSharedPreferences.instance;
+
+    _prefs.setBool('using_bluetooth', usingBluetooth);
+  }
 }

mobile/lib/src/application/eeg_data/data_cubit.dart

@@ -14,6 +14,7 @@ class DataCubit extends Cubit<DataState> {
 
   Future<void> startStreaming() async {
     emit(DataStateRecording());
+    _eegDataRepository.initialize();
     _eegDataRepository
         .createRecordingFromStream(await _deviceRepository.startDataStream());
   }

mobile/lib/src/domain/eeg_data/i_eeg_data_repository.dart

@@ -1,4 +1,5 @@
 abstract class IEEGDataRepository {
+  void initialize();
   void createRecordingFromStream(Stream<List<int>> stream);
   void stopRecordingFromStream();
 

mobile/lib/src/infrastructure/connection_repositories/acquisition_device_repository.dart

@@ -0,0 +1,72 @@
+import 'dart:async';
+
+import 'package:polydodo/src/domain/acquisition_device/acquisition_device.dart';
+import 'package:polydodo/src/domain/acquisition_device/i_acquisition_device_repository.dart';
+import 'package:polydodo/src/infrastructure/connection_repositories/bluetooth_repository.dart';
+import 'package:polydodo/src/infrastructure/connection_repositories/serial_repository.dart';
+import 'package:streaming_shared_preferences/streaming_shared_preferences.dart';
+
+class AcquisitionDeviceRepository implements IAcquisitionDeviceRepository {
+  final BluetoothRepository _bluetoothRepository = new BluetoothRepository();
+  final SerialRepository _serialRepository = new SerialRepository();
+  IAcquisitionDeviceRepository _currentRepository;
+
+  StreamSubscription _bluetoothStream;
+  StreamSubscription _serialStream;
+  StreamSubscription _currentStream;
+
+  StreamController<List<AcquisitionDevice>> _acquisitionDeviceController;
+  StreamingSharedPreferences _preferences;
+
+  AcquisitionDeviceRepository() {
+    _currentRepository = _serialRepository;
+    _acquisitionDeviceController = new StreamController();
+  }
+
+  Future<void> initializeRepository() async {
+    if (_preferences == null) {
+      _preferences = await StreamingSharedPreferences.instance;
+      _preferences
+          .getBool('using_bluetooth', defaultValue: false)
+          .listen((usingBluetooth) {
+        disconnect();
+        _currentStream.pause();
+        _currentRepository =
+            usingBluetooth ? _bluetoothRepository : _serialRepository;
+        _currentRepository.initializeRepository();
+        _currentStream = usingBluetooth ? _bluetoothStream : _serialStream;
+        _currentStream.resume();
+      });
+
+      _serialStream = _serialRepository.watch().listen((event) {
+        _acquisitionDeviceController.add(event);
+      });
+      _bluetoothStream = _bluetoothRepository.watch().listen((event) {
+        _acquisitionDeviceController.add(event);
+      });
+
+      _currentStream = _bluetoothStream;
+      _serialStream.pause();
+    }
+  }
+
+  void connect(AcquisitionDevice device, Function(bool, Exception) callback) {
+    _currentRepository.connect(device, callback);
+  }
+
+  void disconnect() {
+    _currentRepository.disconnect();
+  }
+
+  Future<Stream<List<int>>> startDataStream() {
+    return _currentRepository.startDataStream();
+  }
+
+  void stopDataStream() {
+    _currentRepository.stopDataStream();
+  }
+
+  Stream<List<AcquisitionDevice>> watch() {
+    return _acquisitionDeviceController.stream;
+  }
+}

mobile/lib/src/infrastructure/bluetooth_repository.dart → mobile/lib/src/infrastructure/connection_repositories/bluetooth_repository.dart

@@ -3,14 +3,13 @@ import 'dart:async';
 import 'package:flutter_reactive_ble/flutter_reactive_ble.dart';
 import 'package:polydodo/src/domain/acquisition_device/acquisition_device.dart';
 import 'package:polydodo/src/domain/acquisition_device/i_acquisition_device_repository.dart';
+import 'package:polydodo/src/infrastructure/constants.dart';
 import 'package:polydodo/src/domain/unique_id.dart';
 
 class BluetoothRepository implements IAcquisitionDeviceRepository {
   static const String BLE_SERVICE = "0000fe84-0000-1000-8000-00805f9b34fb";
   static const String BLE_RECEIVE = "2d30c082-f39f-4ce6-923f-3484ea480596";
   static const String BLE_SEND = "2d30c083-f39f-4ce6-923f-3484ea480596";
-  static const startStreamChar = 'b';
-  static const stopStreamChar = 's';
 
   AcquisitionDevice _selectedDevice;
   QualifiedCharacteristic _sendCharacteristic;
@@ -22,8 +21,6 @@ class BluetoothRepository implements IAcquisitionDeviceRepository {
   List<AcquisitionDevice> _acquisitionDevicePersistency = [];
   final streamController = StreamController<List<AcquisitionDevice>>();
 
-  BluetoothRepository();
-
   void initializeRepository() {
     if (_bluetoothScanSubscription == null) {
       flutterReactiveBle = FlutterReactiveBle();
@@ -32,6 +29,7 @@ class BluetoothRepository implements IAcquisitionDeviceRepository {
           withServices: []).listen((device) => addDevice(device));
     } else {
       _bluetoothScanSubscription.resume();
+      _acquisitionDevicePersistency.clear();
     }
   }
 
@@ -72,10 +70,8 @@ class BluetoothRepository implements IAcquisitionDeviceRepository {
   }
 
   void disconnect() async {
-    if (_selectedDevice != null) {
-      _selectedDevice = null;
-      _connectedDeviceStream.cancel();
-    }
+    _selectedDevice = null;
+    _connectedDeviceStream?.cancel();
   }
 
   void setupCharacteristics() async {
@@ -96,7 +92,7 @@ class BluetoothRepository implements IAcquisitionDeviceRepository {
         priority: ConnectionPriority.highPerformance);
 
     flutterReactiveBle.writeCharacteristicWithoutResponse(_sendCharacteristic,
-        value: startStreamChar.codeUnits);
+        value: START_STREAM_CHAR.codeUnits);
 
     return flutterReactiveBle.subscribeToCharacteristic(_receiveCharacteristic);
   }
@@ -106,7 +102,7 @@ class BluetoothRepository implements IAcquisitionDeviceRepository {
         deviceId: _selectedDevice.id.toString(),
         priority: ConnectionPriority.balanced);
     flutterReactiveBle.writeCharacteristicWithoutResponse(_sendCharacteristic,
-        value: stopStreamChar.codeUnits);
+        value: STOP_STREAM_CHAR.codeUnits);
   }
 
   @override

mobile/lib/src/infrastructure/connection_repositories/eeg_data_repository.dart

@@ -0,0 +1,72 @@
+import 'dart:async';
+import 'dart:io';
+import 'dart:typed_data';
+
+import 'package:csv/csv.dart';
+import 'package:path_provider/path_provider.dart';
+import 'package:polydodo/src/domain/eeg_data/eeg_data.dart';
+import 'package:polydodo/src/domain/eeg_data/i_eeg_data_repository.dart';
+import 'package:polydodo/src/domain/unique_id.dart';
+import 'package:polydodo/src/infrastructure/eeg_data_transformers/baseOpenBCITransformer.dart';
+import 'package:polydodo/src/infrastructure/eeg_data_transformers/cytonTransformer.dart';
+import 'package:polydodo/src/infrastructure/constants.dart';
+import 'package:polydodo/src/infrastructure/eeg_data_transformers/ganglionTransformer.dart';
+import 'package:streaming_shared_preferences/streaming_shared_preferences.dart';
+
+class EEGDataRepository implements IEEGDataRepository {
+  EEGData _recordingData;
+  BaseOpenBCITransformer<List<int>, List<dynamic>> currentStreamTransformer;
+
+  final GanglionTransformer<List<int>, List> _ganglionTransformer =
+      new GanglionTransformer<List<int>, List>.broadcast();
+
+  final CytonTransformer<List<int>, List<dynamic>> _cytonTransformer =
+      new CytonTransformer<Uint8List, List>.broadcast();
+
+  BaseOpenBCITransformer<List<int>, List<dynamic>> _currentTransformer;
+  StreamSubscription _currentTransformerStream;
+
+  StreamingSharedPreferences _preferences;
+
+  void initialize() async {
+    if (_preferences == null) {
+      _preferences = await StreamingSharedPreferences.instance;
+    }
+
+    _currentTransformer =
+        _preferences.getBool('using_bluetooth', defaultValue: false).getValue()
+            ? _ganglionTransformer
+            : _cytonTransformer;
+  }
+
+  void createRecordingFromStream(Stream<List<int>> stream) {
+    _recordingData =
+        EEGData(UniqueId.from(DateTime.now().toString()), List<List>());
+
+    _currentTransformer.reset();
+    _currentTransformerStream = stream
+        .asBroadcastStream()
+        .transform(_currentTransformer)
+        .listen((data) => _recordingData.values.add(data));
+  }
+
+  Future<void> stopRecordingFromStream() async {
+    // todo: move save future to another file
+    _currentTransformerStream.cancel();
+
+    final directory = await getExternalStorageDirectory();
+    final pathOfTheFileToWrite =
+        directory.path + '/' + _recordingData.fileName + ".txt";
+    File file = File(pathOfTheFileToWrite);
+    List<List> fileContent = [];
+    //todo: dynamically change header when we change transformer
+    fileContent.addAll(OPEN_BCI_CYTON_HEADER);
+    fileContent.addAll(_recordingData.values);
+    String csv = const ListToCsvConverter().convert(fileContent);
+    await file.writeAsString(csv);
+  }
+
+  // todo: implement export and import
+  void importData() {}
+  void exportData() {}
+}

mobile/lib/src/infrastructure/connection_repositories/serial_repository.dart

@@ -0,0 +1,69 @@
+import 'dart:async';
+import 'dart:typed_data';
+
+import 'package:polydodo/src/domain/unique_id.dart';
+import 'package:polydodo/src/domain/acquisition_device/acquisition_device.dart';
+import 'package:polydodo/src/domain/acquisition_device/i_acquisition_device_repository.dart';
+import 'package:polydodo/src/infrastructure/constants.dart';
+import 'package:usb_serial/usb_serial.dart';
+
+class SerialRepository implements IAcquisitionDeviceRepository {
+  UsbDevice _selectedDevice;
+  UsbPort _serialPort;
+  List<AcquisitionDevice> _acquisitionDevicePersistency = [];
+  List<UsbDevice> _serialDevices = [];
+  final streamController = StreamController<List<AcquisitionDevice>>();
+
+  void initializeRepository() {
+    _acquisitionDevicePersistency.clear();
+    _serialDevices.clear();
+    UsbSerial.listDevices().then((devices) => addDevices(devices));
+  }
+
+  void addDevices(List<UsbDevice> serialDevices) {
+    for (UsbDevice serialDevice in serialDevices) {
+      AcquisitionDevice device = AcquisitionDevice(
+          UniqueId.from(serialDevice.deviceId.toString()),
+          serialDevice.productName);
+
+      _acquisitionDevicePersistency.add(device);
+      _serialDevices.add(serialDevice);
+    }
+    streamController.add(_acquisitionDevicePersistency);
+  }
+
+  Future<void> connect(
+      AcquisitionDevice device, Function(bool, Exception) callback) async {
+    _selectedDevice =
+        _serialDevices[_acquisitionDevicePersistency.indexOf(device)];
+    _serialPort = await _selectedDevice.create();
+    bool openSuccessful = await _serialPort.open();
+
+    if (!openSuccessful) {
+      callback(false, Exception("Could not open port"));
+    }
+
+    _serialPort.setPortParameters(
+        115200, UsbPort.DATABITS_8, UsbPort.STOPBITS_1, UsbPort.PARITY_NONE);
+
+    callback(true, null);
+  }
+
+  Future<void> disconnect() async {
+    await _serialPort?.close();
+    _selectedDevice = null;
+    _serialPort = null;
+  }
+
+  Future<Stream<List<int>>> startDataStream() async {
+    await _serialPort.write(Uint8List.fromList(START_STREAM_CHAR.codeUnits));
+
+    return _serialPort.inputStream;
+  }
+
+  Future<void> stopDataStream() async {
+    await _serialPort.write(Uint8List.fromList(STOP_STREAM_CHAR.codeUnits));
+  }
+
+  Stream<List<AcquisitionDevice>> watch() => streamController.stream;
+}