img.Image? letter = await helper.generateImage(
      const TextSpan(
        text: "test",
        style: TextStyle(fontSize: 24, color: Colors.black),
      ),
      size: size * 8,
    );

    await label.printLabel(
      [letter],
      printer: printer,
      labelSize: const Size(10, 10),
      spacing: 0,
      rotate: false,
    ).then((value) {
      printing = false;
      emit(LabelPrinterPrintingDone(allowPrinting: state.allowPrinting));
    });
  }

import 'dart:async';
import 'dart:math';
import 'package:flutter/foundation.dart';
import 'package:flutter_blue_plus/flutter_blue_plus.dart';

enum BluetoothOptions {
  SEARCHING,
  CONNECTING,
  CONNECTED,
  RECEIVED_SERVICES,
  DISCONNECTED,
  DATA_RECEIVED,
  STOP_SEARCHING
}

typedef BluetoothCallback = void Function(BluetoothOptions options);

class Bluetooth {
  Bluetooth({
    required this.onUpdate,
    required this.names,
    required this.deviceChange,
  }) {
    _startScan();
    FlutterBluePlus.adapterState.listen((state) {
      _updateAdapterState(state);
      _startScan();
    });
  }
  final List<String> names;
  late BluetoothCallback onUpdate;
  final Function(BluetoothDevice? device) deviceChange;
  BluetoothDevice? selectedDevice;
  List<BluetoothCharacteristic>? characteristics;
  BluetoothAdapterState adapterState = BluetoothAdapterState.on;
  bool scanning = false;
  bool get isScanning => scanning;

  void _updateAdapterState(BluetoothAdapterState state) {
    adapterState = state;
    if (adapterState == BluetoothAdapterState.on) {
      _startScan();
    }
  }

  void _startScan() async {
    if (!isScanning && adapterState == BluetoothAdapterState.on) {
      onUpdate(BluetoothOptions.SEARCHING);
      scanning = true;
      await FlutterBluePlus.startScan(timeout: const Duration(seconds: 15));

      StreamSubscription<List<ScanResult>>? scanSubscription;

      scanSubscription = FlutterBluePlus.scanResults.listen(
        (results) {
          if (results.isNotEmpty) {
            _processScanResult(results);
          }
        },
        onError: (e, stackTrace) {},
        onDone: () {
          // scanSubscription?.cancel();
          // scanning = false;
          // onUpdate(BluetoothOptions.STOP_SEARCHING);
        },
      );

      Future.delayed(const Duration(minutes: 2), () {
        if (scanning) {
          _stopScan("Timeout");
        }
      });
    }
  }

  void _stopScan(String reason) {
    scanning = false;
    // onUpdate(BluetoothOptions.STOP_SEARCHING);
    FlutterBluePlus.stopScan();
  }

  void _processScanResult(List<ScanResult> scanResult) {
    for (var result in scanResult) {
      if (names.isNotEmpty &&
          result.device.platformName.trim().isNotEmpty &&
          names.contains(result.device.platformName)) {
        _connect(result.device);
        _stopScan("Connecting");
        break;
      }
    }
  }

  void _connect(BluetoothDevice device) {
    onUpdate(BluetoothOptions.CONNECTING);
    selectedDevice = device;
    deviceChange(selectedDevice);

    if (kDebugMode) {
      print(selectedDevice!.platformName);
    }
    device.connect(mtu: null).then((_) {
      onUpdate(BluetoothOptions.CONNECTED);
      _discoverServices();
    });
  }

  void _handleNotificationData(List<int> data) {
    print('Received data =======> ${data.toString()}');
  }

  void _discoverServices() async {
    if (selectedDevice != null) {
      List<BluetoothService> services =
          await selectedDevice!.discoverServices();
      if (services.isNotEmpty) {
        for (var service in services) {
          characteristics = service.characteristics;
          for (var characteristic in service.characteristics) {
            if (characteristic.properties.notify) {
              characteristic.setNotifyValue(true);
              characteristic.lastValueStream.listen(_handleNotificationData,
                  onError: (error) {
                print('Received data =======> ${error.toString()}');
              });
              break;
            }
          }
        }
        onUpdate(BluetoothOptions.RECEIVED_SERVICES);
      }
    }
  }

  void _readCharacteristic() async {
    BluetoothCharacteristic? toSend;
    for (var char in characteristics!) {
      if (char.properties.notify) {
        toSend = char;
      }
    }
    List<int> value = await toSend!.read();
  }

  void readBluetoothData() {
    _readCharacteristic();
  }

  Future<List<int>> read() async {
    BluetoothCharacteristic? toSend;
    for (var char in characteristics!) {
      if (char.properties.notify) {
        toSend = char;
      }
    }
    return await toSend!.read();
  }

  Future<void> write(List<int> data) async {
    BluetoothCharacteristic? toSend;
    for (var char in characteristics!) {
      if (char.properties.write) {
        toSend = char;
      }
    }

    await toSend!.write("HHH".codeUnits,
        withoutResponse: true, allowLongWrite: false, timeout: 200000);
  }

  void destroy() {
    FlutterBluePlus.stopScan();
  }
}