@leonardojc/capacitor-ioboard 1.1.0

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

@@ -0,0 +1,657 @@
+package com.leonardojc.capacitor.ioboard;
+
+import android.util.Log;
+import android.util.Base64;
+import java.util.Arrays;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Manager class for IOBOARD communication protocol
+ * This class integrates with the @leonardojc/capacitor-serial-port plugin
+ */
+public class IOBoardManager {
+    
+    private static final String TAG = "IOBoardManager";
+    private static final int SOI = 0x0D; // Start of frame
+    private static final int EOI = 0x0A; // End of frame
+    
+    // Frame types
+    private static final int FRAME_TYPE_STATUS_QUERY = 0x00;
+    private static final int FRAME_TYPE_SINGLE_PALLET = 0x01;
+    private static final int FRAME_TYPE_FULL_PALLET = 0x02;
+    private static final int FRAME_TYPE_OTA_REQUEST = 0xF1;
+    private static final int FRAME_TYPE_OTA_DATA = 0xF2;
+    
+    private boolean isConnected = false;
+
+    // Response classes
+    public static class IOBoardResponse {
+        public boolean success;
+        public String message;
+        
+        public IOBoardResponse(boolean success, String message) {
+            this.success = success;
+            this.message = message;
+        }
+    }
+
+    public static class StatusData {
+        public int doorLockStatus;
+        public SoftwareVersion softwareVersion;
+        
+        public StatusData(int doorLockStatus, SoftwareVersion softwareVersion) {
+            this.doorLockStatus = doorLockStatus;
+            this.softwareVersion = softwareVersion;
+        }
+    }
+
+    public static class SoftwareVersion {
+        public int major;
+        public int minor;
+        public int patch;
+        
+        public SoftwareVersion(int major, int minor, int patch) {
+            this.major = major;
+            this.minor = minor;
+            this.patch = patch;
+        }
+    }
+
+    public static class StatusResponse extends IOBoardResponse {
+        public StatusData data;
+        
+        public StatusResponse(boolean success, String message, StatusData data) {
+            super(success, message);
+            this.data = data;
+        }
+    }
+
+    public static class LEDControl {
+        public int red;
+        public int green;
+        public int blue;
+        public int intensity;
+        public int blinkTimes;
+        public int blinkSpeed;
+        
+        public LEDControl(int red, int green, int blue, int intensity, int blinkTimes, int blinkSpeed) {
+            this.red = Math.max(0, Math.min(255, red));
+            this.green = Math.max(0, Math.min(255, green));
+            this.blue = Math.max(0, Math.min(255, blue));
+            this.intensity = Math.max(0, Math.min(255, intensity));
+            this.blinkTimes = Math.max(0, Math.min(255, blinkTimes));
+            this.blinkSpeed = Math.max(0, Math.min(30, blinkSpeed));
+        }
+    }
+
+    public static class SerialConfig {
+        public String portPath;
+        public int baudRate;
+        public int dataBits;
+        public int stopBits;
+        public String parity;
+        public String flowControl;
+        public int timeout;
+        
+        public SerialConfig(String portPath, int baudRate, int dataBits, int stopBits, String parity, String flowControl, int timeout) {
+            this.portPath = portPath;
+            this.baudRate = baudRate;
+            this.dataBits = dataBits;
+            this.stopBits = stopBits;
+            this.parity = parity;
+            this.flowControl = flowControl;
+            this.timeout = timeout;
+        }
+    }
+
+    // New classes for simplified API
+    public static class DeviceInfo {
+        public int address;
+        public boolean responding;
+        public StatusData status;
+        
+        public DeviceInfo(int address, boolean responding, StatusData status) {
+            this.address = address;
+            this.responding = responding;
+            this.status = status;
+        }
+    }
+
+    public static class ScanResponse extends IOBoardResponse {
+        public DeviceInfo[] devices;
+        
+        public ScanResponse(boolean success, String message, DeviceInfo[] devices) {
+            super(success, message);
+            this.devices = devices;
+        }
+    }
+
+    /**
+     * Calculate CRC-16 CCITT checksum
+     */
+    private int calculateCRC16(int[] data) {
+        int crc = 0xFFFF;
+        
+        for (int dataByte : data) {
+            crc ^= (dataByte << 8);
+            
+            for (int bit = 0; bit < 8; bit++) {
+                if ((crc & 0x8000) != 0) {
+                    crc = (crc << 1) ^ 0x1021;
+                } else {
+                    crc = crc << 1;
+                }
+                crc &= 0xFFFF;
+            }
+        }
+        
+        return crc;
+    }
+
+    /**
+     * Build a command frame for IOBOARD
+     */
+    private int[] buildFrame(int address, int frameType, int[] data) {
+        // Calculate frame size: SOI + Address + FrameType + Data + CRC(2) + EOI
+        int frameSize = 1 + 1 + 1 + data.length + 2 + 1;
+        int[] frame = new int[frameSize];
+        int index = 0;
+        
+        // SOI
+        frame[index++] = SOI;
+        
+        // Address
+        frame[index++] = address;
+        
+        // Frame Type
+        frame[index++] = frameType;
+        
+        // Data
+        for (int dataByte : data) {
+            frame[index++] = dataByte;
+        }
+        
+        // Calculate CRC for address + frameType + data
+        int[] crcData = new int[1 + 1 + data.length];
+        crcData[0] = address;
+        crcData[1] = frameType;
+        System.arraycopy(data, 0, crcData, 2, data.length);
+        
+        int crc = calculateCRC16(crcData);
+        
+        // CRC (high byte first)
+        frame[index++] = (crc >> 8) & 0xFF;
+        frame[index++] = crc & 0xFF;
+        
+        // EOI
+        frame[index] = EOI;
+        
+        return frame;
+    }
+
+    /**
+     * Convert frame to byte array for serial transmission
+     */
+    private byte[] frameToBytes(int[] frame) {
+        byte[] bytes = new byte[frame.length];
+        for (int i = 0; i < frame.length; i++) {
+            bytes[i] = (byte) (frame[i] & 0xFF);
+        }
+        return bytes;
+    }
+
+    /**
+     * Convert frame to hex string for debugging
+     */
+    private String frameToHex(int[] frame) {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < frame.length; i++) {
+            if (i > 0) sb.append(" ");
+            sb.append(String.format("%02X", frame[i]));
+        }
+        return sb.toString();
+    }
+
+    // New simplified API methods
+    
+    /**
+     * Connect to serial port
+     */
+    public IOBoardResponse connect(SerialConfig config) {
+        Log.d(TAG, "Connecting to serial port: " + config.portPath + " at " + config.baudRate + " baud");
+        
+        try {
+            // TODO: Initialize connection with serial port plugin
+            // For now, just set the connected flag
+            isConnected = true;
+            
+            return new IOBoardResponse(true, "Connected to " + config.portPath + " successfully");
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error connecting", e);
+            return new IOBoardResponse(false, "Error connecting: " + e.getMessage());
+        }
+    }
+
+    /**
+     * Disconnect from serial port
+     */
+    public IOBoardResponse disconnect() {
+        Log.d(TAG, "Disconnecting from serial port");
+        
+        try {
+            // TODO: Close connection with serial port plugin
+            isConnected = false;
+            
+            return new IOBoardResponse(true, "Disconnected successfully");
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error disconnecting", e);
+            return new IOBoardResponse(false, "Error disconnecting: " + e.getMessage());
+        }
+    }
+
+    /**
+     * Get status of IOBOARD device
+     */
+    public StatusResponse getStatus(int address, int timeout) {
+        Log.d(TAG, "Getting status for address: " + address + " with timeout: " + timeout + "ms");
+        
+        if (!isConnected) {
+            return new StatusResponse(false, "No serial connection established", null);
+        }
+        
+        try {
+            // Build status query frame
+            int[] frame = buildFrame(address, FRAME_TYPE_STATUS_QUERY, new int[0]);
+            
+            Log.d(TAG, "Sending status query frame: " + frameToHex(frame));
+            
+            // TODO: Send frame via serial port plugin and receive response
+            // For now, return a mock response
+            StatusData mockData = new StatusData(0b11010001, new SoftwareVersion(1, 2, 3));
+            return new StatusResponse(true, "Status retrieved successfully", mockData);
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error getting status", e);
+            return new StatusResponse(false, "Error getting status: " + e.getMessage(), null);
+        }
+    }
+
+    /**
+     * Unlock a specific pallet with LED indication
+     */
+    public IOBoardResponse unlockPallet(int address, int palletNumber, String ledColor, int timeout) {
+        Log.d(TAG, "Unlocking pallet - Address: " + address + ", Pallet: " + palletNumber + ", LED: " + ledColor);
+        
+        if (!isConnected) {
+            return new IOBoardResponse(false, "No serial connection established");
+        }
+        
+        try {
+            // Convert LED color to RGB values
+            LEDControl ledControl = getLEDControlFromColor(ledColor);
+            
+            // Build data array for single pallet control
+            int[] data = new int[8];
+            data[0] = palletNumber;
+            data[1] = 1; // doorLock = true (unlock)
+            data[2] = ledControl.red;
+            data[3] = ledControl.green;
+            data[4] = ledControl.blue;
+            data[5] = ledControl.intensity;
+            data[6] = ledControl.blinkTimes;
+            data[7] = ledControl.blinkSpeed;
+            
+            int[] frame = buildFrame(address, FRAME_TYPE_SINGLE_PALLET, data);
+            
+            Log.d(TAG, "Sending unlock pallet frame: " + frameToHex(frame));
+            
+            // TODO: Send frame via serial port plugin and receive response
+            return new IOBoardResponse(true, "Pallet " + palletNumber + " unlocked successfully");
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error unlocking pallet", e);
+            return new IOBoardResponse(false, "Error unlocking pallet: " + e.getMessage());
+        }
+    }
+
+    /**
+     * Control multiple pallets using a bitmask
+     */
+    public IOBoardResponse controlMultiplePallets(int address, int doorLockMask, String ledColor, int timeout) {
+        Log.d(TAG, "Controlling multiple pallets - Address: " + address + ", Mask: 0x" + Integer.toHexString(doorLockMask));
+        
+        if (!isConnected) {
+            return new IOBoardResponse(false, "No serial connection established");
+        }
+        
+        try {
+            // Convert LED color to RGB values
+            LEDControl ledControl = getLEDControlFromColor(ledColor);
+            
+            // Build data array for full pallet control
+            int[] data = new int[2 + (8 * 6)];
+            int index = 0;
+            
+            data[index++] = doorLockMask;
+            data[index++] = 0; // extendedControl
+            
+            // Add LED controls for 8 pallets
+            for (int i = 0; i < 8; i++) {
+                // If pallet is affected by mask, use specified LED color, otherwise turn off
+                LEDControl led = ((doorLockMask & (1 << i)) != 0) ? ledControl : new LEDControl(0, 0, 0, 0, 0, 0);
+                data[index++] = led.red;
+                data[index++] = led.green;
+                data[index++] = led.blue;
+                data[index++] = led.intensity;
+                data[index++] = led.blinkTimes;
+                data[index++] = led.blinkSpeed;
+            }
+            
+            int[] frame = buildFrame(address, FRAME_TYPE_FULL_PALLET, data);
+            
+            Log.d(TAG, "Sending multiple pallets control frame: " + frameToHex(frame));
+            
+            // TODO: Send frame via serial port plugin and receive response
+            return new IOBoardResponse(true, "Multiple pallets controlled successfully");
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error controlling multiple pallets", e);
+            return new IOBoardResponse(false, "Error controlling multiple pallets: " + e.getMessage());
+        }
+    }
+
+    /**
+     * Scan for devices in address range
+     */
+    public ScanResponse scanDevices(int startAddress, int endAddress, int timeout) {
+        Log.d(TAG, "Scanning devices from address " + startAddress + " to " + endAddress);
+        
+        if (!isConnected) {
+            return new ScanResponse(false, "No serial connection established", null);
+        }
+        
+        try {
+            int deviceCount = endAddress - startAddress + 1;
+            DeviceInfo[] devices = new DeviceInfo[deviceCount];
+            
+            // TODO: Actually scan devices by sending status queries
+            // For now, create mock responses
+            for (int i = 0; i < deviceCount; i++) {
+                int address = startAddress + i;
+                boolean responding = (i % 3 == 0); // Mock: every 3rd device responds
+                StatusData status = responding ? new StatusData(0x00, new SoftwareVersion(1, 0, 0)) : null;
+                devices[i] = new DeviceInfo(address, responding, status);
+            }
+            
+            return new ScanResponse(true, "Scanned addresses " + startAddress + "-" + endAddress, devices);
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error scanning devices", e);
+            return new ScanResponse(false, "Error scanning devices: " + e.getMessage(), null);
+        }
+    }
+
+    /**
+     * Send OTA notification (renamed method)
+     */
+    public IOBoardResponse sendOTANotification(int address, int majorVersion, int minorVersion, int patchVersion, int firmwareSize) {
+        return otaNotification(address, majorVersion, minorVersion, patchVersion, firmwareSize);
+    }
+
+    /**
+     * Send OTA data (renamed method)
+     */
+    public IOBoardResponse sendOTAData(int address, int packetNumber, String dataBase64) {
+        return otaData(address, packetNumber, dataBase64);
+    }
+
+    /**
+     * Helper method to convert color name to LED control
+     */
+    private LEDControl getLEDControlFromColor(String color) {
+        switch (color.toLowerCase()) {
+            case "red":
+                return new LEDControl(255, 0, 0, 255, 0, 0);
+            case "green":
+                return new LEDControl(0, 255, 0, 255, 0, 0);
+            case "blue":
+                return new LEDControl(0, 0, 255, 255, 0, 0);
+            case "yellow":
+                return new LEDControl(255, 255, 0, 255, 0, 0);
+            case "cyan":
+                return new LEDControl(0, 255, 255, 255, 0, 0);
+            case "magenta":
+                return new LEDControl(255, 0, 255, 255, 0, 0);
+            case "white":
+                return new LEDControl(255, 255, 255, 255, 0, 0);
+            case "off":
+                return new LEDControl(0, 0, 0, 0, 0, 0);
+            default:
+                return new LEDControl(0, 255, 0, 255, 0, 0); // Default to green
+        }
+    }
+
+    // Legacy methods (keep for backwards compatibility during transition)
+
+    /**
+     * Query status of IOBOARD device
+     */
+    public StatusResponse queryStatus(int address) {
+        Log.d(TAG, "Querying status for address: " + address);
+        
+        if (!isConnected) {
+            return new StatusResponse(false, "No serial connection established", null);
+        }
+        
+        try {
+            // Build status query frame
+            int[] frame = buildFrame(address, FRAME_TYPE_STATUS_QUERY, new int[0]);
+            
+            Log.d(TAG, "Sending status query frame: " + frameToHex(frame));
+            
+            // TODO: Send frame via serial port plugin and receive response
+            // For now, return a mock response
+            StatusData mockData = new StatusData(0x00, new SoftwareVersion(1, 0, 0));
+            return new StatusResponse(true, "Status queried successfully", mockData);
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error querying status", e);
+            return new StatusResponse(false, "Error querying status: " + e.getMessage(), null);
+        }
+    }
+
+    /**
+     * Control a single pallet
+     */
+    public IOBoardResponse controlSinglePallet(int address, int palletNumber, boolean doorLock, LEDControl ledControl) {
+        Log.d(TAG, "Controlling single pallet - Address: " + address + ", Pallet: " + palletNumber);
+        
+        if (!isConnected) {
+            return new IOBoardResponse(false, "No serial connection established");
+        }
+        
+        try {
+            // Build data array
+            int[] data = new int[8];
+            data[0] = palletNumber;
+            data[1] = doorLock ? 1 : 0;
+            data[2] = ledControl.red;
+            data[3] = ledControl.green;
+            data[4] = ledControl.blue;
+            data[5] = ledControl.intensity;
+            data[6] = ledControl.blinkTimes;
+            data[7] = ledControl.blinkSpeed;
+            
+            int[] frame = buildFrame(address, FRAME_TYPE_SINGLE_PALLET, data);
+            
+            Log.d(TAG, "Sending single pallet control frame: " + frameToHex(frame));
+            
+            // TODO: Send frame via serial port plugin and receive response
+            return new IOBoardResponse(true, "Single pallet controlled successfully");
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error controlling single pallet", e);
+            return new IOBoardResponse(false, "Error controlling single pallet: " + e.getMessage());
+        }
+    }
+
+    /**
+     * Control all pallets
+     */
+    public IOBoardResponse controlFullPallet(int address, int doorLockControl, int extendedControl, LEDControl[] ledControls) {
+        Log.d(TAG, "Controlling full pallet - Address: " + address);
+        
+        if (!isConnected) {
+            return new IOBoardResponse(false, "No serial connection established");
+        }
+        
+        try {
+            // Build data array: doorLockControl + extendedControl + 8 LED controls (6 bytes each)
+            int[] data = new int[2 + (8 * 6)];
+            int index = 0;
+            
+            data[index++] = doorLockControl;
+            data[index++] = extendedControl;
+            
+            // Add LED controls for 8 pallets
+            for (int i = 0; i < 8; i++) {
+                LEDControl led = (i < ledControls.length) ? ledControls[i] : new LEDControl(0, 0, 0, 0, 0, 0);
+                data[index++] = led.red;
+                data[index++] = led.green;
+                data[index++] = led.blue;
+                data[index++] = led.intensity;
+                data[index++] = led.blinkTimes;
+                data[index++] = led.blinkSpeed;
+            }
+            
+            int[] frame = buildFrame(address, FRAME_TYPE_FULL_PALLET, data);
+            
+            Log.d(TAG, "Sending full pallet control frame: " + frameToHex(frame));
+            
+            // TODO: Send frame via serial port plugin and receive response
+            return new IOBoardResponse(true, "Full pallet controlled successfully");
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error controlling full pallet", e);
+            return new IOBoardResponse(false, "Error controlling full pallet: " + e.getMessage());
+        }
+    }
+
+    /**
+     * Send OTA notification
+     */
+    public IOBoardResponse otaNotification(int address, int majorVersion, int minorVersion, int patchVersion, int firmwareSize) {
+        Log.d(TAG, "Sending OTA notification - Address: " + address + ", Version: " + majorVersion + "." + minorVersion + "." + patchVersion);
+        
+        if (!isConnected) {
+            return new IOBoardResponse(false, "No serial connection established");
+        }
+        
+        try {
+            // Build OTA notification data: version(3) + firmware size(4)
+            int[] data = new int[7];
+            data[0] = majorVersion;
+            data[1] = minorVersion;
+            data[2] = patchVersion;
+            data[3] = firmwareSize & 0xFF;
+            data[4] = (firmwareSize >> 8) & 0xFF;
+            data[5] = (firmwareSize >> 16) & 0xFF;
+            data[6] = (firmwareSize >> 24) & 0xFF;
+            
+            int[] frame = buildFrame(address, FRAME_TYPE_OTA_REQUEST, data);
+            
+            Log.d(TAG, "Sending OTA notification frame: " + frameToHex(frame));
+            
+            // TODO: Send frame via serial port plugin and receive response
+            return new IOBoardResponse(true, "OTA notification sent successfully");
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error sending OTA notification", e);
+            return new IOBoardResponse(false, "Error sending OTA notification: " + e.getMessage());
+        }
+    }
+
+    /**
+     * Send OTA data packet
+     */
+    public IOBoardResponse otaData(int address, int packetNumber, String dataBase64) {
+        Log.d(TAG, "Sending OTA data - Address: " + address + ", Packet: " + packetNumber);
+        
+        if (!isConnected) {
+            return new IOBoardResponse(false, "No serial connection established");
+        }
+        
+        try {
+            // Decode base64 data
+            byte[] firmwareData = Base64.decode(dataBase64, Base64.DEFAULT);
+            
+            // Build OTA data: packet number(4) + data
+            int[] data = new int[4 + firmwareData.length];
+            data[0] = packetNumber & 0xFF;
+            data[1] = (packetNumber >> 8) & 0xFF;
+            data[2] = (packetNumber >> 16) & 0xFF;
+            data[3] = (packetNumber >> 24) & 0xFF;
+            
+            for (int i = 0; i < firmwareData.length; i++) {
+                data[4 + i] = firmwareData[i] & 0xFF;
+            }
+            
+            int[] frame = buildFrame(address, FRAME_TYPE_OTA_DATA, data);
+            
+            Log.d(TAG, "Sending OTA data frame: " + frameToHex(frame));
+            
+            // TODO: Send frame via serial port plugin and receive response
+            return new IOBoardResponse(true, "OTA data sent successfully");
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error sending OTA data", e);
+            return new IOBoardResponse(false, "Error sending OTA data: " + e.getMessage());
+        }
+    }
+
+    /**
+     * Open serial connection
+     */
+    public IOBoardResponse openConnection(SerialConfig config) {
+        Log.d(TAG, "Opening serial connection - BaudRate: " + config.baudRate);
+        
+        try {
+            // TODO: Initialize connection with serial port plugin
+            // For now, just set the connected flag
+            isConnected = true;
+            
+            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 serial port plugin
+            isConnected = false;
+            
+            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
+     */
+    public boolean isConnected() {
+        return isConnected;
+    }
+}