@leonardojc/capacitor-ioboard 1.2.7 → 2.0.0

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

@@ -0,0 +1,446 @@
+package com.leonardojc.capacitor.ioboard;
+
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+/**
+ * Serial communication manager for IOBoard plugin
+ * Handles low-level serial port operations
+ */
+public class SerialConnectionManager {
+    private static final String TAG = "SerialConnectionManager";
+    
+    public interface SerialDataListener {
+        void onDataReceived(byte[] data);
+        void onConnectionStateChanged(boolean connected);
+        void onError(String error);
+    }
+    
+    private FileInputStream serialInputStream;
+    private FileOutputStream serialOutputStream;
+    private String currentPortPath;
+    private boolean isConnected = false;
+    private Thread readerThread;
+    private Handler mainHandler;
+    private SerialDataListener listener;
+    private ExecutorService executorService;
+    
+    public SerialConnectionManager() {
+        mainHandler = new Handler(Looper.getMainLooper());
+        executorService = Executors.newSingleThreadExecutor();
+        Log.d(TAG, "SerialConnectionManager initialized");
+    }
+    
+    public void setDataListener(SerialDataListener listener) {
+        this.listener = listener;
+    }
+    
+    /**
+     * Opens a serial port connection
+     */
+    public synchronized boolean openPort(String portPath, int baudRate, int dataBits, int stopBits, String parity) {
+        try {
+            Log.d(TAG, "Opening serial port: " + portPath + " at " + baudRate + " baud");
+            
+            if (isConnected) {
+                Log.w(TAG, "Port already connected, closing existing connection");
+                closePort();
+            }
+            
+            // Verificar que el puerto existe
+            File portFile = new File(portPath);
+            if (!portFile.exists()) {
+                throw new IOException("Serial port does not exist: " + portPath);
+            }
+            
+            // Configurar parámetros del puerto serial usando stty
+            String sttyCommand = String.format(
+                "stty -F %s %d cs%d %s %s raw -echo -echoe -echok -echoctl -echoke",
+                portPath,
+                baudRate,
+                dataBits,
+                stopBits == 1 ? "-cstopb" : "cstopb",
+                getParityFlag(parity)
+            );
+            
+            Log.d(TAG, "Configuring port with: " + sttyCommand);
+            Process sttyProcess = Runtime.getRuntime().exec(new String[]{"su", "-c", sttyCommand});
+            int sttyResult = sttyProcess.waitFor();
+            
+            Log.d(TAG, "stty configuration result: " + sttyResult);
+            if (sttyResult != 0) {
+                Log.w(TAG, "stty configuration failed, trying alternative method");
+                
+                // Try alternative configuration without su
+                String altCommand = String.format("stty -F %s %d raw -echo", portPath, baudRate);
+                Log.d(TAG, "Trying alternative: " + altCommand);
+                Process altProcess = Runtime.getRuntime().exec(altCommand);
+                int altResult = altProcess.waitFor();
+                Log.d(TAG, "Alternative stty result: " + altResult);
+            }
+            
+            // Abrir streams de entrada y salida
+            serialInputStream = new FileInputStream(portFile);
+            serialOutputStream = new FileOutputStream(portFile);
+            
+            currentPortPath = portPath;
+            isConnected = true;
+            
+            // Iniciar hilo de lectura
+            startReaderThread();
+            
+            // Verificar que el hilo se inició correctamente
+            Thread.sleep(100); // Dar tiempo al hilo de iniciarse
+            Log.d(TAG, "Reader thread status: " + (readerThread != null ? "Created" : "NULL"));
+            Log.d(TAG, "Reader thread alive: " + (readerThread != null ? readerThread.isAlive() : "N/A"));
+            
+            Log.d(TAG, "Serial port opened successfully");
+            notifyConnectionStateChanged(true);
+            
+            return true;
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error opening serial port: " + e.getMessage(), e);
+            isConnected = false;
+            notifyError("Failed to open port: " + e.getMessage());
+            return false;
+        }
+    }
+    
+    /**
+     * Closes the serial port connection
+     */
+    public synchronized void closePort() {
+        try {
+            Log.d(TAG, "Closing serial port");
+            
+            isConnected = false;
+            
+            // Detener hilo de lectura
+            if (readerThread != null && readerThread.isAlive()) {
+                readerThread.interrupt();
+                try {
+                    readerThread.join(1000);
+                } catch (InterruptedException e) {
+                    Log.w(TAG, "Reader thread join interrupted");
+                }
+            }
+            
+            // Cerrar streams
+            if (serialInputStream != null) {
+                serialInputStream.close();
+                serialInputStream = null;
+            }
+            
+            if (serialOutputStream != null) {
+                serialOutputStream.close();
+                serialOutputStream = null;
+            }
+            
+            currentPortPath = null;
+            
+            Log.d(TAG, "Serial port closed");
+            notifyConnectionStateChanged(false);
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error closing serial port: " + e.getMessage(), e);
+        }
+    }
+    
+    /**
+     * Writes data to the serial port with enhanced debugging
+     */
+    public boolean writeData(byte[] data) {
+        if (!isConnected || serialOutputStream == null) {
+            Log.e(TAG, "Cannot write: port not connected");
+            return false;
+        }
+        
+        try {
+            // Enhanced logging with hex dump
+            Log.d(TAG, "=== WRITING TO SERIAL PORT ===");
+            Log.d(TAG, "Port: " + currentPortPath);
+            Log.d(TAG, "Data length: " + data.length + " bytes");
+            Log.d(TAG, "HEX data: " + bytesToHex(data));
+            Log.d(TAG, "Raw bytes: " + java.util.Arrays.toString(data));
+            
+            // Clear any pending input first
+            if (serialInputStream != null && serialInputStream.available() > 0) {
+                int available = serialInputStream.available();
+                byte[] discarded = new byte[available];
+                serialInputStream.read(discarded);
+                Log.d(TAG, "Discarded " + available + " pending bytes before write");
+            }
+            
+            long startTime = System.currentTimeMillis();
+            
+            // Write entire frame at once (IOBoard expects complete frame)
+            Log.d(TAG, "Sending complete frame as single write operation...");
+            serialOutputStream.write(data);
+            serialOutputStream.flush();
+            
+            long endTime = System.currentTimeMillis();
+            
+            Log.i(TAG, "✅ Successfully wrote " + data.length + " bytes in " + (endTime - startTime) + "ms");
+            Log.i(TAG, "HEX written: " + bytesToHex(data));
+            
+            // Wait longer for IOBoard response (some devices need more processing time)
+            Thread.sleep(200); // Increased from 50ms to 200ms
+            
+            // Check immediately if there's a response available
+            if (serialInputStream != null) {
+                int available = serialInputStream.available();
+                Log.d(TAG, "Checking for response after " + (endTime - startTime) + "ms write + 200ms wait: " + available + " bytes available");
+                
+                if (available > 0) {
+                    Log.w(TAG, "⚠️ DATA AVAILABLE AFTER WRITE! " + available + " bytes - reader thread should pick this up");
+                } else {
+                    Log.d(TAG, "🔍 No immediate response detected - this is normal for some IOBoard operations");
+                }
+            }
+            
+            return true;
+        } catch (Exception e) {
+            Log.e(TAG, "❌ Error writing to serial port: " + e.getMessage(), e);
+            Log.e(TAG, "Failed to write HEX: " + bytesToHex(data));
+            notifyError("Write error: " + e.getMessage());
+            return false;
+        }
+    }
+
+    // Helper method to convert bytes to hex string for debugging
+    private String bytesToHex(byte[] bytes) {
+        StringBuilder hexString = new StringBuilder();
+        for (byte b : bytes) {
+            String hex = Integer.toHexString(0xFF & b);
+            if (hex.length() == 1) {
+                hexString.append('0');
+            }
+            hexString.append(hex.toUpperCase()).append(" ");
+        }
+        return hexString.toString().trim();
+    }
+    
+    // Helper method to interpret door status codes
+    private String interpretDoorStatus(int doorStatus) {
+        switch (doorStatus) {
+            case 0xFE:
+                return "Door Closed/Locked (0xFE)";
+            case 0xFF:
+                return "Door Open/Unlocked (0xFF)";
+            case 0x00:
+                return "Door Unknown/Error (0x00)";
+            case 0x01:
+                return "Door Moving/Processing (0x01)";
+            default:
+                return String.format("Door Custom Status (0x%02X)", doorStatus);
+        }
+    }
+    
+    /**
+     * Checks if the port is connected
+     */
+    public boolean isConnected() {
+        return isConnected;
+    }
+    
+    /**
+     * Gets the current port path
+     */
+    public String getCurrentPortPath() {
+        return currentPortPath;
+    }
+    
+    /**
+     * Lists available serial ports
+     */
+    public List<String> listAvailablePorts() {
+        List<String> ports = new ArrayList<>();
+        
+        // Paths comunes para puertos seriales en Android
+        String[] commonPaths = {
+            "/dev/ttyS0", "/dev/ttyS1", "/dev/ttyS2", "/dev/ttyS3", "/dev/ttyS4",
+            "/dev/ttyUSB0", "/dev/ttyUSB1", "/dev/ttyUSB2", "/dev/ttyUSB3",
+            "/dev/ttyACM0", "/dev/ttyACM1", "/dev/ttyACM2", "/dev/ttyACM3",
+            "/dev/ttymxc0", "/dev/ttymxc1", "/dev/ttymxc2", "/dev/ttymxc3"
+        };
+        
+        for (String path : commonPaths) {
+            File portFile = new File(path);
+            if (portFile.exists()) {
+                Log.d(TAG, "Found serial port: " + path);
+                ports.add(path);
+            }
+        }
+        
+        Log.d(TAG, "Found " + ports.size() + " available serial ports");
+        return ports;
+    }
+    
+    private void startReaderThread() {
+        Log.d(TAG, "🚀 STARTING READER THREAD...");
+        
+        // Stop any existing reader thread first
+        if (readerThread != null && readerThread.isAlive()) {
+            Log.d(TAG, "Stopping existing reader thread");
+            readerThread.interrupt();
+            try {
+                readerThread.join(1000);
+            } catch (InterruptedException e) {
+                Log.w(TAG, "Interrupted while stopping reader thread");
+            }
+        }
+        
+        readerThread = new Thread(() -> {
+            Log.d(TAG, "📡 Serial reader thread started for port: " + currentPortPath);
+            Log.d(TAG, "Reader thread ID: " + Thread.currentThread().getId());
+            Log.d(TAG, "Input stream available: " + (serialInputStream != null));
+            
+            byte[] buffer = new byte[1024];
+            
+            while (isConnected && !Thread.currentThread().isInterrupted()) {
+                try {
+                    if (serialInputStream != null) {
+                        // Check if data is available
+                        int available = serialInputStream.available();
+                        if (available > 0) {
+                            Log.d(TAG, "📨 Data available: " + available + " bytes");
+                            
+                            int bytesRead = serialInputStream.read(buffer, 0, Math.min(available, buffer.length));
+                            if (bytesRead > 0) {
+                                byte[] data = new byte[bytesRead];
+                                System.arraycopy(buffer, 0, data, 0, bytesRead);
+                                
+                                // Enhanced logging for received data
+                                Log.d(TAG, "=== 📥 RECEIVED FROM IOBOARD ===");
+                                Log.d(TAG, "Port: " + currentPortPath);
+                                Log.d(TAG, "Received " + bytesRead + " bytes");
+                                Log.d(TAG, "HEX received: " + bytesToHex(data));
+                                Log.d(TAG, "Raw bytes: " + java.util.Arrays.toString(data));
+                                
+                                // Parser automático de respuesta del IOBoard
+                                try {
+                                    CapacitorIoboardPlugin.IOBoardResponse response = CapacitorIoboardPlugin.parseIOBoardResponse(data);
+                                    if (response.isValid) {
+                                        Log.i(TAG, String.format("🎯 IOBoard Response Parsed Successfully: %s", response.toString()));
+                                        
+                                        // Logging específico según tipo de respuesta
+                                        if (response.type == 0x00) { // Status Response
+                                            Log.i(TAG, String.format("📊 IOBoard Status - Firmware: %s, Door Status: 0x%02X", 
+                                                response.firmware, response.doorStatus));
+                                            
+                                            // Interpretar door status
+                                            String doorStatusDesc = interpretDoorStatus(response.doorStatus);
+                                            Log.i(TAG, String.format("🚪 Door Status: %s", doorStatusDesc));
+                                        }
+                                    } else {
+                                        Log.w(TAG, "⚠️ Received invalid IOBoard response - trying ASCII interpretation");
+                                        
+                                        // Try to interpret as ASCII if printable
+                                        String ascii = new String(data);
+                                        boolean isPrintable = ascii.chars().allMatch(c -> c >= 32 && c <= 126);
+                                        if (isPrintable) {
+                                            Log.d(TAG, "ASCII: '" + ascii + "'");
+                                        } else {
+                                            Log.d(TAG, "Binary data (non-ASCII)");
+                                        }
+                                    }
+                                } catch (Exception e) {
+                                    Log.e(TAG, "❌ Error parsing IOBoard response: " + e.getMessage(), e);
+                                    
+                                    // Fallback: Try to interpret as ASCII if printable
+                                    String ascii = new String(data);
+                                    boolean isPrintable = ascii.chars().allMatch(c -> c >= 32 && c <= 126);
+                                    if (isPrintable) {
+                                        Log.d(TAG, "ASCII fallback: '" + ascii + "'");
+                                    } else {
+                                        Log.d(TAG, "Binary data fallback (non-ASCII)");
+                                    }
+                                }
+                                
+                                Log.d(TAG, "=== END RECEIVED DATA ===");
+                                
+                                notifyDataReceived(data);
+                            }
+                        } else {
+                            // No data available, small sleep to prevent busy waiting
+                            Thread.sleep(50); // Increased from 10ms to 50ms
+                        }
+                    } else {
+                        Log.w(TAG, "Serial input stream is null");
+                        Thread.sleep(100);
+                    }
+                } catch (InterruptedException e) {
+                    Log.d(TAG, "📡 Reader thread interrupted");
+                    break;
+                } catch (Exception e) {
+                    Log.e(TAG, "❌ Error reading from serial port: " + e.getMessage(), e);
+                    notifyError("Read error: " + e.getMessage());
+                    
+                    // Small delay before retrying
+                    try {
+                        Thread.sleep(1000);
+                    } catch (InterruptedException ie) {
+                        break;
+                    }
+                }
+            }
+            
+            Log.d(TAG, "📡 Serial reader thread stopped");
+        });
+        
+        readerThread.setName("SerialReader-" + currentPortPath);
+        Log.d(TAG, "🎬 Starting reader thread...");
+        readerThread.start();
+        Log.d(TAG, "✅ Reader thread started successfully");
+    }
+    
+    private String getParityFlag(String parity) {
+        switch (parity.toLowerCase()) {
+            case "even":
+                return "parenb -parodd";
+            case "odd":
+                return "parenb parodd";
+            case "none":
+            default:
+                return "-parenb";
+        }
+    }
+    
+    private void notifyDataReceived(byte[] data) {
+        if (listener != null) {
+            Log.d(TAG, "Notifying listener of received data: " + bytesToHex(data));
+            mainHandler.post(() -> listener.onDataReceived(data));
+        } else {
+            Log.w(TAG, "No listener set for received data: " + bytesToHex(data));
+        }
+    }
+    
+    private void notifyConnectionStateChanged(boolean connected) {
+        if (listener != null) {
+            mainHandler.post(() -> listener.onConnectionStateChanged(connected));
+        }
+    }
+    
+    private void notifyError(String error) {
+        if (listener != null) {
+            mainHandler.post(() -> listener.onError(error));
+        }
+    }
+    
+    public void cleanup() {
+        closePort();
+        if (executorService != null) {
+            executorService.shutdown();
+        }
+    }
+}

package/dist/esm/definitions-v2.d.ts

@@ -0,0 +1,228 @@
+export interface CapacitorIoboardPlugin {
+    /**
+     * Connect to IOBoard device via serial port
+     * @param options Serial connection parameters
+     */
+    connect(options: SerialConnectionOptions): Promise<ConnectionResponse>;
+    /**
+     * Disconnect from IOBoard device
+     */
+    disconnect(): Promise<BasicResponse>;
+    /**
+     * Check if connected to IOBoard device
+     */
+    isConnected(): Promise<ConnectionStatusResponse>;
+    /**
+     * List available serial ports
+     */
+    listPorts(): Promise<PortListResponse>;
+    /**
+     * Get status from IOBoard device
+     * @param options Device address
+     */
+    getStatus(options: DeviceAddressOptions): Promise<StatusResponse>;
+    /**
+     * Unlock a specific pallet with RGB LED control
+     * @param options Pallet unlock parameters with RGB settings
+     */
+    unlockPallet(options: UnlockPalletOptions): Promise<BasicResponse>;
+    /**
+     * Control multiple LEDs simultaneously
+     * @param options Multiple LED control parameters
+     */
+    controlMultiple(options: MultipleControlOptions): Promise<BasicResponse>;
+    /**
+     * Start OTA firmware update
+     * @param options OTA initialization parameters
+     */
+    startOTAUpdate(options: OTAStartOptions): Promise<BasicResponse>;
+    /**
+     * Send OTA data packet
+     * @param options OTA data packet parameters
+     */
+    sendOTAData(options: OTADataOptions): Promise<BasicResponse>;
+    /**
+     * Add listener for data received events
+     */
+    addListener(eventName: 'dataReceived', listenerFunc: (event: DataReceivedEvent) => void): Promise<PluginListenerHandle>;
+    /**
+     * Add listener for connection state changes
+     */
+    addListener(eventName: 'connectionStateChanged', listenerFunc: (event: ConnectionStateEvent) => void): Promise<PluginListenerHandle>;
+    /**
+     * Add listener for serial errors
+     */
+    addListener(eventName: 'serialError', listenerFunc: (event: ErrorEvent) => void): Promise<PluginListenerHandle>;
+    /**
+     * Remove all listeners for this plugin
+     */
+    removeAllListeners(): Promise<void>;
+}
+export interface SerialConnectionOptions {
+    /** Serial port path (e.g., '/dev/ttyS2') */
+    portPath: string;
+    /** Baud rate (default: 115200) */
+    baudRate?: number;
+    /** Data bits (default: 8) */
+    dataBits?: number;
+    /** Stop bits (default: 1) */
+    stopBits?: number;
+    /** Parity (default: 'none') */
+    parity?: 'none' | 'even' | 'odd';
+}
+export interface DeviceAddressOptions {
+    /** IOBoard device address (1-255) */
+    address: number;
+}
+export interface UnlockPalletOptions {
+    /** IOBoard device address */
+    address: number;
+    /** Pallet number (0-7) */
+    palletNumber: number;
+    /** RGB Red value (0-255) */
+    red?: number;
+    /** RGB Green value (0-255) */
+    green?: number;
+    /** RGB Blue value (0-255) */
+    blue?: number;
+    /** LED intensity (0-100) */
+    intensity?: number;
+    /** Number of blinks (0-255) */
+    blinkTimes?: number;
+    /** Blink speed (1-30) */
+    blinkSpeed?: number;
+}
+export interface LEDConfiguration {
+    /** RGB Red value (0-255) */
+    red: number;
+    /** RGB Green value (0-255) */
+    green: number;
+    /** RGB Blue value (0-255) */
+    blue: number;
+    /** LED intensity (0-100) */
+    intensity: number;
+    /** Number of blinks (0-255) */
+    blinkTimes: number;
+    /** Blink speed (1-30) */
+    blinkSpeed: number;
+}
+export interface MultipleControlOptions {
+    /** IOBoard device address */
+    address: number;
+    /** Array of LED configurations for 8 pallets */
+    leds: LEDConfiguration[];
+}
+export interface OTAStartOptions {
+    /** IOBoard device address */
+    address: number;
+    /** Firmware file name */
+    fileName: string;
+    /** File size in bytes */
+    fileSize: number;
+    /** Total number of packets */
+    totalPackets: number;
+}
+export interface OTADataOptions {
+    /** IOBoard device address */
+    address: number;
+    /** Packet number */
+    packetNumber: number;
+    /** Data payload (128 bytes) */
+    data: number[];
+}
+export interface BasicResponse {
+    /** Operation success flag */
+    success: boolean;
+    /** Error message if failed */
+    error?: string;
+    /** Additional message */
+    message?: string;
+}
+export interface ConnectionResponse extends BasicResponse {
+    /** Connected port path */
+    portPath?: string;
+    /** Baud rate used */
+    baudRate?: number;
+}
+export interface ConnectionStatusResponse {
+    /** Connection status */
+    connected: boolean;
+    /** Current port path if connected */
+    portPath?: string;
+}
+export interface PortListResponse {
+    /** Available serial ports */
+    ports: string[];
+    /** Number of ports found */
+    count: number;
+}
+export interface StatusResponse extends BasicResponse {
+    /** Device address */
+    address?: number;
+    /** Device status information */
+    status?: DeviceStatus;
+    /** Frame type received */
+    frameType?: number;
+    /** Raw response data */
+    rawData?: number[];
+}
+export interface DeviceStatus {
+    /** Device online status */
+    online: boolean;
+    /** Firmware version */
+    firmwareVersion?: string;
+    /** Pallet states */
+    pallets?: PalletStatus[];
+    /** Device temperature */
+    temperature?: number;
+    /** Power status */
+    powerStatus?: string;
+}
+export interface PalletStatus {
+    /** Pallet number */
+    number: number;
+    /** Pallet locked/unlocked state */
+    locked: boolean;
+    /** Current LED RGB values */
+    led?: {
+        red: number;
+        green: number;
+        blue: number;
+        intensity: number;
+    };
+}
+export interface DataReceivedEvent {
+    /** Parsed response data */
+    data: any;
+    /** Raw bytes as string */
+    rawBytes: string;
+}
+export interface ConnectionStateEvent {
+    /** Connection status */
+    connected: boolean;
+    /** Port path */
+    portPath?: string;
+}
+export interface ErrorEvent {
+    /** Error message */
+    error: string;
+}
+export interface PluginListenerHandle {
+    remove(): Promise<void>;
+}
+export interface RGBColor {
+    red: number;
+    green: number;
+    blue: number;
+}
+export interface ColorPresets {
+    RED: RGBColor;
+    GREEN: RGBColor;
+    BLUE: RGBColor;
+    WHITE: RGBColor;
+    YELLOW: RGBColor;
+    PURPLE: RGBColor;
+    CYAN: RGBColor;
+    OFF: RGBColor;
+}
+export declare const COLOR_PRESETS: ColorPresets;

package/dist/esm/definitions-v2.js

@@ -0,0 +1,11 @@
+// Predefined color constants
+export const COLOR_PRESETS = {
+    RED: { red: 255, green: 0, blue: 0 },
+    GREEN: { red: 0, green: 255, blue: 0 },
+    BLUE: { red: 0, green: 0, blue: 255 },
+    WHITE: { red: 255, green: 255, blue: 255 },
+    YELLOW: { red: 255, green: 255, blue: 0 },
+    PURPLE: { red: 255, green: 0, blue: 255 },
+    CYAN: { red: 0, green: 255, blue: 255 },
+    OFF: { red: 0, green: 0, blue: 0 }
+};