@leonardojc/capacitor-ioboard 1.2.0 → 1.2.2

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

@@ -2,10 +2,17 @@ package com.leonardojc.capacitor.ioboard;
 
 import android.util.Log;
 import android.util.Base64;
+import android.os.Handler;
+import android.os.Looper;
 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.io.IOException;
 
 /**
  * Manager class for IOBOARD communication protocol
@@ -16,8 +23,15 @@ public class IOBoardManager {
     
     private static final String TAG = "IOBoardManager";
     
+    // Serial communication variables
+    private FileInputStream serialInputStream;
+    private FileOutputStream serialOutputStream;
+    private String currentPortPath;
     private boolean isConnected = false;
-    private String currentSerialPortId = null;
+    private Thread readerThread;
+    private Handler mainHandler;
+    private String responseBuffer = "";
+    private CountDownLatch responseLatch;
 
     // Response classes
     public static class IOBoardResponse {
@@ -122,18 +136,177 @@ public class IOBoardManager {
     }
 
     /**
-     * Send command via SerialPort plugin and wait for response
+     * Constructor - Initialize the manager
      */
-    private String sendCommandAndWaitResponse(byte[] command, int timeoutMs) throws Exception {
-        // TODO: Integrate with @leonardojc/capacitor-serial-port plugin
-        // This method should:
-        // 1. Convert command to appropriate format for SerialPort plugin
-        // 2. Call SerialPort.writeData(portId, data)
-        // 3. Wait for response using SerialPort.readData() or data listeners
-        // 4. Return response string
+    public IOBoardManager() {
+        mainHandler = new Handler(Looper.getMainLooper());
+        Log.d(TAG, "IOBoardManager initialized");
+    }
+
+    /**
+     * Open serial port for communication
+     */
+    public boolean openSerialPort(String portPath, int baudRate) {
+        if (isConnected) {
+            Log.w(TAG, "Port already connected. Close current connection first.");
+            return false;
+        }
+
+        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());
+            isConnected = false;
+            return false;
+        }
+    }
+
+    /**
+     * Close serial port
+     */
+    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());
+        }
+    }
+
+    /**
+     * Start reader thread for incoming data
+     */
+    private void startReaderThread() {
+        if (readerThread != null && readerThread.isAlive()) {
+            return;
+        }
+
+        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());
+                    }
+                    break;
+                }
+            }
+        });
         
-        // For now, return mock response for testing
-        throw new Exception("SerialPort integration not yet implemented");
+        readerThread.start();
+    }
+
+    /**
+     * 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();
+            }
+        }
+    }
+
+    /**
+     * Send command via serial port and wait for response
+     */
+    private String sendCommandAndWaitResponse(byte[] command, int timeoutMs) throws Exception {
+        if (!isConnected || serialOutputStream == null) {
+            throw new Exception("Serial port not connected");
+        }
+
+        String hexCommand = IOBoardProtocolUtils.frameToHex(command);
+        Log.d(TAG, "Sending command (HEX): " + hexCommand);
+
+        synchronized (this) {
+            // Clear response buffer
+            responseBuffer = "";
+            responseLatch = new CountDownLatch(1);
+        }
+
+        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");
+            }
+
+        } catch (IOException e) {
+            throw new Exception("Error sending command: " + e.getMessage());
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+            throw new Exception("Command interrupted");
+        }
     }
 
     // New simplified API methods
@@ -145,15 +318,12 @@ public class IOBoardManager {
         Log.d(TAG, "Connecting to serial port: " + config.portPath + " at " + config.baudRate + " baud");
         
         try {
-            // TODO: Initialize connection with SerialPort plugin
-            // Call SerialPort.openConnection() with config parameters
-            // Store the returned port ID for future operations
-            
-            // For now, just set the connected flag
-            isConnected = true;
-            currentSerialPortId = "mock_port_id";
-            
-            return new IOBoardResponse(true, "Connected to " + config.portPath + " successfully");
+            boolean success = openSerialPort(config.portPath, config.baudRate);
+            if (success) {
+                return new IOBoardResponse(true, "Connected to " + config.portPath + " successfully");
+            } else {
+                return new IOBoardResponse(false, "Failed to open serial port: " + config.portPath);
+            }
             
         } catch (Exception e) {
             Log.e(TAG, "Error connecting", e);
@@ -168,12 +338,7 @@ public class IOBoardManager {
         Log.d(TAG, "Disconnecting from serial port");
         
         try {
-            // TODO: Close connection with SerialPort plugin
-            // Call SerialPort.closeConnection(currentSerialPortId)
-            
-            isConnected = false;
-            currentSerialPortId = null;
-            
+            closeSerialPort();
             return new IOBoardResponse(true, "Disconnected successfully");
             
         } catch (Exception e) {
@@ -656,49 +821,6 @@ public class IOBoardManager {
         }
     }
 
-    /**
-     * Open serial connection
-     */
-    public IOBoardResponse openConnection(SerialConfig config) {
-        Log.d(TAG, "Opening serial connection - Port: " + config.portPath + ", BaudRate: " + config.baudRate);
-        
-        try {
-            // TODO: Initialize connection with SerialPort plugin
-            // Call SerialPort.openConnection() with config parameters
-            // Store the returned port ID for future operations
-            
-            isConnected = true;
-            currentSerialPortId = "mock_port_id";
-            
-            return new IOBoardResponse(true, "Serial connection opened successfully");
-            
-        } catch (Exception e) {
-            Log.e(TAG, "Error opening connection", e);
-            return new IOBoardResponse(false, "Error opening connection: " + e.getMessage());
-        }
-    }
-
-    /**
-     * Close serial connection
-     */
-    public IOBoardResponse closeConnection() {
-        Log.d(TAG, "Closing serial connection");
-        
-        try {
-            // TODO: Close connection with SerialPort plugin
-            // Call SerialPort.closeConnection(currentSerialPortId)
-            
-            isConnected = false;
-            currentSerialPortId = null;
-            
-            return new IOBoardResponse(true, "Serial connection closed successfully");
-            
-        } catch (Exception e) {
-            Log.e(TAG, "Error closing connection", e);
-            return new IOBoardResponse(false, "Error closing connection: " + e.getMessage());
-        }
-    }
-
     /**
      * Check if serial connection is open
      */

package/dist/esm/definitions.d.ts

@@ -81,6 +81,7 @@ export interface UnlockPalletOptions extends DeviceOptions {
 }
 export interface MultiplePalletOptions extends DeviceOptions {
     doorLockMask: number;
+    ledColor?: 'red' | 'green' | 'blue' | 'yellow' | 'white' | 'off';
     ledControls?: LEDControlOptions[];
 }
 export interface ScanOptions {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leonardojc/capacitor-ioboard",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "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",