@leonardojc/capacitor-ioboard 1.2.2 → 1.2.3

package/android/src/main/java/com/leonardojc/capacitor/ioboard/IOBoardManager.java

@@ -4,14 +4,17 @@ import android.util.Log;
 import android.util.Base64;
 import android.os.Handler;
 import android.os.Looper;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.PluginCall;
+import com.frankandroid.capacitor.serialport.SerialPortPlugin;
 import java.util.Arrays;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.CountDownLatch;
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileOutputStream;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.Executors;
 import java.io.IOException;
 
 /**
@@ -23,15 +26,13 @@ public class IOBoardManager {
     
     private static final String TAG = "IOBoardManager";
     
-    // Serial communication variables
-    private FileInputStream serialInputStream;
-    private FileOutputStream serialOutputStream;
-    private String currentPortPath;
+    // SerialPort plugin integration
     private boolean isConnected = false;
-    private Thread readerThread;
+    private String currentPortId = null;
     private Handler mainHandler;
     private String responseBuffer = "";
     private CountDownLatch responseLatch;
+    private com.frankandroid.capacitor.serialport.SerialPortPlugin serialPortPlugin;
 
     // Response classes
     public static class IOBoardResponse {
@@ -140,11 +141,12 @@ public class IOBoardManager {
      */
     public IOBoardManager() {
         mainHandler = new Handler(Looper.getMainLooper());
-        Log.d(TAG, "IOBoardManager initialized");
+        serialPortPlugin = new com.frankandroid.capacitor.serialport.SerialPortPlugin();
+        Log.d(TAG, "IOBoardManager initialized with SerialPort plugin");
     }
 
     /**
-     * Open serial port for communication
+     * Open serial port using SerialPort plugin
      */
     public boolean openSerialPort(String portPath, int baudRate) {
         if (isConnected) {
@@ -153,160 +155,236 @@ public class IOBoardManager {
         }
 
         try {
-            // Verificar que el puerto existe
-            File portFile = new File(portPath);
-            if (!portFile.exists()) {
-                Log.e(TAG, "Port " + portPath + " does not exist");
-                return false;
-            }
-
-            // Intentar abrir streams
-            serialInputStream = new FileInputStream(portFile);
-            serialOutputStream = new FileOutputStream(portFile);
-
-            currentPortPath = portPath;
-            isConnected = true;
-
-            // Iniciar hilo de lectura
-            startReaderThread();
-
-            Log.d(TAG, "Port opened successfully: " + portPath + " at " + baudRate + " baud");
-            return true;
-
-        } catch (IOException e) {
-            Log.e(TAG, "Error opening port: " + e.getMessage());
+            Log.d(TAG, "Opening serial port via SerialPort plugin: " + portPath + " at " + baudRate + " baud");
+            
+            // Create a mock PluginCall for the SerialPort plugin
+            JSObject openParams = new JSObject();
+            openParams.put("path", portPath);
+            openParams.put("baudRate", baudRate);
+            
+            // Use CompletableFuture to handle async call
+            CompletableFuture<Boolean> future = new CompletableFuture<>();
+            
+            PluginCall mockCall = new PluginCall() {
+                @Override
+                public void resolve(JSObject result) {
+                    boolean success = result.optBoolean("success", false);
+                    if (success) {
+                        isConnected = true;
+                        currentPortId = portPath; // Store port path as ID
+                        Log.d(TAG, "SerialPort opened successfully");
+                        setupSerialDataListener();
+                    }
+                    future.complete(success);
+                }
+                
+                @Override
+                public void reject(String message) {
+                    Log.e(TAG, "Failed to open SerialPort: " + message);
+                    future.complete(false);
+                }
+                
+                @Override
+                public String getString(String key) {
+                    return openParams.optString(key);
+                }
+                
+                @Override
+                public int getInt(String key, int defaultValue) {
+                    return openParams.optInt(key, defaultValue);
+                }
+            };
+            
+            // Call SerialPort plugin
+            serialPortPlugin.openPort(mockCall);
+            
+            // Wait for result (with timeout)
+            return future.get(5, TimeUnit.SECONDS);
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error opening port via SerialPort plugin: " + e.getMessage());
             isConnected = false;
             return false;
         }
     }
 
     /**
-     * Close serial port
+     * Setup data listener for SerialPort plugin
+     */
+    private void setupSerialDataListener() {
+        // The SerialPort plugin will emit data events that we can capture
+        // For now, we'll rely on the existing data flow mechanism
+        Log.d(TAG, "Serial data listener setup completed");
+    }
+
+    /**
+     * Close serial port using SerialPort plugin
      */
     public void closeSerialPort() {
         if (!isConnected) return;
 
         try {
-            // Detener hilo de lectura
-            stopReaderThread();
-
-            // Cerrar streams
-            if (serialInputStream != null) {
-                serialInputStream.close();
-                serialInputStream = null;
-            }
-            if (serialOutputStream != null) {
-                serialOutputStream.close();
-                serialOutputStream = null;
-            }
-
-            isConnected = false;
-            currentPortPath = null;
-            Log.d(TAG, "Port closed successfully");
-
-        } catch (IOException e) {
-            Log.e(TAG, "Error closing port: " + e.getMessage());
+            Log.d(TAG, "Closing serial port via SerialPort plugin");
+            
+            CompletableFuture<Boolean> future = new CompletableFuture<>();
+            
+            PluginCall mockCall = new PluginCall() {
+                @Override
+                public void resolve(JSObject result) {
+                    isConnected = false;
+                    currentPortId = null;
+                    Log.d(TAG, "SerialPort closed successfully");
+                    future.complete(true);
+                }
+                
+                @Override
+                public void reject(String message) {
+                    Log.e(TAG, "Failed to close SerialPort: " + message);
+                    future.complete(false);
+                }
+            };
+            
+            serialPortPlugin.closePort(mockCall);
+            future.get(2, TimeUnit.SECONDS);
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error closing port via SerialPort plugin: " + e.getMessage());
         }
     }
 
     /**
-     * Start reader thread for incoming data
+     * Send command and wait for response using SerialPort plugin
      */
-    private void startReaderThread() {
-        if (readerThread != null && readerThread.isAlive()) {
-            return;
+    public CompletableFuture<byte[]> sendCommandAndWaitResponse(byte[] command, int timeoutMs) {
+        CompletableFuture<byte[]> future = new CompletableFuture<>();
+
+        if (!isConnected) {
+            future.completeExceptionally(new IOException("Port is not connected"));
+            return future;
         }
 
-        readerThread = new Thread(() -> {
-            byte[] buffer = new byte[1024];
-            
-            while (isConnected && !Thread.currentThread().isInterrupted()) {
-                try {
-                    if (serialInputStream.available() > 0) {
-                        int bytesRead = serialInputStream.read(buffer);
-                        if (bytesRead > 0) {
-                            String receivedData = new String(buffer, 0, bytesRead, "ISO-8859-1");
-                            synchronized (this) {
-                                responseBuffer += receivedData;
-                                if (responseLatch != null) {
-                                    responseLatch.countDown();
-                                }
-                            }
-                            Log.d(TAG, "Data received (length): " + bytesRead);
-                        }
-                    }
-                    Thread.sleep(10); // Small delay to prevent excessive CPU usage
-                } catch (IOException | InterruptedException e) {
-                    if (isConnected) {
-                        Log.e(TAG, "Error in reader thread: " + e.getMessage());
+        try {
+            Log.d(TAG, "Sending command: " + IOBoardProtocolUtils.bytesToHex(command));
+
+            // Send command using SerialPort plugin
+            JSObject writeParams = new JSObject();
+            String hexData = IOBoardProtocolUtils.bytesToHex(command);
+            writeParams.put("data", hexData);
+            
+            PluginCall writeCall = new PluginCall() {
+                @Override
+                public void resolve(JSObject result) {
+                    boolean success = result.optBoolean("success", false);
+                    if (success) {
+                        Log.d(TAG, "Command sent successfully via SerialPort");
+                        // Start waiting for response
+                        waitForResponse(future, timeoutMs);
+                    } else {
+                        future.completeExceptionally(new IOException("Failed to send command"));
                     }
-                    break;
                 }
-            }
-        });
-        
-        readerThread.start();
-    }
+                
+                @Override
+                public void reject(String message) {
+                    Log.e(TAG, "Failed to send data: " + message);
+                    future.completeExceptionally(new IOException("Send failed: " + message));
+                }
+                
+                @Override
+                public String getString(String key) {
+                    return writeParams.optString(key);
+                }
+            };
 
-    /**
-     * Stop reader thread
-     */
-    private void stopReaderThread() {
-        if (readerThread != null && readerThread.isAlive()) {
-            readerThread.interrupt();
-            try {
-                readerThread.join(1000); // Wait up to 1 second
-            } catch (InterruptedException e) {
-                Thread.currentThread().interrupt();
-            }
+            serialPortPlugin.writeData(writeCall);
+
+        } catch (Exception e) {
+            Log.e(TAG, "Error sending command: " + e.getMessage());
+            future.completeExceptionally(e);
         }
+
+        return future;
     }
 
     /**
-     * Send command via serial port and wait for response
+     * Helper method for backward compatibility - returns String response
      */
     private String sendCommandAndWaitResponse(byte[] command, int timeoutMs) throws Exception {
-        if (!isConnected || serialOutputStream == null) {
-            throw new Exception("Serial port not connected");
-        }
+        CompletableFuture<byte[]> future = sendCommandAndWaitResponse(command, timeoutMs);
+        byte[] responseData = future.get(timeoutMs + 1000, TimeUnit.MILLISECONDS);
+        return new String(responseData, "ISO-8859-1");
+    }
 
-        String hexCommand = IOBoardProtocolUtils.frameToHex(command);
-        Log.d(TAG, "Sending command (HEX): " + hexCommand);
+    /**
+     * Wait for response from SerialPort
+     */
+    private void waitForResponse(CompletableFuture<byte[]> future, int timeoutMs) {
+        // Schedule timeout
+        ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
+        scheduler.schedule(() -> {
+            if (!future.isDone()) {
+                future.completeExceptionally(new IOException("Response timeout after " + timeoutMs + "ms"));
+            }
+        }, timeoutMs, TimeUnit.MILLISECONDS);
 
-        synchronized (this) {
-            // Clear response buffer
-            responseBuffer = "";
-            responseLatch = new CountDownLatch(1);
-        }
+        // Set up listener for incoming data
+        // Note: This would typically be set up through the SerialPort plugin's data events
+        // For now, we'll use a simplified approach
+        setupResponseListener(future, scheduler);
+    }
 
-        try {
-            // Convert command to Latin-1 string and write to serial port
-            String commandString = IOBoardProtocolUtils.frameToLatin1String(command);
-            byte[] bytes = commandString.getBytes("ISO-8859-1");
-            serialOutputStream.write(bytes);
-            serialOutputStream.flush();
-
-            Log.d(TAG, "Command sent, waiting for response...");
-
-            // Wait for response with timeout
-            boolean responseReceived = responseLatch.await(timeoutMs, TimeUnit.MILLISECONDS);
-            
-            if (responseReceived) {
-                synchronized (this) {
-                    String response = responseBuffer;
-                    Log.d(TAG, "Response received (length): " + response.length());
-                    return response;
-                }
-            } else {
-                throw new Exception("Timeout waiting for response");
+    /**
+     * Setup response listener (simplified for SerialPort integration)
+     */
+    private void setupResponseListener(CompletableFuture<byte[]> future, ScheduledExecutorService scheduler) {
+        // This would be implemented to listen for data events from SerialPort plugin
+        // For now, we'll implement a polling mechanism
+        new Thread(() -> {
+            try {
+                Thread.sleep(100); // Wait for potential response
+                
+                // Try to read response using SerialPort plugin
+                JSObject readParams = new JSObject();
+                readParams.put("timeout", 1000);
+                
+                PluginCall readCall = new PluginCall() {
+                    @Override
+                    public void resolve(JSObject result) {
+                        try {
+                            String dataHex = result.optString("data", "");
+                            if (!dataHex.isEmpty()) {
+                                byte[] responseData = IOBoardProtocolUtils.hexToBytes(dataHex);
+                                Log.d(TAG, "Received response: " + IOBoardProtocolUtils.bytesToHex(responseData));
+                                future.complete(responseData);
+                            } else {
+                                future.completeExceptionally(new IOException("No response data received"));
+                            }
+                        } catch (Exception e) {
+                            future.completeExceptionally(e);
+                        } finally {
+                            scheduler.shutdown();
+                        }
+                    }
+                    
+                    @Override
+                    public void reject(String message) {
+                        future.completeExceptionally(new IOException("Read failed: " + message));
+                        scheduler.shutdown();
+                    }
+                    
+                    @Override
+                    public int getInt(String key, int defaultValue) {
+                        return readParams.optInt(key, defaultValue);
+                    }
+                };
+                
+                serialPortPlugin.readData(readCall);
+                
+            } catch (Exception e) {
+                future.completeExceptionally(e);
+                scheduler.shutdown();
             }
-
-        } catch (IOException e) {
-            throw new Exception("Error sending command: " + e.getMessage());
-        } catch (InterruptedException e) {
-            Thread.currentThread().interrupt();
-            throw new Exception("Command interrupted");
-        }
+        }).start();
     }
 
     // New simplified API methods

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leonardojc/capacitor-ioboard",
-  "version": "1.2.2",
+  "version": "1.2.3",
   "description": "A Capacitor plugin for controlling custom IOBOARD devices via RS485 serial communication with full native protocol implementation",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",