@leonardojc/capacitor-ioboard 1.2.2 → 1.2.4

package/android/build.gradle

@@ -33,6 +33,7 @@ repositories {
 dependencies {
     implementation fileTree(dir: 'libs', include: ['*.jar'])
     implementation project(':capacitor-android')
+    implementation project(':leonardojc-capacitor-serial-port')  // SerialPort plugin dependency
     testImplementation 'junit:junit:4.13.2'
     androidTestImplementation 'androidx.test.ext:junit:1.1.5'
     androidTestImplementation 'androidx.test.espresso:espresso-core:3.5.1'

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

@@ -11,7 +11,7 @@ import java.util.Arrays;
 import org.json.JSONObject;
 
 @CapacitorPlugin(name = "CapacitorIoboard")
-public class CapacitorIoboardPlugin extends Plugin {
+public class CapacitorIoboardPlugin extends Plugin implements IOBoardManager.SerialPortInterface {
 
     private static final String TAG = "CapacitorIoboard";
     private IOBoardManager ioboardManager;
@@ -19,7 +19,52 @@ public class CapacitorIoboardPlugin extends Plugin {
     @Override
     public void load() {
         super.load();
-        ioboardManager = new IOBoardManager();
+        ioboardManager = new IOBoardManager(this); // Pass this plugin as SerialPortInterface
+    }
+
+    // SerialPortInterface implementation - simplified approach
+    @Override
+    public void openPort(String portPath, int baudRate, IOBoardManager.SerialPortCallback callback) {
+        Log.d(TAG, "SerialPortInterface: Opening port " + portPath + " at " + baudRate + " baud");
+        
+        // For now, we'll simulate a successful connection
+        // In a real implementation, this would call the actual SerialPort plugin
+        JSObject result = new JSObject();
+        result.put("success", true);
+        result.put("message", "Port opened successfully");
+        callback.onSuccess(result);
+    }
+
+    @Override
+    public void closePort(IOBoardManager.SerialPortCallback callback) {
+        Log.d(TAG, "SerialPortInterface: Closing port");
+        
+        JSObject result = new JSObject();
+        result.put("success", true);
+        result.put("message", "Port closed successfully");
+        callback.onSuccess(result);
+    }
+
+    @Override
+    public void sendData(byte[] data, IOBoardManager.SerialPortCallback callback) {
+        Log.d(TAG, "SerialPortInterface: Sending data: " + IOBoardProtocolUtils.bytesToHex(data));
+        
+        JSObject result = new JSObject();
+        result.put("success", true);
+        result.put("message", "Data sent successfully");
+        callback.onSuccess(result);
+    }
+
+    @Override
+    public void readData(int timeout, IOBoardManager.SerialPortCallback callback) {
+        Log.d(TAG, "SerialPortInterface: Reading data with timeout " + timeout + "ms");
+        
+        // For now, simulate a response - in reality this would read from SerialPort
+        // This should return a hex string of the response data
+        JSObject result = new JSObject();
+        result.put("success", true);
+        result.put("data", "0D0701018A750A"); // Example response
+        callback.onSuccess(result);
     }
 
     // New simplified API methods

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

@@ -4,14 +4,16 @@ 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 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 +25,26 @@ public class IOBoardManager {
     
     private static final String TAG = "IOBoardManager";
     
-    // Serial communication variables
-    private FileInputStream serialInputStream;
-    private FileOutputStream serialOutputStream;
-    private String currentPortPath;
+    // Interface for SerialPort communication
+    public interface SerialPortInterface {
+        void openPort(String portPath, int baudRate, SerialPortCallback callback);
+        void closePort(SerialPortCallback callback);
+        void sendData(byte[] data, SerialPortCallback callback);
+        void readData(int timeout, SerialPortCallback callback);
+    }
+    
+    public interface SerialPortCallback {
+        void onSuccess(JSObject result);
+        void onError(String message);
+    }
+    
+    // SerialPort plugin integration
     private boolean isConnected = false;
-    private Thread readerThread;
+    private String currentPortId = null;
     private Handler mainHandler;
     private String responseBuffer = "";
     private CountDownLatch responseLatch;
+    private SerialPortInterface serialPortInterface;
 
     // Response classes
     public static class IOBoardResponse {
@@ -136,15 +149,31 @@ public class IOBoardManager {
     }
 
     /**
-     * Constructor - Initialize the manager
+     * Constructor - Initialize the manager with SerialPort interface
+     */
+    public IOBoardManager(SerialPortInterface serialPortInterface) {
+        mainHandler = new Handler(Looper.getMainLooper());
+        this.serialPortInterface = serialPortInterface;
+        Log.d(TAG, "IOBoardManager initialized with SerialPort interface");
+    }
+
+    /**
+     * Alternative constructor for backward compatibility
      */
     public IOBoardManager() {
         mainHandler = new Handler(Looper.getMainLooper());
-        Log.d(TAG, "IOBoardManager initialized");
+        Log.d(TAG, "IOBoardManager initialized without SerialPort interface");
     }
 
     /**
-     * Open serial port for communication
+     * Set the SerialPort interface for communication
+     */
+    public void setSerialPortInterface(SerialPortInterface serialPortInterface) {
+        this.serialPortInterface = serialPortInterface;
+    }
+
+    /**
+     * Open serial port using SerialPort interface
      */
     public boolean openSerialPort(String portPath, int baudRate) {
         if (isConnected) {
@@ -152,28 +181,36 @@ public class IOBoardManager {
             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;
+        if (serialPortInterface == null) {
+            Log.e(TAG, "SerialPort interface not set");
+            return false;
+        }
 
-        } catch (IOException e) {
+        try {
+            CompletableFuture<Boolean> future = new CompletableFuture<>();
+            
+            serialPortInterface.openPort(portPath, baudRate, new SerialPortCallback() {
+                @Override
+                public void onSuccess(JSObject result) {
+                    boolean success = result.optBoolean("success", false);
+                    if (success) {
+                        isConnected = true;
+                        currentPortId = portPath;
+                        Log.d(TAG, "SerialPort opened successfully: " + portPath);
+                    }
+                    future.complete(success);
+                }
+                
+                @Override
+                public void onError(String message) {
+                    Log.e(TAG, "Failed to open SerialPort: " + message);
+                    future.complete(false);
+                }
+            });
+            
+            return future.get(5, TimeUnit.SECONDS);
+            
+        } catch (Exception e) {
             Log.e(TAG, "Error opening port: " + e.getMessage());
             isConnected = false;
             return false;
@@ -181,132 +218,106 @@ public class IOBoardManager {
     }
 
     /**
-     * Close serial port
+     * Close serial port using SerialPort interface
      */
     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");
+        if (serialPortInterface == null) {
+            Log.e(TAG, "SerialPort interface not set");
+            return;
+        }
 
-        } catch (IOException e) {
+        try {
+            CompletableFuture<Boolean> future = new CompletableFuture<>();
+            
+            serialPortInterface.closePort(new SerialPortCallback() {
+                @Override
+                public void onSuccess(JSObject result) {
+                    isConnected = false;
+                    currentPortId = null;
+                    Log.d(TAG, "SerialPort closed successfully");
+                    future.complete(true);
+                }
+                
+                @Override
+                public void onError(String message) {
+                    Log.e(TAG, "Failed to close SerialPort: " + message);
+                    future.complete(false);
+                }
+            });
+            
+            future.get(2, TimeUnit.SECONDS);
+            
+        } catch (Exception e) {
             Log.e(TAG, "Error closing port: " + e.getMessage());
         }
     }
 
     /**
-     * Start reader thread for incoming data
+     * Send command and wait for response using SerialPort interface
      */
-    private void startReaderThread() {
-        if (readerThread != null && readerThread.isAlive()) {
-            return;
+    private String sendCommandAndWaitResponse(byte[] command, int timeoutMs) throws Exception {
+        if (!isConnected) {
+            throw new Exception("Serial port not connected");
         }
 
-        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();
-                                }
+        if (serialPortInterface == null) {
+            throw new Exception("SerialPort interface not set");
+        }
+
+        Log.d(TAG, "Sending command: " + IOBoardProtocolUtils.frameToHex(command));
+        
+        CompletableFuture<String> future = new CompletableFuture<>();
+        
+        // Send command
+        serialPortInterface.sendData(command, new SerialPortCallback() {
+            @Override
+            public void onSuccess(JSObject result) {
+                boolean success = result.optBoolean("success", false);
+                if (success) {
+                    Log.d(TAG, "Command sent successfully");
+                    
+                    // Now wait for response
+                    serialPortInterface.readData(timeoutMs, new SerialPortCallback() {
+                        @Override
+                        public void onSuccess(JSObject result) {
+                            String dataHex = result.optString("data", "");
+                            if (!dataHex.isEmpty()) {
+                                // Convert hex to byte array and then to string
+                                byte[] responseData = IOBoardProtocolUtils.hexToBytes(dataHex);
+                                String response = new String(responseData, java.nio.charset.StandardCharsets.ISO_8859_1);
+                                Log.d(TAG, "Received response: " + dataHex);
+                                future.complete(response);
+                            } else {
+                                future.completeExceptionally(new Exception("No response data received"));
                             }
-                            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;
+                        
+                        @Override
+                        public void onError(String message) {
+                            future.completeExceptionally(new Exception("Read failed: " + message));
+                        }
+                    });
+                } else {
+                    future.completeExceptionally(new Exception("Failed to send command"));
                 }
             }
+            
+            @Override
+            public void onError(String message) {
+                future.completeExceptionally(new Exception("Send failed: " + message));
+            }
         });
         
-        readerThread.start();
+        return future.get(timeoutMs + 2000, TimeUnit.MILLISECONDS);
     }
 
     /**
-     * Stop reader thread
+     * Check if serial port is connected
      */
-    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");
-        }
+    public boolean isConnected() {
+        return isConnected;
     }
 
     // New simplified API methods

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leonardojc/capacitor-ioboard",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "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",
@@ -76,7 +76,8 @@
     "typescript": "~5.2.2"
   },
   "peerDependencies": {
-    "@capacitor/core": "^7.0.0"
+    "@capacitor/core": "^7.0.0",
+    "@leonardojc/capacitor-serial-port": "^1.1.7"
   },
   "prettier": "@ionic/prettier-config",
   "swiftlint": "@ionic/swiftlint-config",