@leonardojc/capacitor-ioboard 1.2.8 → 2.0.0

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

@@ -0,0 +1,777 @@
+package com.leonardojc.capacitor.ioboard;
+
+import com.getcapacitor.JSArray;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+import android.util.Log;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.TimeUnit;
+import org.json.JSONObject;
+
+@CapacitorPlugin(name = "CapacitorIoboard")
+public class CapacitorIoboardPlugin extends Plugin implements SerialConnectionManager.SerialDataListener {
+
+    private static final String TAG = "CapacitorIoboard";
+    private SerialConnectionManager serialManager;
+    private IOBoardManager ioboardManager;
+    private CompletableFuture<JSObject> currentCommandFuture;
+
+    @Override
+    public void load() {
+        super.load();
+        Log.d(TAG, "IOBoard Plugin v2.0 loaded - Integrated Serial + Protocol");
+        
+        // Initialize managers
+        serialManager = new SerialConnectionManager();
+        serialManager.setDataListener(this);
+        ioboardManager = new IOBoardManager();
+    }
+
+    // ================== CONNECTION METHODS ==================
+
+    @PluginMethod
+    public void connect(PluginCall call) {
+        String portPath = call.getString("portPath", "/dev/ttyS2");
+        Integer baudRate = call.getInt("baudRate", 115200);
+        Integer dataBits = call.getInt("dataBits", 8);
+        Integer stopBits = call.getInt("stopBits", 1);
+        String parity = call.getString("parity", "none");
+
+        Log.d(TAG, "Connecting to " + portPath + " at " + baudRate + " baud");
+
+        try {
+            boolean success = serialManager.openPort(portPath, baudRate, dataBits, stopBits, parity);
+            
+            if (success) {
+                JSObject result = new JSObject();
+                result.put("success", true);
+                result.put("portPath", portPath);
+                result.put("baudRate", baudRate);
+                result.put("message", "Connected successfully");
+                call.resolve(result);
+                
+                // Notify connection state
+                notifyListeners("connectionStateChanged", result);
+            } else {
+                call.reject("Failed to connect to serial port");
+            }
+        } catch (Exception e) {
+            Log.e(TAG, "Connection error: " + e.getMessage(), e);
+            call.reject("Connection error: " + e.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void disconnect(PluginCall call) {
+        Log.d(TAG, "Disconnecting from serial port");
+        
+        try {
+            serialManager.closePort();
+            
+            JSObject result = new JSObject();
+            result.put("success", true);
+            result.put("message", "Disconnected successfully");
+            call.resolve(result);
+            
+            // Notify disconnection
+            notifyListeners("connectionStateChanged", result);
+        } catch (Exception e) {
+            Log.e(TAG, "Disconnection error: " + e.getMessage(), e);
+            call.reject("Disconnection error: " + e.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void isConnected(PluginCall call) {
+        JSObject result = new JSObject();
+        result.put("connected", serialManager.isConnected());
+        result.put("portPath", serialManager.getCurrentPortPath());
+        call.resolve(result);
+    }
+
+    @PluginMethod
+    public void listPorts(PluginCall call) {
+        try {
+            List<String> ports = serialManager.listAvailablePorts();
+            
+            JSArray portsArray = new JSArray();
+            for (String port : ports) {
+                portsArray.put(port);
+            }
+            
+            JSObject result = new JSObject();
+            result.put("ports", portsArray);
+            result.put("count", ports.size());
+            call.resolve(result);
+        } catch (Exception e) {
+            Log.e(TAG, "Error listing ports: " + e.getMessage(), e);
+            call.reject("Error listing ports: " + e.getMessage());
+        }
+    }
+
+    // ================== IOBoard PROTOCOL METHODS ==================
+
+    @PluginMethod
+    public void getStatus(PluginCall call) {
+        Integer address = call.getInt("address", 1);
+        
+        if (!serialManager.isConnected()) {
+            call.reject("Not connected to serial port");
+            return;
+        }
+        
+        try {
+            Log.d(TAG, "Getting status for device address: " + address);
+            
+            // Build GET_STATUS command
+            byte[] command = ioboardManager.buildCommand("GET_STATUS", address, null);
+            
+            // Send command and wait for response
+            sendCommandAndWaitForResponse(command, call, "GET_STATUS");
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error getting status: " + e.getMessage(), e);
+            call.reject("Error getting status: " + e.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void unlockPallet(PluginCall call) {
+        Integer address = call.getInt("address", 1);
+        Integer palletNumber = call.getInt("palletNumber", 0);
+        Integer red = call.getInt("red", 0);
+        Integer green = call.getInt("green", 255);
+        Integer blue = call.getInt("blue", 0);
+        Integer intensity = call.getInt("intensity", 100);
+        Integer blinkTimes = call.getInt("blinkTimes", 0);
+        Integer blinkSpeed = call.getInt("blinkSpeed", 1);
+        
+        if (!serialManager.isConnected()) {
+            call.reject("Not connected to serial port");
+            return;
+        }
+        
+        try {
+            Log.d(TAG, "Unlocking pallet " + palletNumber + " for device " + address);
+            
+            // Prepare RGB parameters
+            JSObject params = new JSObject();
+            params.put("palletNumber", palletNumber);
+            params.put("red", red);
+            params.put("green", green);
+            params.put("blue", blue);
+            params.put("intensity", intensity);
+            params.put("blinkTimes", blinkTimes);
+            params.put("blinkSpeed", blinkSpeed);
+            
+            // Build UNLOCK_PALLET command
+            byte[] command = ioboardManager.buildCommand("UNLOCK_PALLET", address, params);
+            
+            // Send command and wait for response
+            sendCommandAndWaitForResponse(command, call, "UNLOCK_PALLET");
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error unlocking pallet: " + e.getMessage(), e);
+            call.reject("Error unlocking pallet: " + e.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void controlMultiple(PluginCall call) {
+        Integer address = call.getInt("address", 1);
+        JSArray leds = call.getArray("leds");
+        
+        if (!serialManager.isConnected()) {
+            call.reject("Not connected to serial port");
+            return;
+        }
+        
+        try {
+            Log.d(TAG, "Controlling multiple LEDs for device " + address);
+            
+            // Prepare parameters
+            JSObject params = new JSObject();
+            params.put("leds", leds);
+            
+            // Build CONTROL_MULTIPLE command
+            byte[] command = ioboardManager.buildCommand("CONTROL_MULTIPLE", address, params);
+            
+            // Send command and wait for response
+            sendCommandAndWaitForResponse(command, call, "CONTROL_MULTIPLE");
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error controlling multiple LEDs: " + e.getMessage(), e);
+            call.reject("Error controlling multiple LEDs: " + e.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void startOTAUpdate(PluginCall call) {
+        Integer address = call.getInt("address", 1);
+        String fileName = call.getString("fileName", "firmware.bin");
+        Integer fileSize = call.getInt("fileSize", 0);
+        Integer totalPackets = call.getInt("totalPackets", 0);
+        
+        if (!serialManager.isConnected()) {
+            call.reject("Not connected to serial port");
+            return;
+        }
+        
+        try {
+            Log.d(TAG, "Starting OTA update for device " + address + " - File: " + fileName);
+            
+            // Prepare OTA parameters
+            JSObject params = new JSObject();
+            params.put("fileName", fileName);
+            params.put("fileSize", fileSize);
+            params.put("totalPackets", totalPackets);
+            
+            // Build OTA_NOTIFICATION command
+            byte[] command = ioboardManager.buildCommand("OTA_NOTIFICATION", address, params);
+            
+            // Send command and wait for response
+            sendCommandAndWaitForResponse(command, call, "OTA_NOTIFICATION");
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error starting OTA update: " + e.getMessage(), e);
+            call.reject("Error starting OTA update: " + e.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void sendOTAData(PluginCall call) {
+        Integer address = call.getInt("address", 1);
+        Integer packetNumber = call.getInt("packetNumber", 0);
+        JSArray dataArray = call.getArray("data");
+        
+        if (!serialManager.isConnected()) {
+            call.reject("Not connected to serial port");
+            return;
+        }
+        
+        try {
+            Log.d(TAG, "Sending OTA data packet " + packetNumber + " to device " + address);
+            
+            // Prepare OTA data parameters
+            JSObject params = new JSObject();
+            params.put("packetNumber", packetNumber);
+            params.put("data", dataArray);
+            
+            // Build OTA_DATA command
+            byte[] command = ioboardManager.buildCommand("OTA_DATA", address, params);
+            
+            // Send command and wait for response
+            sendCommandAndWaitForResponse(command, call, "OTA_DATA");
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error sending OTA data: " + e.getMessage(), e);
+            call.reject("Error sending OTA data: " + e.getMessage());
+        }
+    }
+        String command = call.getString("command");
+        Integer address = call.getInt("address");
+        
+        if (command == null || address == null) {
+            call.reject("Command and address are required");
+            return;
+        }
+
+        try {
+            byte[] frame = null;
+            
+            switch (command.toUpperCase()) {
+                case "GET_STATUS":
+                    frame = IOBoardProtocolUtils.createStatusQuery((byte) address.intValue());
+                    break;
+                    
+                case "UNLOCK_PALLET":
+                    Integer palletNumber = call.getInt("palletNumber");
+                    Boolean doorLock = call.getBoolean("doorLock", true); // Default unlock
+                    
+                    // LED RGB parameters with defaults
+                    Integer red = call.getInt("red", 0);           // Default red (0-255)
+                    Integer green = call.getInt("green", 255);     // Default green (0-255)  
+                    Integer blue = call.getInt("blue", 0);         // Default blue (0-255)
+                    Integer intensity = call.getInt("intensity", 100); // Default max intensity (0-100)
+                    Integer blinkTimes = call.getInt("blinkTimes", 0);  // Default no blink (0=no flash, 255=forever)
+                    Integer blinkSpeed = call.getInt("blinkSpeed", 1);  // Default 1 second interval (1-30)
+                    
+                    if (palletNumber == null) {
+                        call.reject("palletNumber is required for UNLOCK_PALLET command");
+                        return;
+                    }
+                    
+                    // Create complete single pallet control frame according to protocol
+                    frame = IOBoardProtocolUtils.createSinglePalletControl(
+                        (byte) address.intValue(),
+                        palletNumber.intValue(),
+                        doorLock.booleanValue(),
+                        red.intValue(),
+                        green.intValue(), 
+                        blue.intValue(),
+                        intensity.intValue(),
+                        blinkTimes.intValue(),
+                        blinkSpeed.intValue()
+                    );
+                    break;
+                    
+                case "CONTROL_MULTIPLE":
+                    Integer doorLockMask = call.getInt("doorLockMask", 0);      // 8-bit mask for door locks
+                    Integer extendedControl = call.getInt("extendedControl", 0); // 8-bit extended control
+                    JSArray ledsArray = call.getArray("leds");                   // Array of 8 LED configurations
+                    
+                    // Parse LED configurations for all 8 pallets
+                    int[][] ledControls = new int[8][6]; // 8 LEDs × 6 parameters each
+                    
+                    for (int i = 0; i < 8; i++) {
+                        // Default LED: off (all zeros except blink speed = 1)
+                        ledControls[i] = new int[]{0, 0, 0, 0, 0, 1};
+                        
+                        if (ledsArray != null && i < ledsArray.length()) {
+                            try {
+                                JSObject ledConfig = ledsArray.getJSObject(i);
+                                if (ledConfig != null) {
+                                    ledControls[i][0] = ledConfig.getInteger("red", 0);           // RGB Red (0-255)
+                                    ledControls[i][1] = ledConfig.getInteger("green", 255);      // RGB Green (0-255)
+                                    ledControls[i][2] = ledConfig.getInteger("blue", 0);         // RGB Blue (0-255)
+                                    ledControls[i][3] = ledConfig.getInteger("intensity", 100);  // Intensity (0-100)
+                                    ledControls[i][4] = ledConfig.getInteger("blinkTimes", 0);   // Blink times (0-255)
+                                    ledControls[i][5] = ledConfig.getInteger("blinkSpeed", 1);   // Blink speed (1-30)
+                                }
+                            } catch (Exception e) {
+                                Log.w(TAG, "Invalid LED config for pallet " + i + ", using defaults");
+                            }
+                        }
+                    }
+                    
+                    // Create complete full pallet control frame according to protocol
+                    frame = IOBoardProtocolUtils.createFullPalletControl(
+                        (byte) address.intValue(),
+                        doorLockMask.intValue(),
+                        extendedControl.intValue(),
+                        ledControls
+                    );
+                    break;
+                    
+                case "OTA_NOTIFICATION":
+                    Integer majorVersion = call.getInt("majorVersion");
+                    Integer minorVersion = call.getInt("minorVersion");
+                    Integer patchVersion = call.getInt("patchVersion");
+                    Integer firmwareSize = call.getInt("firmwareSize");
+                    
+                    if (majorVersion == null || minorVersion == null || patchVersion == null || firmwareSize == null) {
+                        call.reject("All version parameters and firmware size are required for OTA_NOTIFICATION");
+                        return;
+                    }
+                    
+                    // Create OTA notification data payload according to protocol
+                    // Format: Header('?') + Major + Minor + Patch + Size(4 bytes)
+                    byte[] otaData = new byte[8];
+                    otaData[0] = (byte) '?';                               // Notification header
+                    otaData[1] = (byte) majorVersion.intValue();           // Major version (0-99)
+                    otaData[2] = (byte) minorVersion.intValue();           // Minor version (0-99)  
+                    otaData[3] = (byte) patchVersion.intValue();           // Patch version (0-99)
+                    // Firmware size as 4 bytes (little endian)
+                    otaData[4] = (byte) (firmwareSize & 0xFF);
+                    otaData[5] = (byte) ((firmwareSize >> 8) & 0xFF);
+                    otaData[6] = (byte) ((firmwareSize >> 16) & 0xFF);
+                    otaData[7] = (byte) ((firmwareSize >> 24) & 0xFF);
+                    
+                    frame = IOBoardProtocolUtils.createFrame((byte) address.intValue(), IOBoardProtocolUtils.FRAME_TYPE_OTA_REQUEST, otaData);
+                    break;
+                    
+                case "OTA_DATA":
+                    Integer packetNumber = call.getInt("packetNumber");
+                    JSArray dataArray = call.getArray("data");
+                    
+                    if (packetNumber == null || dataArray == null) {
+                        call.reject("packetNumber and data array are required for OTA_DATA");
+                        return;
+                    }
+                    
+                    // Create OTA data payload according to protocol
+                    // Format: PacketNumber(4 bytes) + Data(128 bytes)
+                    byte[] otaDataFrame = new byte[132]; // 4 + 128
+                    
+                    // Packet number as 4 bytes (little endian)
+                    otaDataFrame[0] = (byte) (packetNumber & 0xFF);
+                    otaDataFrame[1] = (byte) ((packetNumber >> 8) & 0xFF);
+                    otaDataFrame[2] = (byte) ((packetNumber >> 16) & 0xFF);
+                    otaDataFrame[3] = (byte) ((packetNumber >> 24) & 0xFF);
+                    
+                    // Copy data (up to 128 bytes, pad with zeros if less)
+                    for (int i = 0; i < 128; i++) {
+                        if (i < dataArray.length()) {
+                            try {
+                                otaDataFrame[4 + i] = (byte) dataArray.getInt(i);
+                            } catch (Exception e) {
+                                otaDataFrame[4 + i] = 0; // Pad with zero on error
+                            }
+                        } else {
+                            otaDataFrame[4 + i] = 0; // Pad remaining with zeros
+                        }
+                    }
+                    
+                    frame = IOBoardProtocolUtils.createFrame((byte) address.intValue(), IOBoardProtocolUtils.FRAME_TYPE_OTA_DATA, otaDataFrame);
+                    break;
+                    
+                default:
+                    call.reject("Unknown command: " + command);
+                    return;
+            }
+            
+            JSObject result = new JSObject();
+            result.put("frame", IOBoardProtocolUtils.frameToHex(frame));
+            result.put("command", command);
+            result.put("address", address);
+            
+            call.resolve(result);
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error building command", e);
+            call.reject("Failed to build command: " + e.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void parseResponse(PluginCall call) {
+        String hexData = call.getString("data");
+        
+        if (hexData == null || hexData.trim().isEmpty()) {
+            call.reject("Data is required");
+            return;
+        }
+
+        try {
+            Log.d(TAG, "Parsing response: " + hexData);
+            
+            IOBoardProtocolUtils.ParsedResponse parsedResponse = IOBoardProtocolUtils.parseResponse(hexData);
+            
+            JSObject result = new JSObject();
+            result.put("valid", parsedResponse.success);
+            result.put("rawData", hexData);
+            result.put("message", parsedResponse.message);
+            
+            if (parsedResponse.success) {
+                result.put("address", parsedResponse.address);
+                result.put("frameType", parsedResponse.frameType);
+                
+                if (parsedResponse.data != null && parsedResponse.data.length > 0) {
+                    result.put("payload", IOBoardProtocolUtils.frameToHex(parsedResponse.data));
+                    
+                    // Parse response data based on frame type
+                    switch (parsedResponse.frameType) {
+                        case IOBoardProtocolUtils.FRAME_TYPE_STATUS_QUERY:
+                            // Status response: LOCK(1) + Version(3)
+                            if (parsedResponse.data.length >= 4) {
+                                result.put("doorLockStatus", parsedResponse.data[0] & 0xFF);
+                                
+                                JSObject version = new JSObject();
+                                version.put("major", parsedResponse.data[1] & 0xFF);
+                                version.put("minor", parsedResponse.data[2] & 0xFF);
+                                version.put("patch", parsedResponse.data[3] & 0xFF);
+                                result.put("softwareVersion", version);
+                            }
+                            break;
+                            
+                        case IOBoardProtocolUtils.FRAME_TYPE_OTA_RESPONSE:
+                            // OTA Response: Header(1) + Code(1) + Data(4)
+                            if (parsedResponse.data.length >= 2) {
+                                char responseHeader = (char) (parsedResponse.data[0] & 0xFF);
+                                int responseCode = parsedResponse.data[1] & 0xFF;
+                                
+                                result.put("otaResponseHeader", String.valueOf(responseHeader));
+                                result.put("otaResponseCode", responseCode);
+                                
+                                // Parse OTA response types
+                                JSObject otaResponse = new JSObject();
+                                switch (responseHeader) {
+                                    case '&': // Area request
+                                        otaResponse.put("type", "area_request");
+                                        if (responseCode == 'A') {
+                                            otaResponse.put("area", "A");
+                                            otaResponse.put("description", "Request A zone firmware");
+                                        } else if (responseCode == 'B') {
+                                            otaResponse.put("area", "B"); 
+                                            otaResponse.put("description", "Request B zone firmware");
+                                        }
+                                        // Parse size confirmation (4 bytes)
+                                        if (parsedResponse.data.length >= 6) {
+                                            int size = (parsedResponse.data[2] & 0xFF) |
+                                                     ((parsedResponse.data[3] & 0xFF) << 8) |
+                                                     ((parsedResponse.data[4] & 0xFF) << 16) |
+                                                     ((parsedResponse.data[5] & 0xFF) << 24);
+                                            otaResponse.put("sizeConfirmation", size);
+                                        }
+                                        break;
+                                        
+                                    case '#': // Data request
+                                        otaResponse.put("type", "data_request");
+                                        // Parse packet number (4 bytes)
+                                        if (parsedResponse.data.length >= 6) {
+                                            int packetNum = (parsedResponse.data[2] & 0xFF) |
+                                                          ((parsedResponse.data[3] & 0xFF) << 8) |
+                                                          ((parsedResponse.data[4] & 0xFF) << 16) |
+                                                          ((parsedResponse.data[5] & 0xFF) << 24);
+                                            otaResponse.put("requestedPacket", packetNum);
+                                            otaResponse.put("description", "Request packet " + packetNum);
+                                        }
+                                        break;
+                                        
+                                    case 'O': // Completion notification
+                                        otaResponse.put("type", "completion");
+                                        otaResponse.put("description", "OTA upgrade completed successfully");
+                                        break;
+                                        
+                                    case 'E': // Failure notification
+                                        otaResponse.put("type", "error");
+                                        String errorDesc = "Unknown error";
+                                        switch (responseCode) {
+                                            case 9: errorDesc = "Illegal version/firmware size"; break;
+                                            case 8: errorDesc = "Non-OTA status"; break;
+                                            case 7: errorDesc = "Write failed"; break;
+                                            case 6: errorDesc = "Verification failed"; break;
+                                            case 5: errorDesc = "Transfer failed"; break;
+                                        }
+                                        otaResponse.put("errorCode", responseCode);
+                                        otaResponse.put("description", errorDesc);
+                                        break;
+                                }
+                                result.put("otaResponse", otaResponse);
+                            }
+                            break;
+                            
+                        default:
+                            // For other frame types, just include raw payload
+                            result.put("frameTypeName", getFrameTypeName(parsedResponse.frameType));
+                            break;
+                    }
+                }
+            }
+            
+            call.resolve(result);
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error parsing response", e);
+            call.reject("Failed to parse response: " + e.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void validateFrame(PluginCall call) {
+        String hexData = call.getString("data");
+        
+        if (hexData == null || hexData.trim().isEmpty()) {
+            call.reject("Data is required");
+            return;
+        }
+
+        try {
+            // Use parseResponse to validate the frame
+            IOBoardProtocolUtils.ParsedResponse parsed = IOBoardProtocolUtils.parseResponse(hexData);
+            
+            JSObject result = new JSObject();
+            result.put("valid", parsed.success);
+            result.put("data", hexData);
+            result.put("message", parsed.message);
+            
+            if (parsed.success) {
+                byte[] frameData = IOBoardProtocolUtils.hexStringToBytes(hexData);
+                result.put("length", frameData.length);
+            }
+            
+            call.resolve(result);
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error validating frame", e);
+            call.reject("Failed to validate frame: " + e.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void hexToBytes(PluginCall call) {
+        String hexData = call.getString("data");
+        
+        if (hexData == null || hexData.trim().isEmpty()) {
+            call.reject("Data is required");
+            return;
+        }
+
+        try {
+            byte[] bytes = IOBoardProtocolUtils.hexStringToBytes(hexData);
+            
+            // Convert byte array to JSArray of integers
+            JSArray bytesArray = new JSArray();
+            for (byte b : bytes) {
+                bytesArray.put((int) b & 0xFF); // Convert to unsigned int
+            }
+            
+            JSObject result = new JSObject();
+            result.put("bytes", bytesArray);
+            result.put("length", bytes.length);
+            result.put("hex", hexData);
+            
+            call.resolve(result);
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error converting hex to bytes", e);
+            call.reject("Failed to convert hex to bytes: " + e.getMessage());
+        }
+    }
+
+    @PluginMethod
+    public void bytesToHex(PluginCall call) {
+        JSArray bytesArray = call.getArray("bytes");
+        
+        if (bytesArray == null) {
+            call.reject("Bytes array is required");
+            return;
+        }
+
+        try {
+            byte[] bytes = new byte[bytesArray.length()];
+            for (int i = 0; i < bytesArray.length(); i++) {
+                bytes[i] = (byte) bytesArray.getInt(i);
+            }
+            
+            String hexString = IOBoardProtocolUtils.frameToHex(bytes);
+            
+            // Convert byte array back to JSArray for consistency
+            JSArray resultBytesArray = new JSArray();
+            for (byte b : bytes) {
+                resultBytesArray.put((int) b & 0xFF);
+            }
+            
+            JSObject result = new JSObject();
+            result.put("hex", hexString);
+            result.put("length", bytes.length);
+            result.put("bytes", resultBytesArray);
+            
+            call.resolve(result);
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error converting bytes to hex", e);
+            call.reject("Failed to convert bytes to hex: " + e.getMessage());
+        }
+    }
+    
+    // ================== HELPER METHODS ==================
+    
+    /**
+     * Sends a command and waits for response
+     */
+    private void sendCommandAndWaitForResponse(byte[] command, PluginCall call, String commandType) {
+        try {
+            // Set up future for response
+            currentCommandFuture = new CompletableFuture<>();
+            
+            // Send command
+            boolean sent = serialManager.writeData(command);
+            if (!sent) {
+                call.reject("Failed to send command");
+                return;
+            }
+            
+            // Wait for response with timeout
+            JSObject response = currentCommandFuture.get(5, TimeUnit.SECONDS);
+            call.resolve(response);
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error in sendCommandAndWaitForResponse: " + e.getMessage(), e);
+            call.reject("Command timeout or error: " + e.getMessage());
+        } finally {
+            currentCommandFuture = null;
+        }
+    }
+
+    // ================== SERIAL DATA LISTENER IMPLEMENTATION ==================
+
+    @Override
+    public void onDataReceived(byte[] data) {
+        try {
+            Log.d(TAG, "Received " + data.length + " bytes from serial port");
+            
+            // Parse the response using IOBoardManager
+            JSObject response = ioboardManager.parseResponse(data);
+            
+            // Complete the current command future if waiting
+            if (currentCommandFuture != null && !currentCommandFuture.isDone()) {
+                currentCommandFuture.complete(response);
+            }
+            
+            // Notify listeners
+            JSObject eventData = new JSObject();
+            eventData.put("data", response);
+            eventData.put("rawBytes", Arrays.toString(data));
+            notifyListeners("dataReceived", eventData);
+            
+        } catch (Exception e) {
+            Log.e(TAG, "Error processing received data: " + e.getMessage(), e);
+            
+            // Complete future with error if waiting
+            if (currentCommandFuture != null && !currentCommandFuture.isDone()) {
+                JSObject errorResponse = new JSObject();
+                errorResponse.put("success", false);
+                errorResponse.put("error", "Parse error: " + e.getMessage());
+                currentCommandFuture.complete(errorResponse);
+            }
+        }
+    }
+
+    @Override
+    public void onConnectionStateChanged(boolean connected) {
+        Log.d(TAG, "Connection state changed: " + (connected ? "Connected" : "Disconnected"));
+        
+        JSObject eventData = new JSObject();
+        eventData.put("connected", connected);
+        eventData.put("portPath", serialManager.getCurrentPortPath());
+        notifyListeners("connectionStateChanged", eventData);
+    }
+
+    @Override
+    public void onError(String error) {
+        Log.e(TAG, "Serial connection error: " + error);
+        
+        JSObject eventData = new JSObject();
+        eventData.put("error", error);
+        notifyListeners("serialError", eventData);
+        
+        // Complete future with error if waiting
+        if (currentCommandFuture != null && !currentCommandFuture.isDone()) {
+            JSObject errorResponse = new JSObject();
+            errorResponse.put("success", false);
+            errorResponse.put("error", error);
+            currentCommandFuture.complete(errorResponse);
+        }
+    }
+
+    @Override
+    public void onDestroy() {
+        super.onDestroy();
+        Log.d(TAG, "Plugin destroying - cleaning up resources");
+        
+        if (serialManager != null) {
+            serialManager.cleanup();
+        }
+    }
+    
+    /**
+     * Helper method to get frame type name
+     */
+    private String getFrameTypeName(byte frameType) {
+        switch (frameType) {
+            case IOBoardProtocolUtils.FRAME_TYPE_STATUS_QUERY: return "STATUS_QUERY";
+            case IOBoardProtocolUtils.FRAME_TYPE_SINGLE_PALLET: return "SINGLE_PALLET"; 
+            case IOBoardProtocolUtils.FRAME_TYPE_FULL_PALLET: return "FULL_PALLET";
+            case IOBoardProtocolUtils.FRAME_TYPE_OTA_REQUEST: return "OTA_REQUEST";
+            case IOBoardProtocolUtils.FRAME_TYPE_OTA_DATA: return "OTA_DATA";
+            case IOBoardProtocolUtils.FRAME_TYPE_OTA_RESPONSE: return "OTA_RESPONSE";
+            default: return "UNKNOWN_0x" + String.format("%02X", frameType & 0xFF);
+        }
+    }
+}