feat: Added next gen profile

Author: samruddhi-Rahegaonkar

lib/bademagic_module/bluetooth/completed_state.dart

@@ -1,10 +1,18 @@
 import 'package:badgemagic/bademagic_module/bluetooth/base_ble_state.dart';
+import 'package:badgemagic/bademagic_module/bluetooth/datagenerator.dart';
 
 class CompletedState extends NormalBleState {
   final bool isSuccess;
   final String message;
+  final TransferMode? mode;
+  final bool shouldDisconnect;
 
-  CompletedState({required this.isSuccess, required this.message});
+  CompletedState({
+    required this.isSuccess,
+    required this.message,
+    this.mode,
+    this.shouldDisconnect = false,
+  });
 
   @override
   Future<BleState?> processState() async {
@@ -13,6 +21,7 @@ class CompletedState extends NormalBleState {
     } else {
       toast.showErrorToast(message);
     }
+
     return null;
   }
 }

lib/bademagic_module/bluetooth/connect_state.dart

@@ -1,47 +1,39 @@
+import 'package:badgemagic/bademagic_module/bluetooth/base_ble_state.dart';
+import 'package:badgemagic/bademagic_module/bluetooth/completed_state.dart';
 import 'package:badgemagic/bademagic_module/bluetooth/datagenerator.dart';
 import 'package:badgemagic/bademagic_module/bluetooth/write_state.dart';
 import 'package:flutter_blue_plus/flutter_blue_plus.dart';
-import 'base_ble_state.dart';
 
-class ConnectState extends RetryBleState {
+class ConnectState extends NormalBleState {
   final ScanResult scanResult;
   final DataTransferManager manager;
 
-  ConnectState({required this.manager, required this.scanResult});
+  ConnectState({required this.scanResult, required this.manager});
 
   @override
   Future<BleState?> processState() async {
-    try {
-      try {
-        await scanResult.device.disconnect();
-        logger.d("Pre-emptive disconnect for clean state");
-        await Future.delayed(const Duration(seconds: 1));
-      } catch (_) {
-        logger.d("No existing connection to disconnect");
-      }
-
-      await scanResult.device.connect(autoConnect: false);
-      BluetoothConnectionState connectionState =
-          await scanResult.device.connectionState.first;
+    BluetoothDevice device = scanResult.device;
+    manager.connectedDevice = device;
 
-      if (connectionState == BluetoothConnectionState.connected) {
-        logger.d("Device connected successfully");
-        toast.showToast('Device connected successfully.');
+    try {
+      toast.showToast("Connecting to ${device.platformName}...");
+      logger.d("Attempting to connect to ${device.platformName}...");
 
-        manager.connectedDevice = scanResult.device;
+      await device.connect(autoConnect: false);
+      await Future.delayed(const Duration(milliseconds: 500));
 
-        final writeState = WriteState(
-          device: scanResult.device,
-          manager: manager,
-        );
+      logger.d("Connected to device: ${device.platformName}");
+      toast.showToast("Connected to ${device.platformName}");
 
-        return await writeState.process();
-      } else {
-        throw Exception("Failed to connect to the device");
-      }
+      return WriteState(manager: manager, device: device);
     } catch (e) {
-      toast.showErrorToast('Failed to connect. Retrying...');
-      rethrow;
+      logger.e("Connection failed: $e");
+      return CompletedState(
+        isSuccess: false,
+        message: "Failed to connect to device. Please retry.",
+        mode: manager.mode,
+        shouldDisconnect: true, // ensure cleanup
+      );
     }
   }
 }

lib/bademagic_module/bluetooth/datagenerator.dart

@@ -1,30 +1,170 @@
+// Enhanced DataTransferManager with streaming support
+import 'dart:async';
 import 'package:badgemagic/bademagic_module/models/data.dart';
 import 'package:badgemagic/bademagic_module/utils/data_to_bytearray_converter.dart';
 import 'package:badgemagic/bademagic_module/utils/file_helper.dart';
 import 'package:badgemagic/providers/badge_message_provider.dart';
 import 'package:badgemagic/providers/imageprovider.dart';
 import 'package:flutter_blue_plus/flutter_blue_plus.dart';
 import 'package:get_it/get_it.dart';
+import 'package:logger/logger.dart';
+
+enum TransferMode { legacy, streaming }
 
 class DataTransferManager {
-  final Data data;
+  final Data? data; // Make nullable for streaming-only usage
+  TransferMode mode;
 
   BluetoothDevice? connectedDevice;
 
+  // Legacy characteristics
+  BluetoothCharacteristic? legacyWriteCharacteristic;
+
+  // Streaming characteristics
+  BluetoothCharacteristic? streamingWriteCharacteristic;
+  BluetoothCharacteristic? streamingNotifyCharacteristic;
+  StreamSubscription<List<int>>? notificationSubscription;
+
   final BadgeMessageProvider badgeData = BadgeMessageProvider();
   final DataToByteArrayConverter converter = DataToByteArrayConverter();
   final FileHelper fileHelper = FileHelper();
   final InlineImageProvider controllerData =
       GetIt.instance<InlineImageProvider>();
+  final Logger logger = Logger();
+
+  bool isStreamingActive = false;
+
+  DataTransferManager(this.data, {this.mode = TransferMode.legacy});
+
+  // Factory constructors for convenience
+  factory DataTransferManager.forLegacy(Data data) =>
+      DataTransferManager(data, mode: TransferMode.legacy);
 
-  DataTransferManager(this.data);
+  factory DataTransferManager.forStreaming(Data data) =>
+      DataTransferManager(null, mode: TransferMode.streaming);
 
   Future<List<List<int>>> generateDataChunk() async {
-    return converter.convert(data);
+    if (data == null) throw Exception("No data provided for legacy transfer");
+    return converter.convert(data!);
   }
 
-  /// Helper to clear the currently connected device.
+  /// Clear the currently connected device and cleanup
   void clearConnectedDevice() {
     connectedDevice = null;
+    legacyWriteCharacteristic = null;
+    streamingWriteCharacteristic = null;
+    streamingNotifyCharacteristic = null;
+    notificationSubscription?.cancel();
+    notificationSubscription = null;
+    isStreamingActive = false;
+  }
+
+  /// Handle error codes from streaming badge
+  void handleStreamingErrorCode(int errorCode) {
+    switch (errorCode) {
+      case 0x00:
+        logger.d("Streaming command executed successfully");
+        break;
+      case 0xff:
+        logger.e("Streaming parameters out of range");
+        break;
+      case 0xfe:
+        logger.e("Height larger than maximum allowed");
+        break;
+      case 0xfd:
+        logger.e("Message length not matched");
+        break;
+      case 0xfc:
+        logger.e("Missing pixel contents");
+        break;
+      case 0x01:
+        logger.e("Flash writing error");
+        break;
+      case 0x02:
+        logger.e("Speed/brightness out of range");
+        break;
+      default:
+        logger.e("Unknown streaming error code: $errorCode");
+    }
+  }
+
+  /// Stream bitmap data (for streaming mode)
+  Future<bool> streamBitmap(List<int> bitmap) async {
+    if (!isStreamingActive || streamingWriteCharacteristic == null) {
+      logger.e("Streaming not active or characteristic unavailable");
+      return false;
+    }
+
+    try {
+      List<int> command = [0x03]; // stream_bitmap function code
+
+      // Convert bitmap to 16-bit words (little-endian)
+      for (int column in bitmap) {
+        command.add(column & 0xFF);
+        command.add((column >> 8) & 0xFF);
+      }
+
+      await streamingWriteCharacteristic!
+          .write(command, withoutResponse: false);
+      logger.d("Bitmap streamed successfully, ${bitmap.length} columns");
+      return true;
+    } catch (e) {
+      logger.e("Failed to stream bitmap: $e");
+      return false;
+    }
+  }
+
+  /// Enter streaming mode
+  Future<bool> enterStreamingMode() async {
+    if (streamingWriteCharacteristic == null) return false;
+
+    try {
+      List<int> command = [0x02, 0x00]; // Enter streaming mode
+      await streamingWriteCharacteristic!
+          .write(command, withoutResponse: false);
+      await Future.delayed(const Duration(milliseconds: 100));
+      isStreamingActive = true;
+      return true;
+    } catch (e) {
+      logger.e("Failed to enter streaming mode: $e");
+      return false;
+    }
+  }
+
+  /// Exit streaming mode
+  Future<bool> exitStreamingMode() async {
+    if (streamingWriteCharacteristic == null) return false;
+
+    try {
+      List<int> command = [0x02, 0x01]; // Exit streaming mode
+      await streamingWriteCharacteristic!
+          .write(command, withoutResponse: false);
+      isStreamingActive = false;
+      return true;
+    } catch (e) {
+      logger.e("Failed to exit streaming mode: $e");
+      return false;
+    }
+  }
+
+  /// Convert 2D bitmap to column format for streaming
+  List<int> convertBitmapToColumns(List<List<bool>> bitmap) {
+    if (bitmap.isEmpty) return [];
+
+    int height = bitmap.length;
+    int width = bitmap[0].length;
+    List<int> columns = [];
+
+    for (int col = 0; col < width; col++) {
+      int columnValue = 0;
+      for (int row = 0; row < height && row < 16; row++) {
+        if (bitmap[row][col]) {
+          columnValue |= (1 << row);
+        }
+      }
+      columns.add(columnValue);
+    }
+
+    return columns;
   }
 }

lib/bademagic_module/bluetooth/scan_state.dart

@@ -14,32 +14,39 @@ class ScanState extends NormalBleState {
     manager.clearConnectedDevice();
     await FlutterBluePlus.stopScan();
 
-    toast.showToast("Searching for device...");
+    String searchMessage = manager.mode == TransferMode.streaming
+        ? "Searching for streaming device..."
+        : "Searching for device...";
+    toast.showToast(searchMessage);
+
     Completer<BleState?> nextStateCompleter = Completer();
     StreamSubscription<List<ScanResult>>? subscription;
-
     bool isCompleted = false;
+
     try {
       subscription = FlutterBluePlus.scanResults.listen(
         (results) async {
           if (isCompleted || results.isEmpty) return;
 
           try {
             final foundDevice = results.firstWhere(
-              (r) => r.advertisementData.serviceUuids.contains(
-                Guid("0000fee0-0000-1000-8000-00805f9b34fb"),
-              ),
-              orElse: () => throw Exception("Matching device not found."),
+              (r) => _deviceSupportsRequiredMode(r, manager.mode),
+              orElse: () => throw Exception("Compatible device not found."),
             );
 
             isCompleted = true;
             await FlutterBluePlus.stopScan();
-            toast.showToast('Device found. Connecting...');
+
+            String foundMessage = manager.mode == TransferMode.streaming
+                ? 'Streaming device found. Connecting...'
+                : 'Device found. Connecting...';
+            toast.showToast(foundMessage);
+
             nextStateCompleter.complete(
               ConnectState(scanResult: foundDevice, manager: manager),
             );
           } catch (_) {
-            // Ignore and keep scanning
+            // keep scanning until timeout
           }
         },
         onError: (e) {
@@ -55,22 +62,16 @@ class ScanState extends NormalBleState {
         },
       );
 
+      // Start scan with proper services
+      List<Guid> services = _getServicesForMode(manager.mode);
       await FlutterBluePlus.startScan(
-        withServices: [Guid("0000fee0-0000-1000-8000-00805f9b34fb")],
+        withServices: services,
         removeIfGone: const Duration(seconds: 5),
         continuousUpdates: true,
         timeout: const Duration(seconds: 15),
       );
 
-      await Future.delayed(const Duration(seconds: 1));
-
-      if (!isCompleted) {
-        isCompleted = true;
-        FlutterBluePlus.stopScan();
-        toast.showErrorToast('Device not found.');
-        nextStateCompleter.completeError(Exception('Device not found.'));
-      }
-
+      // Instead of 1s fixed delay, let the scan timeout handle completion
       return await nextStateCompleter.future;
     } catch (e) {
       logger.e("Exception during scanning: $e");
@@ -80,4 +81,39 @@ class ScanState extends NormalBleState {
       await FlutterBluePlus.stopScan();
     }
   }
+
+  bool _deviceSupportsRequiredMode(ScanResult result, TransferMode mode) {
+    List<Guid> serviceUuids = result.advertisementData.serviceUuids;
+
+    switch (mode) {
+      case TransferMode.legacy:
+        return serviceUuids
+            .contains(Guid("0000fee0-0000-1000-8000-00805f9b34fb"));
+      case TransferMode.streaming:
+        // Prefer next-gen service, fallback to legacy
+        if (serviceUuids
+            .contains(Guid("0000f055-0000-1000-8000-00805f9b34fb"))) {
+          return true; // ✅ streaming
+        }
+        if (serviceUuids
+            .contains(Guid("0000fee0-0000-1000-8000-00805f9b34fb"))) {
+          logger.w("Streaming service not found, falling back to legacy.");
+          manager.mode = TransferMode.legacy; // switch mode internally
+          return true;
+        }
+        return false;
+    }
+  }
+
+  List<Guid> _getServicesForMode(TransferMode mode) {
+    switch (mode) {
+      case TransferMode.legacy:
+        return [Guid("0000fee0-0000-1000-8000-00805f9b34fb")];
+      case TransferMode.streaming:
+        return [
+          Guid("0000f055-0000-1000-8000-00805f9b34fb"), // next-gen
+          Guid("0000fee0-0000-1000-8000-00805f9b34fb"), // legacy fallback
+        ];
+    }
+  }
 }