fix: updated the logics

Author: samruddhi-Rahegaonkar

lib/bademagic_module/bluetooth/base_ble_state.dart

@@ -18,15 +18,18 @@ abstract class NormalBleState extends BleState {
       return await processState();
     } on Exception catch (e) {
       String errorMessage = e.toString().replaceFirst('Exception: ', '');
-      return CompletedState(isSuccess: false, message: errorMessage);
+      return CompletedState(
+        isSuccess: false,
+        message: errorMessage,
+        shouldDisconnect: true, // Always disconnect on errors
+      );
     }
   }
 }
 
 abstract class RetryBleState extends BleState {
   final logger = Logger();
   final toast = ToastUtils();
-
   final _maxRetries = 3;
 
   Future<BleState?> processState();
@@ -43,6 +46,7 @@ abstract class RetryBleState extends BleState {
         logger.e(e);
         lastException = e;
         attempt++;
+
         if (attempt < _maxRetries) {
           logger.d("Retrying ($attempt/$_maxRetries)...");
         } else {
@@ -53,9 +57,10 @@ abstract class RetryBleState extends BleState {
       }
     }
 
-    // After max retries, return a CompletedState indicating failure.
     return CompletedState(
-        isSuccess: false,
-        message: lastException?.toString() ?? "Unknown error");
+      isSuccess: false,
+      message: lastException?.toString() ?? "Unknown error",
+      shouldDisconnect: true, // Always disconnect after max retries
+    );
   }
 }

lib/bademagic_module/bluetooth/completed_state.dart

@@ -6,16 +6,40 @@ class CompletedState extends NormalBleState {
   final String message;
   final TransferMode? mode;
   final bool shouldDisconnect;
+  final DataTransferManager? manager; // Add manager reference
 
   CompletedState({
     required this.isSuccess,
     required this.message,
     this.mode,
     this.shouldDisconnect = false,
+    this.manager, // Add manager parameter
   });
 
   @override
   Future<BleState?> processState() async {
+    // Handle disconnection if required
+    if (shouldDisconnect && manager?.connectedDevice != null) {
+      try {
+        logger.d("Disconnecting device as requested...");
+
+        // For streaming mode, exit streaming first
+        if (mode == TransferMode.streaming && manager!.isStreamingActive) {
+          await manager!.exitStreamingMode();
+          await Future.delayed(const Duration(milliseconds: 200));
+        }
+
+        await manager!.connectedDevice!.disconnect();
+        await Future.delayed(const Duration(milliseconds: 700));
+        manager!.clearConnectedDevice();
+
+        logger.d("Device disconnected successfully");
+      } catch (e) {
+        logger.e("Error during disconnection: $e");
+      }
+    }
+
+    // Show user feedback
     if (isSuccess) {
       toast.showToast(message);
     } else {

lib/bademagic_module/bluetooth/connect_state.dart

@@ -32,7 +32,8 @@ class ConnectState extends NormalBleState {
         isSuccess: false,
         message: "Failed to connect to device. Please retry.",
         mode: manager.mode,
-        shouldDisconnect: true, // ensure cleanup
+        shouldDisconnect: true,
+        manager: manager, // Add this line
       );
     }
   }

lib/bademagic_module/bluetooth/datagenerator.dart

@@ -1,8 +1,9 @@
-// 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/bademagic_module/utils/converters.dart';
+import 'package:badgemagic/bademagic_module/utils/byte_array_utils.dart';
 import 'package:badgemagic/providers/badge_message_provider.dart';
 import 'package:badgemagic/providers/imageprovider.dart';
 import 'package:flutter_blue_plus/flutter_blue_plus.dart';
@@ -12,7 +13,7 @@ import 'package:logger/logger.dart';
 enum TransferMode { legacy, streaming }
 
 class DataTransferManager {
-  final Data? data; // Make nullable for streaming-only usage
+  final Data? data;
   TransferMode mode;
 
   BluetoothDevice? connectedDevice;
@@ -30,19 +31,96 @@ class DataTransferManager {
   final FileHelper fileHelper = FileHelper();
   final InlineImageProvider controllerData =
       GetIt.instance<InlineImageProvider>();
+  final Converters _converters = Converters();
   final Logger logger = Logger();
 
   bool isStreamingActive = false;
 
+  // NEW: Streaming state management
+  Map<String, dynamic>? _pendingStreamData;
+  bool _isStreamingReady = false;
+
   DataTransferManager(this.data, {this.mode = TransferMode.legacy});
 
   // Factory constructors for convenience
   factory DataTransferManager.forLegacy(Data data) =>
       DataTransferManager(data, mode: TransferMode.legacy);
-
-  factory DataTransferManager.forStreaming(Data data) =>
+  factory DataTransferManager.forStreaming() =>
       DataTransferManager(null, mode: TransferMode.streaming);
 
+  // NEW: Store parameters for streaming use after connection
+  void setPendingStreamData(Map<String, dynamic> streamData) {
+    _pendingStreamData = streamData;
+    logger.d("Stored pending stream data: ${streamData.keys}");
+  }
+
+  Map<String, dynamic> getPendingStreamData() {
+    return _pendingStreamData ?? {};
+  }
+
+  // NEW: Check if streaming connection is established and ready
+  bool isStreamingConnectionReady() {
+    return _isStreamingReady &&
+        connectedDevice != null &&
+        streamingWriteCharacteristic != null &&
+        isStreamingActive;
+  }
+
+  // NEW: Mark streaming as ready (called from WriteState)
+  void setStreamingReady(bool ready) {
+    _isStreamingReady = ready;
+    logger.d("Streaming ready state: $ready");
+  }
+
+  // NEW: Process the actual streaming content using your Converters
+  Future<bool> processStreamingContent() async {
+    if (_pendingStreamData == null) {
+      logger.e("No pending stream data");
+      return false;
+    }
+
+    try {
+      Map<String, dynamic> params = _pendingStreamData!;
+      logger.i("Processing streaming content: '${params['text']}'");
+
+      String text = params['text'] ?? "";
+      if (text.isEmpty) {
+        logger.w("Empty text for streaming");
+        return false;
+      }
+
+      // Use your existing Converters class for text to hex conversion
+      List<String> hexStrings =
+          await _converters.messageTohex(text, params['isInverted'] ?? false);
+
+      if (hexStrings.isEmpty) {
+        logger.w("No hex data generated for streaming");
+        return false;
+      }
+
+      logger.d("Generated ${hexStrings.length} hex strings for streaming");
+
+      // Convert hex to bitmap using your existing utility
+      List<List<bool>> bitmap = hexStringToBool(hexStrings.join());
+
+      // Convert bitmap to column format for streaming
+      List<int> columns = convertBitmapToColumns(bitmap);
+
+      logger.i("Streaming ${columns.length} columns");
+
+      // Stream the bitmap
+      bool success = await streamBitmap(columns);
+
+      // Clear pending data after processing
+      _pendingStreamData = null;
+
+      return success;
+    } catch (e) {
+      logger.e("Error processing streaming content: $e");
+      return false;
+    }
+  }
+
   Future<List<List<int>>> generateDataChunk() async {
     if (data == null) throw Exception("No data provided for legacy transfer");
     return converter.convert(data!);
@@ -57,6 +135,8 @@ class DataTransferManager {
     notificationSubscription?.cancel();
     notificationSubscription = null;
     isStreamingActive = false;
+    _isStreamingReady = false;
+    _pendingStreamData = null;
   }
 
   /// Handle error codes from streaming badge
@@ -88,14 +168,16 @@ class DataTransferManager {
     }
   }
 
-  /// Stream bitmap data (for streaming mode)
+  /// Stream bitmap data (enhanced with better logging)
   Future<bool> streamBitmap(List<int> bitmap) async {
     if (!isStreamingActive || streamingWriteCharacteristic == null) {
       logger.e("Streaming not active or characteristic unavailable");
       return false;
     }
 
     try {
+      logger.i("Streaming bitmap with ${bitmap.length} columns");
+
       List<int> command = [0x03]; // stream_bitmap function code
 
       // Convert bitmap to 16-bit words (little-endian)
@@ -104,26 +186,41 @@ class DataTransferManager {
         command.add((column >> 8) & 0xFF);
       }
 
+      logger.d("Sending ${command.length} bytes to streaming characteristic");
+
       await streamingWriteCharacteristic!
           .write(command, withoutResponse: false);
-      logger.d("Bitmap streamed successfully, ${bitmap.length} columns");
+
+      // Wait for processing
+      await Future.delayed(const Duration(milliseconds: 200));
+
+      logger.i("Bitmap streamed successfully, ${bitmap.length} columns");
       return true;
     } catch (e) {
       logger.e("Failed to stream bitmap: $e");
       return false;
     }
   }
 
-  /// Enter streaming mode
+  /// Enter streaming mode (enhanced)
   Future<bool> enterStreamingMode() async {
-    if (streamingWriteCharacteristic == null) return false;
+    if (streamingWriteCharacteristic == null) {
+      logger.e("Streaming write characteristic not available");
+      return false;
+    }
 
     try {
+      logger.i("Entering streaming mode...");
+
       List<int> command = [0x02, 0x00]; // Enter streaming mode
       await streamingWriteCharacteristic!
           .write(command, withoutResponse: false);
-      await Future.delayed(const Duration(milliseconds: 100));
+
+      // Wait for device to enter streaming mode
+      await Future.delayed(const Duration(milliseconds: 200));
+
       isStreamingActive = true;
+      logger.i("Successfully entered streaming mode");
       return true;
     } catch (e) {
       logger.e("Failed to enter streaming mode: $e");
@@ -136,10 +233,18 @@ class DataTransferManager {
     if (streamingWriteCharacteristic == null) return false;
 
     try {
+      logger.i("Exiting streaming mode...");
+
       List<int> command = [0x02, 0x01]; // Exit streaming mode
       await streamingWriteCharacteristic!
           .write(command, withoutResponse: false);
+
+      await Future.delayed(const Duration(milliseconds: 100));
+
       isStreamingActive = false;
+      _isStreamingReady = false;
+
+      logger.i("Successfully exited streaming mode");
       return true;
     } catch (e) {
       logger.e("Failed to exit streaming mode: $e");

lib/bademagic_module/bluetooth/write_state.dart

@@ -61,7 +61,8 @@ class WriteState extends NormalBleState {
             isSuccess: true,
             message: "Data transferred successfully",
             mode: TransferMode.legacy,
-            shouldDisconnect: true, // ✅ disconnect after legacy
+            shouldDisconnect: true,
+            manager: manager, // Add this line
           );
         }
       }
@@ -129,11 +130,16 @@ class WriteState extends NormalBleState {
 
     if (success) {
       logger.d("Streaming mode activated successfully");
+
+      // CRITICAL: Mark streaming as ready for content processing
+      manager.setStreamingReady(true);
+
       return CompletedState(
         isSuccess: true,
-        message: "Streaming mode activated. Ready to stream bitmaps.",
+        message: "Streaming mode activated. Processing content...",
         mode: TransferMode.streaming,
-        shouldDisconnect: false, // ✅ stay connected for streaming
+        shouldDisconnect: false, // Keep connection alive
+        manager: manager,
       );
     } else {
       throw Exception("Failed to activate streaming mode");

lib/providers/animation_badge_provider.dart

@@ -322,6 +322,7 @@ class AnimationBadgeProvider extends ChangeNotifier {
       logger.i(
           "Starting streaming transfer with aniIndex=$aniIndex, speed=$selectedSpeed");
 
+      // ✅ CRITICAL FIX: Use useStreaming parameter, not isSavedBadge
       await badgeData.checkAndTransfer(
         inlineImageProvider.getController().text,
         flash,
@@ -330,13 +331,13 @@ class AnimationBadgeProvider extends ChangeNotifier {
         selectedSpeed,
         modeValueMap[aniIndex],
         null,
-        true, // 🚨 IMPORTANT: mark streaming = true
+        false, // ✅ isSavedBadge should be false for new transfers
+        useStreaming: true, // ✅ THIS is the correct streaming parameter
       );
-
-      ToastUtils().showToast("Streaming transfer started");
     } catch (e) {
-      logger.e("Error in handleStreamingTransfer");
-      ToastUtils().showErrorToast("Streaming transfer failed: $e");
+      logger.e("Error in handleStreamingTransfer: $e");
+      ToastUtils().showErrorToast("❌ Streaming transfer failed: $e");
+      rethrow;
     }
   }
 }