README.md

 
 ## Getting Started
 
-This project is a starting point for a Flutter
-[plug-in package](https://flutter.dev/developing-packages/),
-a specialized package that includes platform-specific implementation code for
-Android and/or iOS.
-
-For help getting started with Flutter development, view the
-[online documentation](https://flutter.dev/docs), which offers tutorials,
-samples, guidance on mobile development, and a full API reference.
+Add `flutter_zsdk` as a dependency in your `pubspec.yaml` file.
+
+## Project Setup
+
+### Android
+note: tested using `JDK 17.0.2`, `Gradle 8.0`, `AGP 8.1.3`
+
+Tambah / ganti `distributionUrl=https\://services.gradle.org/distributions/gradle-8.0-bin.zip` di android/gradle/wrapper/gradle-wrapper.properties.
+
+Tambah / ganti `id "com.android.application" version "8.1.3" apply false` di android/settings.gradle.
+
+Tambah ke file `gradle.properties`.
+```
+org.gradle.jvmargs=-Xmx4G
+android.useAndroidX=true
+android.enableJetifier=true
+android.jetifier.ignorelist=jackson-core-2.17.2.jar
+```
+
+## Usage
+Contoh lengkap bisa dilihat di `example` folder.  
+
+Pertama buat objek dari plugin
+```
+import 'package:flutter_zsdk/flutter_zsdk.dart';
+
+final _flutterZsdkPlugin = FlutterZsdk();
+
+_flutterZsdk.findBluetoothPrinter();
+// etc
+```
+
+### Discover Bluetooth Device
+Return nilai dari `_flutterZsdkPlugin.findBluetoothPrinter()` itu `Stream<dynamic>` jadi perlu di handle untuk listen ke stream tsb.
+
+Default event:
+- `SOS` : Start of Stream
+- `EOS` : End of Stream (`StreamSubscription` harus di cancel jika tidak diperlukan lagi)
+
+contoh:
+```
+Future<void> discoverBluetoothDevices() async {
+    try {
+      Stream<dynamic> stream = await _flutterZsdkPlugin.findBluetoothPrinters();
+      _bluetoothPrinterSubscription = stream.listen((event) {
+        print(event);
+
+        if (event == 'SOS') {
+          _isDiscovering = true;
+
+        }
+
+        if (event is List) {
+          // add to list logic here...
+
+        }
+
+        if (event == 'EOS') {
+          _isDiscovering = false;
+          showSnackBar('Bluetooth discovery finished, found ${_discoveredBluetoothPrinters.length} printers');
+          _bluetoothPrinterSubscription?.cancel();
+        }
+
+        setState(() {});
+      });
+    
+    } on PlatformException catch (e) {
+      showSnackBar(e.message.toString());
+
+    } on FlutterZsdkException catch (e) { 
+      showSnackBar(e.message);
+
+    } catch (e) {
+      showSnackBar('Unexpected error while discovering bluetooth printers');
+
+    }
+  }
+  ```
+
+
+### Connect to Printer
+Gunakan `_flutterZsdkPlugin.openConnection(<Mac Address>)`, dimana `<Mac Address>` bisa didapatkan dari `.findBluetoothPrinter()`
+
+disarankan `.closeConnection()` sebelum melakukan connect ke printer lain. walaupun sudah dihandle disisi plugin.
+
+### Send ZPL Data to Printer (Print ZPL)
+sebelum print, check dulu koneksi ke printer, utk memastikan printer terkoneksi.
+
+`_flutterZsdkPlugin.isConnected()` utk check koneksi ke printer.
+
+jika sudah terkoneksi, gunakan `_flutterZsdkPlugin.printZplOverBluetooth(<zpl_data>)` untuk mengirim data ZPL ke printer.
+
+
+### Disconnect from Printer
+`_flutterZsdkPlugin.closeConnection()` utk disconnect dari printer.
+
+</br>
+
+
+note: 
+- semua aksi harus dipanggil dalam try-catch block
+- `_flutterZsdkPlugin.isConnected()` hanya harus dipanggil setelah `_flutterZsdkPlugin.openConnection()` jika tidak app bisa crash (tested ANDROID)

android/src/main/java/id/kalanusa/flutter_zsdk/FlutterZsdkPlugin.java

 import id.kalanusa.flutter_zsdk.bluetoothconnectionhandler.BluetoothConnectionHolder;
 import id.kalanusa.flutter_zsdk.bluetoothdiscoveryhandler.BluetoothDiscoveryHandler;
 import id.kalanusa.flutter_zsdk.bluetoothdiscoveryhandler.BluetoothPrinter;
+import id.kalanusa.flutter_zsdk.zplprinthandler.ZplPrintHandler;
 import io.flutter.Log;
 import io.flutter.embedding.engine.dart.DartExecutor;
 import io.flutter.embedding.engine.plugins.FlutterPlugin;
   private MethodChannel channel;
   private Context context;
   private Activity activity;
-  private ArrayList<BluetoothPrinter> discoveredPrinterList = new ArrayList<BluetoothPrinter>();
   public static final String bluetoothDiscoveryEventChannel = "id.kalanusa.flutter_zsdk.channel_events/bluetooth_discovery";
-  private EventChannel.EventSink attachEvent;
-  private Handler handler;
   private DartExecutor dartExecutor;
   private BinaryMessenger binaryMessenger;
 
   public BluetoothConnectionHolder bluetoothConnectionHolder;
 
   public BluetoothConnectionHandler bluetoothConnectionHandler;
+  public ZplPrintHandler zplPrintHandler;
 
 
   @Override
     dartExecutor = Objects.requireNonNull(flutterPluginBinding.getFlutterEngine()).getDartExecutor();
     binaryMessenger = dartExecutor.getBinaryMessenger();
 
+
+    bluetoothConnectionHolder = new BluetoothConnectionHolder(null);
   }
 
   @Override
 
   @Override
   public void onMethodCall(@NonNull MethodCall call, @NonNull Result result) {
-    Log.w("From Native (Android)", "ini di FLutterZsdkPlugin");
+    Log.w("From Native (Android)", "ini di FlutterZsdkPlugin");
 
     switch(call.method) {
       case "bluetoothOpenConnection":
       case "isConnected":
       case "bluetoothCloseConnection":
         if (bluetoothConnectionHandler == null) {
-          bluetoothConnectionHandler = new BluetoothConnectionHandler(bluetoothConnectionHolder);
+          bluetoothConnectionHandler = new BluetoothConnectionHandler();
         }
 
         bluetoothConnectionHandler.handle(call, result);
         break;
 
+      case "printZplOverBluetooth":
+        if (zplPrintHandler == null) {
+          zplPrintHandler = new ZplPrintHandler();
+        }
+
+        zplPrintHandler.handle(call, result);
+        break;
     }
   }
 

android/src/main/java/id/kalanusa/flutter_zsdk/bluetoothconnectionhandler/BluetoothConnectionHandler.java

 import io.flutter.plugin.common.MethodChannel;
 
 public class BluetoothConnectionHandler {
-    BluetoothConnectionHolder bluetoothConnectionHolder;
-    String macAddress;
-
-    public BluetoothConnectionHandler(BluetoothConnectionHolder bluetoothConnectionHolder) {
-        this.bluetoothConnectionHolder = bluetoothConnectionHolder;
-    }
 
     public void handle(@NonNull MethodCall call, @NonNull MethodChannel.Result result) {
 
         switch (call.method) {
             case "bluetoothOpenConnection":
-                if (bluetoothConnectionHolder == null) {
-                    bluetoothConnectionHolder = new BluetoothConnectionHolder(new BluetoothConnectionInsecure(call.argument("macAddress")));
+                String macAddressArgument = call.argument("macAddress");
+
+                if (BluetoothConnectionHolder.connection != null) {
+                    String connectionInfo = BluetoothConnectionHolder.connection.getSimpleConnectionName();
+                    String currentConnectionMacAddress = connectionInfo.substring(0, 17);
+
+                    if (!currentConnectionMacAddress.equals(macAddressArgument)) {
+                        closeAndReopenConnection(result, macAddressArgument);
+
+                    } else {
+                        openConnection(result);
+
+                    }
+
+                    break;
                 }
 
-                openConnection(result);
+                if (BluetoothConnectionHolder.connection == null) {
+                    BluetoothConnectionHolder.updateConnection(new BluetoothConnectionInsecure(macAddressArgument));
+
+                    openConnection(result);
+
+                }
                 break;
 
             case "isConnected":
             public void run() {
                 try {
                     Looper.prepare();
-                    bluetoothConnectionHolder.connection.open();
+                    BluetoothConnectionHolder.connection.open();
                     Looper.myLooper().quit();
                     result.success(null);
                     Log.w("From Native (Android)", "open connection finished");
         }).start();
     }
 
+    public void closeAndReopenConnection(@NonNull MethodChannel.Result result, String newMacAddress) {
+        new Thread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    Looper.prepare();
+                    BluetoothConnectionHolder.connection.close();
+                    BluetoothConnectionHolder.updateConnection(new BluetoothConnectionInsecure(newMacAddress));
+                    BluetoothConnectionHolder.connection.open();
+                    Looper.myLooper().quit();
+                    result.success(null);
+                    Log.w("From Native (Android)", "close and reopen connection finished");
+                } catch (ConnectionException e) {
+                    Log.w("From Native (Android)", "Connection Exception threw " + e);
+                    result.error("CLOSE_AND_REOPEN_CONNECTION_ERROR", "Cant close and connect to new printers", e.getMessage());
+                }
+            }
+        }).start();
+    }
+
     public void checkConnection(@NonNull MethodChannel.Result result) {
         new Thread(new Runnable() {
             @Override
             public void run() {
-                boolean isConnected = bluetoothConnectionHolder.connection.isConnected();
+//                BluetoothConnectionHolder.getSimpleConnectionName();
+                try {
+                    boolean isConnected = BluetoothConnectionHolder.connection.isConnected();
+
+                    result.success(isConnected);
 
-                result.success(isConnected);
+                    Log.w("From Native (Android)", "isConnected: " + isConnected);
+                } catch (Exception e) {
+                    Log.w("From Native (Android)", "Cant get connection status");
+                    Log.w("From Native (Android)", e.getClass().toString());
+                    Log.w("From Native (Android)", "is exception nullPointerException: " + (e.getClass() == NullPointerException.class));
 
-                Log.w("From Native (Android)", "isConnected: " + isConnected);
+                    if (e.getClass() == NullPointerException.class) {
+                        result.error("CONNECTION_HAS_NOT_BEEN_ESTABLISHED", "Cant get connection status, establish connection first", e.getCause());
+                    } else {
+                        result.error("CHECK_CONNECTION_ERROR", "Cant get connection status", e.getMessage());
+                    }
+                }
             }
         }).start();
     }
             @Override
             public void run() {
                 try {
-                    bluetoothConnectionHolder.connection.close();
+                    BluetoothConnectionHolder.connection.close();
+                    BluetoothConnectionHolder.connection = null;
                     result.success(null);
                 } catch (ConnectionException e) {
                     Log.w("From Native (Android)", "something went wrong when closing connection");

android/src/main/java/id/kalanusa/flutter_zsdk/bluetoothconnectionhandler/BluetoothConnectionHolder.java

 
 import com.zebra.sdk.comm.Connection;
 
+import io.flutter.Log;
+
 public class BluetoothConnectionHolder {
-    public Connection connection;
+    static public Connection connection;
 
     public BluetoothConnectionHolder(@NonNull Connection connection) {
         this.connection = connection;
     }
 
-    public void updateConnection(@NonNull Connection connection) {
-        this.connection = connection;
+    static public void updateConnection(@NonNull Connection connection) {
+        BluetoothConnectionHolder.connection = connection;
+    }
+
+    static public void getSimpleConnectionName() {
+        String simpleConnectionName = BluetoothConnectionHolder.connection.getSimpleConnectionName();
+        String macAddressFromSimpleConnectionName = simpleConnectionName.substring(0, 17);
+
+
+        Log.w("From Native (Android)", "SimpleConnectioName: " + BluetoothConnectionHolder.connection.getSimpleConnectionName());
+        Log.w("From Native (Android)", "MacAddressFromSimpleConnectionName: " + macAddressFromSimpleConnectionName);
     }
 }

android/src/main/java/id/kalanusa/flutter_zsdk/zplprinthandler/ZplPrintHandler.java

+package id.kalanusa.flutter_zsdk.zplprinthandler;
+
+import androidx.annotation.NonNull;
+
+import com.zebra.sdk.comm.ConnectionException;
+
+import id.kalanusa.flutter_zsdk.bluetoothconnectionhandler.BluetoothConnectionHandler;
+import id.kalanusa.flutter_zsdk.bluetoothconnectionhandler.BluetoothConnectionHolder;
+import io.flutter.Log;
+import io.flutter.plugin.common.MethodCall;
+import io.flutter.plugin.common.MethodChannel;
+
+public class ZplPrintHandler {
+
+    public void handle(@NonNull MethodCall call, @NonNull MethodChannel.Result result) {
+        printZplOverBluetooth(result, call.argument("zplData"));
+    }
+
+
+    public void printZplOverBluetooth(@NonNull MethodChannel.Result result, String zplData) {
+        new Thread(new Runnable() {
+            @Override
+            public void run() {
+//                Log.w("From Native (Android)", "isConnected from zplPrinterHandler " + BluetoothConnectionHolder.connection.isConnected() );
+                try {
+//                    String zplData = "^XA^PW624^LL800^FO20,20^A0N,25,25^FDThis is a ZPL test.^FS^FO20,60^BQ , 60,10 , , , A ^FD 1234ABC.^FS^XZ";
+                    BluetoothConnectionHolder.connection.write(zplData.getBytes());
+                } catch (ConnectionException e) {
+                    Log.w("From Native (Android)", "something went wrong when sending data to printer");
+                    result.error("WRITE_ERROR", "Something went wrong when sending data to printer", e.getMessage());
+                }
+            }
+        }).start();
+    }
+}

example/lib/main.dart

     setState(() {});
   }
 
+  Future<void> printZplOverBluetooth() async {
+    print('invoked printZplOverBluetooth from dart');
+    try {
+      await _flutterZsdkPlugin.printZplOverBluetooth("^XA^PW624^LL800^FO20,20^A0N,25,25^FDThis is a ZPL test.^FS^FO20,60^BQ ,2,10 , , , A ^FDQA,http://192.168.102.170:4218/?q=IDC4C321S023^FS^^FO20,500^A0N,25,25^FDDart Zpl Test.^FS^XZ");
+      print('printZplOverBluetooth successfully from dart');
+      
+    } on FlutterZsdkException catch (e) {
+      inspect(e);
+      showSnackBar(e.message);
+
+    } catch (e) {
+      inspect(e);
+      showSnackBar('Unexpected error when send data to printers');
+    }
+
+    setState(() {});
+  }
+
+  Future<void> checkConnectionStatus() async {
+    print('invoked checkConnectionStatus from dart');
+    try{
+      bool isConnected = await _flutterZsdkPlugin.isConnected();
+              
+      print('isConnected from dart: $isConnected');
+    } on FlutterZsdkException catch (e) {
+      inspect(e);
+      showSnackBar(e.message.toString());
+    } catch (e) {
+      inspect(e);
+      showSnackBar('Unexpected error while checking connection status');
+    }
+  }
+
   @override
   Widget build(BuildContext context) {
     return Scaffold(
         
             ElevatedButton(
               child: Text('Connect to $_selectedBluetoothPrinterMacAddress'),
-              onPressed: _selectedBluetoothPrinterMacAddress == null || _connectedPrinter != null ? null : openConnection,
+              onPressed: _selectedBluetoothPrinterMacAddress == null ? null : openConnection,
             ),
             SizedBox(height: 20),
 
             ),
             SizedBox(height: 20),
 
+            ElevatedButton(
+              child: Text('Print zpl over bluetooth'),
+              onPressed: _connectedPrinter == null ? null : printZplOverBluetooth,
+            ),
+            SizedBox(height: 20),
+
             ElevatedButton(
               child: Text('Check connection status'),
-              onPressed: () async {
-                bool isConnected =await _flutterZsdkPlugin.isConnected();
-              
-                print('isConnected from dart: $isConnected');
-              },
+              onPressed: checkConnectionStatus,
             ),
             SizedBox(height: 20),
             

lib/flutter_zsdk.dart

   Future<void> closeConnection() {
     return FlutterZsdkPlatform.instance.closeConnection();
   }
+
+  Future<void> printZplOverBluetooth(String zplData) {
+    return FlutterZsdkPlatform.instance.printZplOverBluetooth(zplData);
+  }
 }

lib/src/flutter_zsdk_method_channel.dart

 import 'package:flutter/services.dart';
 import 'package:flutter_blue_plus/flutter_blue_plus.dart';
 import 'package:flutter_zsdk/src/models/bluetooth_printer.dart';
+import 'package:flutter_zsdk/src/models/error_code.dart';
 import 'package:flutter_zsdk/src/models/flutter_zsdk_exception.dart';
 import 'package:permission_handler/permission_handler.dart';
 
     //   print(event);
     // });
     if (!await FlutterBluePlus.isSupported) {
-      throw FlutterZsdkException("Bluetooth is not supported on this device.");
+      throw FlutterZsdkException(ErrorCode.bluetoothIsNotSupported, "Bluetooth is not supported on this device.");
     }
 
 
         try {
           await FlutterBluePlus.turnOn();
         } on FlutterBluePlusException catch (e) {
-          throw FlutterZsdkException("Failed to turn on bluetooth: ${e.description}");
+          throw FlutterZsdkException(ErrorCode.turnOnBluetoothError, "Failed to turn on bluetooth: ${e.description}");
         }
       } else {
-        throw FlutterZsdkException("Bluetooth is not turned on on this device.");
+        throw FlutterZsdkException(ErrorCode.bluetoothDisabled, "Bluetooth is not turned on on this device.");
       }
     }
 
         return bluetoothDiscoveryEventChannel.receiveBroadcastStream();
       } else {
         // throw Exception("Permissions not granted, please allow permission to discover bluetooth printers.");
-        throw FlutterZsdkException("Permissions not granted, please allow permission to discover bluetooth printers.");
+        throw FlutterZsdkException(ErrorCode.permissionNotGranted, "Permissions not granted, please allow permission to discover bluetooth printers.");
       }
 
     } else {
 
     } on PlatformException catch (e) {
       inspect(e);
-      throw FlutterZsdkException("Failed to open connection to printer: ${e.details}");
+      throw FlutterZsdkException(e.code, "Failed to open connection to printer: ${e.details}");
 
     } catch (e) {
-      throw FlutterZsdkException("Failed to open connection to printer: $e");
+      throw FlutterZsdkException(ErrorCode.unexpectedError, "Message: $e");
     }
   }
 
   @override
   Future<bool> isConnected() async {
-    bool isConnected = await methodChannel.invokeMethod('isConnected');
+    try {
+      bool isConnected = await methodChannel.invokeMethod('isConnected');
+      return isConnected;
+    } on PlatformException catch (e) {
+      throw FlutterZsdkException(e.code, "Failed to check connection , message: ${e.details}");
+    } catch (e) {
+      throw FlutterZsdkException(ErrorCode.unexpectedError, "Message: $e");
+    }
 
-    return isConnected;
   }
 
   @override
   Future<void> closeConnection() async {
     try {
       await methodChannel.invokeMethod('bluetoothCloseConnection');
+    } on PlatformException catch (e) {
+      inspect(e);
+      throw FlutterZsdkException(e.code, "Failed to close connection, message: ${e.details}");
+    } catch (e) {
+      throw FlutterZsdkException(ErrorCode.unexpectedError, "Message: $e");
+    }
+  }
+
+  @override
+  Future<void> printZplOverBluetooth(String zplData) async {
+    try {
+      await methodChannel.invokeMethod('printZplOverBluetooth', {'zplData': zplData});
+    } on PlatformException catch (e) {
+      inspect(e);
+      throw FlutterZsdkException(e.code, "Failed to print ZPL over Bluetooth, message: ${e.details}");
     } catch (e) {
-      throw FlutterZsdkException("Failed to close connection to printer: $e");
+      throw FlutterZsdkException(ErrorCode.unexpectedError, "Message: $e");
     }
   }
 }

lib/src/flutter_zsdk_platform_interface.dart

   Future<void> closeConnection() {
     throw UnimplementedError('closeConnection() has not been implemented.');
   }
+
+  Future<void> printZplOverBluetooth(String zplData) {
+    throw UnimplementedError('printZplOverBluetooth() has not been implemented.');
+  }
 }

lib/src/models/error_code.dart

+class ErrorCode {
+  static const String permissionNotGranted = "PERMISSION_NOT_GRANTED";
+  static const String turnOnBluetoothError = "TURN_ON_BLUETOOTH_ERROR";
+  static const String bluetoothIsNotSupported = "BLUETOOTH_IS_NOT_SUPPORTED";
+  static const String bluetoothDisabled = "BLUETOOTH_DISABLED";
+
+  static const String discoveryError = "DISCOVERY_ERROR";
+  static const String openConnectionError = "OPEN_CONNECTION_ERROR";
+  static const String closeAndReopenConnectionError = "CLOSE_AND_REOPEN_CONNECTION_ERROR";
+  static const String connectionHasNotBeenEstablished = "CONNECTION_HAS_NOT_BEEN_ESTABLISHED";
+  static const String checkConnectionError = "CHECK_CONNECTION_ERROR";
+  static const String closeConnectionError = "CLOSE_CONNECTION_ERROR";
+  static const String writeError = "WRITE_ERROR";
+
+  static const String unexpectedError = "UNEXPECTED_ERROR";
+}

lib/src/models/flutter_zsdk_exception.dart

 class FlutterZsdkException implements Exception {
+  String code;
   String message;
 
-  FlutterZsdkException(this.message);
+  FlutterZsdkException(this.code, this.message);
 
   @override
   String toString() {