Merge branch 'development' into issue#1268

Author: samruddhi-Rahegaonkar

assets/animations/ic_anim_animation.gif

@@ -11,48 +11,37 @@ class ConnectState extends RetryBleState {
 
   @override
   Future<BleState?> processState() async {
-    bool connected = false;
-
     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;
 
       if (connectionState == BluetoothConnectionState.connected) {
-        connected = true;
-
-        logger.d("Device connected");
+        logger.d("Device connected successfully");
         toast.showToast('Device connected successfully.');
 
-        final writeState =
-            WriteState(device: scanResult.device, manager: manager);
-        final result = await writeState.process();
-        try {
-          await scanResult.device.disconnect();
-          logger.d("Device disconnected after transfer");
-          await Future.delayed(const Duration(seconds: 1));
-          logger.d("Waited 1s after disconnect");
-        } catch (e) {
-          logger.e("Error during disconnect after transfer: $e");
-        }
-        return result;
+        manager.connectedDevice = scanResult.device;
+
+        final writeState = WriteState(
+          device: scanResult.device,
+          manager: manager,
+        );
+
+        return await writeState.process();
       } else {
         throw Exception("Failed to connect to the device");
       }
     } catch (e) {
-      toast.showErrorToast('Failed to connect retrying...');
+      toast.showErrorToast('Failed to connect. Retrying...');
       rethrow;
-    } finally {
-      if (!connected) {
-        try {
-          await scanResult.device.disconnect();
-          logger.d("Device disconnected in finally block");
-          await Future.delayed(const Duration(seconds: 1));
-          logger.d("Waited 1s after disconnect (finally)");
-        } catch (e) {
-          logger.e("Error during disconnect in finally: $e");
-        }
-      }
     }
   }
 }

assets/animations/ic_anim_picture.gif

@@ -3,20 +3,28 @@ import 'package:badgemagic/bademagic_module/utils/data_to_bytearray_converter.da
 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';
 
 class DataTransferManager {
   final Data data;
-  //make it singleton
 
-  DataTransferManager(this.data);
+  BluetoothDevice? connectedDevice;
 
   final BadgeMessageProvider badgeData = BadgeMessageProvider();
-  DataToByteArrayConverter converter = DataToByteArrayConverter();
-  FileHelper fileHelper = FileHelper();
-  InlineImageProvider controllerData = GetIt.instance<InlineImageProvider>();
+  final DataToByteArrayConverter converter = DataToByteArrayConverter();
+  final FileHelper fileHelper = FileHelper();
+  final InlineImageProvider controllerData =
+      GetIt.instance<InlineImageProvider>();
+
+  DataTransferManager(this.data);
 
   Future<List<List<int>>> generateDataChunk() async {
     return converter.convert(data);
   }
+
+  /// Helper to clear the currently connected device.
+  void clearConnectedDevice() {
+    connectedDevice = null;
+  }
 }

assets/animations/ic_anim_snowflake.gif

@@ -2,74 +2,82 @@ import 'dart:async';
 import 'package:badgemagic/bademagic_module/bluetooth/connect_state.dart';
 import 'package:badgemagic/bademagic_module/bluetooth/datagenerator.dart';
 import 'package:flutter_blue_plus/flutter_blue_plus.dart';
-
 import 'base_ble_state.dart';
 
 class ScanState extends NormalBleState {
   final DataTransferManager manager;
+
   ScanState({required this.manager});
 
   @override
   Future<BleState?> processState() async {
-    StreamSubscription<List<ScanResult>>? subscription;
-    toast.showToast("Searching for device...");
+    manager.clearConnectedDevice();
+    await FlutterBluePlus.stopScan();
 
+    toast.showToast("Searching for device...");
     Completer<BleState?> nextStateCompleter = Completer();
-    bool isCompleted = false;
-
-    ScanResult? foundDevice;
+    StreamSubscription<List<ScanResult>>? subscription;
 
+    bool isCompleted = false;
     try {
       subscription = FlutterBluePlus.scanResults.listen(
         (results) async {
-          if (!isCompleted) {
-            if (results.isNotEmpty) {
-              foundDevice = results.firstWhere(
-                (result) => result.advertisementData.serviceUuids
-                    .contains(Guid("0000fee0-0000-1000-8000-00805f9b34fb")),
-              );
-              if (foundDevice != null) {
-                toast.showToast('Device found. Connecting...');
-                isCompleted = true;
-                nextStateCompleter.complete(ConnectState(
-                  scanResult: foundDevice!,
-                  manager: manager,
-                ));
-              }
-            }
+          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."),
+            );
+
+            isCompleted = true;
+            await FlutterBluePlus.stopScan();
+            toast.showToast('Device found. Connecting...');
+            nextStateCompleter.complete(
+              ConnectState(scanResult: foundDevice, manager: manager),
+            );
+          } catch (_) {
+            // Ignore and keep scanning
           }
         },
-        onError: (e) async {
+        onError: (e) {
           if (!isCompleted) {
             isCompleted = true;
+            FlutterBluePlus.stopScan();
             logger.e("Scan error: $e");
             toast.showErrorToast('Scan error occurred.');
-            nextStateCompleter.completeError(e);
+            nextStateCompleter.completeError(
+              Exception("Error during scanning: $e"),
+            );
           }
         },
       );
 
       await FlutterBluePlus.startScan(
         withServices: [Guid("0000fee0-0000-1000-8000-00805f9b34fb")],
-        removeIfGone: Duration(seconds: 5),
+        removeIfGone: const Duration(seconds: 5),
         continuousUpdates: true,
-        timeout: const Duration(seconds: 15), // Reduced scan timeout
+        timeout: const Duration(seconds: 15),
       );
 
       await Future.delayed(const Duration(seconds: 1));
 
-      // If no device is found after the scan timeout, complete with an error.
       if (!isCompleted) {
-        toast.showToast('Device not found.');
+        isCompleted = true;
+        FlutterBluePlus.stopScan();
+        toast.showErrorToast('Device not found.');
         nextStateCompleter.completeError(Exception('Device not found.'));
       }
 
       return await nextStateCompleter.future;
     } catch (e) {
       logger.e("Exception during scanning: $e");
-      throw Exception("please check the device is turned on and retry.");
+      throw Exception("Please check if the device is turned on and retry.");
     } finally {
       await subscription?.cancel();
+      await FlutterBluePlus.stopScan();
     }
   }
 }

lib/bademagic_module/bluetooth/connect_state.dart

@@ -27,16 +27,19 @@ class WriteState extends NormalBleState {
               for (int attempt = 1; attempt <= 3; attempt++) {
                 try {
                   await characteristic.write(chunk, withoutResponse: false);
+                  logger.d("Chunk written successfully: $chunk");
                   success = true;
                   break;
                 } catch (e) {
-                  logger.e("Write failed, retrying ($attempt/3): $e");
+                  logger.e("Write failed (attempt $attempt/3): $e");
                 }
               }
               if (!success) {
                 throw Exception("Failed to transfer data. Please try again.");
               }
+              await Future.delayed(Duration(milliseconds: 50));
             }
+
             logger.d("Characteristic written successfully");
             return CompletedState(
                 isSuccess: true, message: "Data transferred successfully");

lib/bademagic_module/bluetooth/datagenerator.dart

@@ -7,22 +7,25 @@ class Message {
   final bool marquee;
   final Speed speed;
   final Mode mode;
+  final int? animationIndex; // 👈 NEW
 
   Message({
     required this.text,
     this.flash = false,
     this.marquee = false,
-    this.speed = Speed.one, // Default speed
-    this.mode = Mode.left, // Default mode
+    this.speed = Speed.one,
+    this.mode = Mode.left,
+    this.animationIndex, // 👈 NEW
   });
 
   // Convert Message object to JSON
   Map<String, dynamic> toJson() => {
         'text': text,
         'flash': flash,
         'marquee': marquee,
-        'speed': speed.hexValue, // Use hexValue for serialization
-        'mode': mode.hexValue, // Use hexValue for serialization
+        'speed': speed.hexValue,
+        'mode': mode.hexValue,
+        if (animationIndex != null) 'animationIndex': animationIndex, // 👈 NEW
       };
 
   // Convert JSON to Message object
@@ -52,10 +55,9 @@ class Message {
       text: List<String>.from(textList),
       flash: (json['flash'] as bool?) ?? false,
       marquee: (json['marquee'] as bool?) ?? false,
-      speed: Speed.fromHex(
-          json['speed'] as String), // Using helper method for safety
-      mode: Mode.fromHex(
-          json['mode'] as String), // Using helper method for safety
+      speed: Speed.fromHex(json['speed'] as String),
+      mode: Mode.fromHex(json['mode'] as String),
+      animationIndex: json['animationIndex'] as int?, // 👈 NEW
     );
   }
 }

lib/bademagic_module/bluetooth/scan_state.dart

@@ -4,26 +4,27 @@ enum Mode {
   up('0x02'),
   down('0x03'),
   fixed('0x04'),
-  snowflake('0x05'),
-  picture('0x06'),
-  animation('0x07'),
+  animation('0x05'),
+  snowflake('0x06'),
+  picture('0x07'),
   laser('0x08');
 
   final String hexValue;
   const Mode(this.hexValue);
 
-  //method to get the integer value of the mode
   static int getIntValue(Mode mode) {
-    String hexValue = mode.hexValue.substring(3, 4);
-    int intValue = int.parse(hexValue, radix: 10);
-    return intValue;
+    return int.parse(mode.hexValue.substring(2), radix: 16);
   }
 
-  // Helper method to safely parse hex value
   static Mode fromHex(String hexValue) {
     return Mode.values.firstWhere(
       (mode) => mode.hexValue == hexValue,
-      orElse: () => Mode.left, // Default to Mode.left if no match
+      orElse: () => Mode.left,
     );
   }
+
+  static Mode fromInt(int value) {
+    final hex = value.toRadixString(16).padLeft(2, '0');
+    return fromHex('0x$hex');
+  }
 }

lib/bademagic_module/bluetooth/write_state.dart

@@ -4,61 +4,26 @@ class AniAnimation extends BadgeAnimation {
   @override
   void processAnimation(int badgeHeight, int badgeWidth, int animationIndex,
       List<List<bool>> processGrid, List<List<bool>> canvas) {
-    int newWidth = processGrid[0].length;
-    int newHeight = processGrid.length;
-    int verticalOffset = (badgeHeight - newHeight) ~/ 2;
-    int displayWidth = newWidth > badgeWidth ? badgeWidth : newWidth;
-    int horizontalOffset = (badgeWidth - displayWidth) ~/ 2;
-    var totalAnimationLength = badgeWidth;
-    int frame = animationIndex % totalAnimationLength;
-    var firstHalf = frame < badgeWidth ~/ 2;
-    var secondHalf = frame >= badgeWidth ~/ 2;
-
+    int newGridHeight = processGrid.length;
+    int newGridWidth = processGrid[0].length;
     for (int i = 0; i < badgeHeight; i++) {
       for (int j = 0; j < badgeWidth; j++) {
-        bool lineShow = false;
-        bool bitmapShowcenter = false;
-        bool bitmapShowOut = false;
-
-        int sourceRow = i - verticalOffset;
-        int sourceCol = j - horizontalOffset;
-
-        bool isWithinNewGrid = sourceRow >= 0 &&
-            sourceRow < newHeight &&
-            sourceCol >= 0 &&
-            sourceCol < displayWidth;
-
-        int leftCenterCol = badgeWidth ~/ 2 - 1;
-        int rightCenterCol = badgeWidth ~/ 2;
-
-        int maxDistance = leftCenterCol;
-
-        int currentAnimationIndex = animationIndex % (maxDistance + 1);
+        // Calculate the total number of frames that fit the badge width
+        int framesCount = (newGridWidth / badgeWidth).ceil();
 
-        int leftColPos = leftCenterCol - currentAnimationIndex;
-        int rightColPos = rightCenterCol + currentAnimationIndex;
+        // Determine the current frame based on the animation value
+        int currentcountFrame = animationIndex ~/ badgeWidth % framesCount;
 
-        if (leftColPos < 0) leftColPos += badgeWidth;
-        if (rightColPos >= badgeWidth) rightColPos -= badgeWidth;
+        // Calculate the starting column for the current frame in newGrid
+        int startCol = currentcountFrame * badgeWidth;
 
-        if (j == leftColPos || j == rightColPos) {
-          lineShow = true;
-        } else {
-          lineShow = false;
-        }
+        bool isNewGridCell = i < newGridHeight && (startCol + j) < newGridWidth;
 
-        if (firstHalf) {
-          if (isWithinNewGrid && j > leftColPos && j < rightColPos) {
-            bitmapShowcenter = processGrid[sourceRow][sourceCol];
-          }
-        }
-        if (secondHalf) {
-          if (isWithinNewGrid && (j < leftColPos || j > rightColPos)) {
-            bitmapShowOut = processGrid[sourceRow][sourceCol];
-          }
-        }
+        // Update the grid based on the current frame's data
+        bool animationCondition =
+            (isNewGridCell && processGrid[i][startCol + j]);
 
-        canvas[i][j] = (lineShow || bitmapShowOut || bitmapShowcenter);
+        canvas[i][j] = animationCondition;
       }
     }
   }