From 2d7fc43ea2bd4fec627fab0258f07af0b4257b93 Mon Sep 17 00:00:00 2001
From: Tony <tonylu@tony-cloud.com>
Date: Sun, 28 Jun 2026 06:36:09 +0800
Subject: [PATCH] Add methods to set serial parameters and control lines in
 UsbSerialPort

Signed-off-by: Tony <tonylu@tony-cloud.com>
---
 .../FlutterUsbSerialPlugin.kt                 | 83 +++++++++++++++++++
 lib/src/usb_serial_port.dart                  | 44 ++++++++++
 2 files changed, 127 insertions(+)

diff --git a/android/src/main/kotlin/com/dalimaster/flutter_usb_serial/FlutterUsbSerialPlugin.kt b/android/src/main/kotlin/com/dalimaster/flutter_usb_serial/FlutterUsbSerialPlugin.kt
index d06b5aa..a17140e 100644
--- a/android/src/main/kotlin/com/dalimaster/flutter_usb_serial/FlutterUsbSerialPlugin.kt
+++ b/android/src/main/kotlin/com/dalimaster/flutter_usb_serial/FlutterUsbSerialPlugin.kt
@@ -131,6 +131,10 @@ class FlutterUsbSerialPlugin :
             "requestPermission" -> requestPermission(call, result)
             "openPort" -> openPort(call, result)
             "write" -> write(call, result)
+            "setParameters" -> setParameters(call, result)
+            "setDTR" -> setDtr(call, result)
+            "setRTS" -> setRts(call, result)
+            "purgeHwBuffers" -> purgeHwBuffers(call, result)
             "close" -> closePort(call, result)
             else -> result.notImplemented()
         }
@@ -272,6 +276,85 @@ class FlutterUsbSerialPlugin :
         }
     }
 
+    private fun setParameters(call: MethodCall, result: Result) {
+        val portId = call.argument<Int>("portId") ?: run {
+            result.error("INVALID_ARGUMENT", "portId required", null)
+            return
+        }
+        val baudRate = call.argument<Int>("baudRate") ?: 9600
+        val dataBits = call.argument<Int>("dataBits") ?: 8
+        val parity = call.argument<Int>("parity") ?: UsbSerialPort.PARITY_NONE
+        val stopBits = call.argument<Int>("stopBits") ?: UsbSerialPort.STOPBITS_1
+        val handle = synchronized(portsLock) { openPorts[portId] }
+        if (handle == null) {
+            result.error("PORT_NOT_FOUND", "Port $portId is not open", null)
+            return
+        }
+        try {
+            handle.port.setParameters(baudRate, dataBits, stopBits, parity)
+            result.success(null)
+        } catch (e: Exception) {
+            result.error("SET_PARAMETERS_FAILED", e.message, null)
+        }
+    }
+
+    private fun setDtr(call: MethodCall, result: Result) {
+        setControlLine(call, result, "DTR") { port, value -> port.setDTR(value) }
+    }
+
+    private fun setRts(call: MethodCall, result: Result) {
+        setControlLine(call, result, "RTS") { port, value -> port.setRTS(value) }
+    }
+
+    private fun setControlLine(
+        call: MethodCall,
+        result: Result,
+        name: String,
+        setter: (UsbSerialPort, Boolean) -> Unit,
+    ) {
+        val portId = call.argument<Int>("portId") ?: run {
+            result.error("INVALID_ARGUMENT", "portId required", null)
+            return
+        }
+        val value = call.argument<Boolean>("value") ?: run {
+            result.error("INVALID_ARGUMENT", "value required", null)
+            return
+        }
+        val handle = synchronized(portsLock) { openPorts[portId] }
+        if (handle == null) {
+            result.error("PORT_NOT_FOUND", "Port $portId is not open", null)
+            return
+        }
+        try {
+            setter(handle.port, value)
+            result.success(null)
+        } catch (e: Exception) {
+            result.error("SET_${name}_FAILED", e.message, null)
+        }
+    }
+
+    private fun purgeHwBuffers(call: MethodCall, result: Result) {
+        val portId = call.argument<Int>("portId") ?: run {
+            result.error("INVALID_ARGUMENT", "portId required", null)
+            return
+        }
+        val purgeWriteBuffers = call.argument<Boolean>("purgeWriteBuffers") ?: true
+        val purgeReadBuffers = call.argument<Boolean>("purgeReadBuffers") ?: true
+        val handle = synchronized(portsLock) { openPorts[portId] }
+        if (handle == null) {
+            result.error("PORT_NOT_FOUND", "Port $portId is not open", null)
+            return
+        }
+        try {
+            handle.port.purgeHwBuffers(purgeWriteBuffers, purgeReadBuffers)
+            result.success(null)
+        } catch (e: UnsupportedOperationException) {
+            result.success(null)
+        } catch (e: Exception) {
+            result.error("PURGE_FAILED", e.message, null)
+        }
+    }
+
     private fun closePort(call: MethodCall, result: Result) {
         val portId = call.argument<Int>("portId") ?: run {
             result.error("INVALID_ARGUMENT", "portId required", null)
diff --git a/lib/src/usb_serial_port.dart b/lib/src/usb_serial_port.dart
index 01f8296..a2246ce 100644
--- a/lib/src/usb_serial_port.dart
+++ b/lib/src/usb_serial_port.dart
@@ -32,6 +32,50 @@ class UsbSerialPort {
     return written ?? 0;
   }
 
+  /// Updates serial line parameters for an already-open port.
+  Future<void> setParameters({
+    required int baudRate,
+    int dataBits = 8,
+    UsbSerialParity parity = UsbSerialParity.none,
+    UsbSerialStopBits stopBits = UsbSerialStopBits.one,
+  }) async {
+    await _methods.invokeMethod<void>('setParameters', {
+      'portId': _portId,
+      'baudRate': baudRate,
+      'dataBits': dataBits,
+      'parity': parity.index,
+      'stopBits': FlutterUsbSerial._stopBitsIndex(stopBits),
+    });
+  }
+
+  /// Sets the DTR modem control line.
+  Future<void> setDTR(bool value) async {
+    await _methods.invokeMethod<void>('setDTR', {
+      'portId': _portId,
+      'value': value,
+    });
+  }
+
+  /// Sets the RTS modem control line.
+  Future<void> setRTS(bool value) async {
+    await _methods.invokeMethod<void>('setRTS', {
+      'portId': _portId,
+      'value': value,
+    });
+  }
+
+  /// Purges USB serial driver buffers when the driver supports it.
+  Future<void> purgeHwBuffers({
+    bool purgeWriteBuffers = true,
+    bool purgeReadBuffers = true,
+  }) async {
+    await _methods.invokeMethod<void>('purgeHwBuffers', {
+      'portId': _portId,
+      'purgeWriteBuffers': purgeWriteBuffers,
+      'purgeReadBuffers': purgeReadBuffers,
+    });
+  }
+
   /// Close the port and release native resources.
   Future<void> close() async {
     await _methods.invokeMethod<void>('close', {'portId': _portId});