@nitra/zebra 6.1.3 → 6.1.5

package/android/src/main/java/com/nitra/zebra_printer_plugin/ZebraPrinter.java

@@ -0,0 +1,1345 @@
+package com.nitra.zebra_printer_plugin;
+
+import android.Manifest;
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothGatt;
+import android.bluetooth.BluetoothGattCallback;
+import android.bluetooth.BluetoothGattCharacteristic;
+import android.bluetooth.BluetoothGattService;
+import android.bluetooth.BluetoothManager;
+import android.bluetooth.BluetoothProfile;
+import android.bluetooth.BluetoothSocket;
+import android.bluetooth.le.BluetoothLeScanner;
+import android.bluetooth.le.ScanCallback;
+import android.bluetooth.le.ScanResult;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.pm.PackageManager;
+import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
+
+import androidx.core.app.ActivityCompat;
+import androidx.core.content.ContextCompat;
+
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+import com.getcapacitor.annotation.Permission;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+@CapacitorPlugin(name = "ZebraPrinter", permissions = {
+        @Permission(alias = "bluetooth", strings = {
+                Manifest.permission.BLUETOOTH,
+                Manifest.permission.BLUETOOTH_ADMIN,
+                Manifest.permission.BLUETOOTH_CONNECT,
+                Manifest.permission.BLUETOOTH_SCAN,
+                Manifest.permission.ACCESS_FINE_LOCATION,
+                Manifest.permission.ACCESS_COARSE_LOCATION
+        })
+})
+public class ZebraPrinter extends Plugin {
+
+    private static final String TAG = "ZebraPrinterPlugin";
+
+    // SPP UUID for classic Bluetooth
+    private static final UUID SPP_UUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");
+
+    // BLE UUIDs for Zebra printers
+    private static final UUID ZEBRA_SERVICE_UUID = UUID.fromString("0000FF00-0000-1000-8000-00805F9B34FB");
+    private static final UUID ZEBRA_CHARACTERISTIC_UUID = UUID.fromString("0000FF01-0000-1000-8000-00805F9B34FB");
+
+    private BluetoothManager bluetoothManager;
+    private BluetoothAdapter bluetoothAdapter;
+    private BluetoothLeScanner bluetoothLeScanner;
+    private BluetoothGatt bluetoothGatt;
+    private BluetoothGattCharacteristic printerCharacteristic;
+
+    private List<BluetoothDevice> discoveredDevices = new ArrayList<>();
+    private boolean isScanning = false;
+    private boolean isConnected = false;
+    private String connectedPrinterAddress;
+
+    // MTU size for BLE
+    private static final int BLE_MTU_SIZE = 20;
+
+    // CRITICAL FIX: Async chunk sending system
+    private boolean isWriting = false;
+    private byte[] currentData;
+    private int currentOffset = 0;
+    private PluginCall currentPrintCall;
+
+    // SPP support for fallback
+    private BluetoothSocket sppSocket;
+    private OutputStream sppOutputStream;
+    private boolean useSPP = false;
+
+    @Override
+    public void load() {
+        super.load();
+        Log.d(TAG, "🔧 Loading NitraZebraPlugin...");
+
+        bluetoothManager = (BluetoothManager) getContext().getSystemService(Context.BLUETOOTH_SERVICE);
+        bluetoothAdapter = bluetoothManager.getAdapter();
+
+        if (bluetoothAdapter != null) {
+            bluetoothLeScanner = bluetoothAdapter.getBluetoothLeScanner();
+            Log.d(TAG, "✅ Bluetooth adapter initialized");
+
+            // Register Classic Bluetooth discovery receiver
+            IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
+            filter.addAction(BluetoothDevice.ACTION_BOND_STATE_CHANGED);
+            getContext().registerReceiver(bluetoothReceiver, filter);
+            Log.d(TAG, "✅ Classic Bluetooth discovery and bonding receiver registered");
+        } else {
+            Log.e(TAG, "❌ Bluetooth not supported");
+        }
+    }
+
+    @PluginMethod
+    public void checkPermissions(PluginCall call) {
+        Log.d(TAG, "🔍 Checking permissions...");
+
+        boolean hasAllPermissions = true;
+        List<String> missingPermissions = new ArrayList<>();
+
+        // Check basic Bluetooth permissions
+        if (ContextCompat.checkSelfPermission(getContext(),
+                Manifest.permission.BLUETOOTH) != PackageManager.PERMISSION_GRANTED) {
+            hasAllPermissions = false;
+            missingPermissions.add(Manifest.permission.BLUETOOTH);
+        }
+
+        if (ContextCompat.checkSelfPermission(getContext(),
+                Manifest.permission.BLUETOOTH_ADMIN) != PackageManager.PERMISSION_GRANTED) {
+            hasAllPermissions = false;
+            missingPermissions.add(Manifest.permission.BLUETOOTH_ADMIN);
+        }
+
+        // Check location permissions (required for BLE scanning)
+        if (ContextCompat.checkSelfPermission(getContext(),
+                Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
+            hasAllPermissions = false;
+            missingPermissions.add(Manifest.permission.ACCESS_FINE_LOCATION);
+        }
+
+        // Check Android 12+ Bluetooth permissions
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            if (ContextCompat.checkSelfPermission(getContext(),
+                    Manifest.permission.BLUETOOTH_CONNECT) != PackageManager.PERMISSION_GRANTED) {
+                hasAllPermissions = false;
+                missingPermissions.add(Manifest.permission.BLUETOOTH_CONNECT);
+            }
+
+            if (ContextCompat.checkSelfPermission(getContext(),
+                    Manifest.permission.BLUETOOTH_SCAN) != PackageManager.PERMISSION_GRANTED) {
+                hasAllPermissions = false;
+                missingPermissions.add(Manifest.permission.BLUETOOTH_SCAN);
+            }
+        }
+
+        JSObject result = new JSObject();
+        result.put("hasPermissions", hasAllPermissions);
+        result.put("missingPermissions", missingPermissions.toArray(new String[0]));
+        result.put("bluetoothSupported", bluetoothAdapter != null);
+        result.put("bleSupported",
+                getContext().getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE));
+
+        call.resolve(result);
+    }
+
+    @PluginMethod
+    public void requestPermissions(PluginCall call) {
+        Log.d(TAG, "🔐 Requesting permissions...");
+
+        List<String> permissionsToRequest = new ArrayList<>();
+
+        // Add basic Bluetooth permissions
+        permissionsToRequest.add(Manifest.permission.BLUETOOTH);
+        permissionsToRequest.add(Manifest.permission.BLUETOOTH_ADMIN);
+        permissionsToRequest.add(Manifest.permission.ACCESS_FINE_LOCATION);
+        permissionsToRequest.add(Manifest.permission.ACCESS_COARSE_LOCATION);
+
+        // Add Android 12+ Bluetooth permissions
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            permissionsToRequest.add(Manifest.permission.BLUETOOTH_CONNECT);
+            permissionsToRequest.add(Manifest.permission.BLUETOOTH_SCAN);
+        }
+
+        requestPermissionForAliases(permissionsToRequest.toArray(new String[0]), call, "permissionsCallback");
+    }
+
+    @PluginMethod
+    public void echo(PluginCall call) {
+        String value = call.getString("value");
+        if (value == null)
+            value = "";
+        JSObject result = new JSObject();
+        result.put("value", value);
+        call.resolve(result);
+    }
+
+    @PluginMethod
+    public void initialize(PluginCall call) {
+        Log.d(TAG, "🔧 Initializing Zebra printer plugin...");
+
+        // Initialize Bluetooth adapter if not already initialized
+        if (bluetoothAdapter == null) {
+            bluetoothManager = (BluetoothManager) getContext().getSystemService(Context.BLUETOOTH_SERVICE);
+            bluetoothAdapter = bluetoothManager.getAdapter();
+
+            if (bluetoothAdapter != null) {
+                bluetoothLeScanner = bluetoothAdapter.getBluetoothLeScanner();
+                Log.d(TAG, "✅ Bluetooth adapter initialized");
+            } else {
+                Log.e(TAG, "❌ Bluetooth not supported");
+                call.reject("Initialization failed", "Bluetooth not supported");
+                return;
+            }
+        }
+
+        JSObject result = new JSObject();
+        result.put("success", true);
+        result.put("message", "Zebra printer plugin initialized");
+        result.put("bluetoothSupported", bluetoothAdapter != null);
+        result.put("bluetoothEnabled", bluetoothAdapter != null && bluetoothAdapter.isEnabled());
+        call.resolve(result);
+    }
+
+    @PluginMethod
+    public void sendRawCommand(PluginCall call) {
+        String command = call.getString("command");
+        if (command == null || command.isEmpty()) {
+            call.reject("Invalid command", "Command cannot be empty");
+            return;
+        }
+
+        Log.d(TAG, "📤 Sending RAW command: " + command);
+
+        // Check printer status first
+        if (!isConnected) {
+            Log.e(TAG, "❌ Not connected to printer");
+            call.reject("Send failed", "Not connected to printer");
+            return;
+        }
+
+        // Check if we have either BLE characteristic or SPP connection
+        if (!useSPP && printerCharacteristic == null) {
+            Log.e(TAG, "❌ No BLE characteristic available");
+            call.reject("Send failed", "No BLE characteristic available");
+            return;
+        }
+
+        // CRITICAL FIX: Store call reference for async completion
+        currentPrintCall = call;
+
+        // Send raw command directly to printer using async chunking
+        if (sendDataToPrinter(command)) {
+            Log.d(TAG, "✅ Started sending RAW command (async)");
+            // Don't resolve here - wait for sendNextChunkAsync to complete
+        } else {
+            Log.e(TAG, "❌ Failed to start sending RAW command");
+            currentPrintCall = null;
+            call.reject("Send failed", "Failed to start sending RAW command to printer");
+        }
+    }
+
+    @PluginMethod
+    public void connectToPrinter(PluginCall call) {
+        Log.d(TAG, "🔌 ConnectToPrinter method called");
+
+        String name = call.getString("name");
+        String address = call.getString("address");
+        String type = call.getString("type", "bluetooth");
+
+        Log.d(TAG, "📱 Connection request - Name: " + (name != null ? name : "none") +
+                ", Address: " + (address != null ? address : "none") +
+                ", Type: " + type);
+
+        // For Android, we only support Bluetooth connections
+        if (!"bluetooth".equals(type)) {
+            call.reject("Unsupported connection type", "Android only supports Bluetooth connections");
+            return;
+        }
+
+        // If address is provided, try to connect to specific device
+        if (address != null && !address.isEmpty()) {
+            // Find device with matching address
+            BluetoothDevice targetDevice = null;
+            for (BluetoothDevice device : discoveredDevices) {
+                if (address.equals(device.getAddress())) {
+                    targetDevice = device;
+                    break;
+                }
+            }
+
+            // If not found in discovered devices, try to get from paired devices
+            if (targetDevice == null && bluetoothAdapter != null) {
+                if (ActivityCompat.checkSelfPermission(getContext(),
+                        Manifest.permission.BLUETOOTH_CONNECT) == PackageManager.PERMISSION_GRANTED) {
+                    for (BluetoothDevice device : bluetoothAdapter.getBondedDevices()) {
+                        if (address.equals(device.getAddress())) {
+                            targetDevice = device;
+                            discoveredDevices.add(device);
+                            break;
+                        }
+                    }
+                }
+            }
+
+            if (targetDevice != null) {
+                Log.d(TAG, "🔌 Connecting to specific printer: " + targetDevice.getName());
+                connectToDevice(targetDevice);
+                JSObject result = new JSObject();
+                result.put("success", true);
+                result.put("connected", false);
+                result.put("name", targetDevice.getName());
+                result.put("address", address);
+                result.put("type", "bluetooth");
+                result.put("message", "Connecting to printer...");
+                call.resolve(result);
+                return;
+            } else {
+                call.reject("Printer not found", "Printer with address " + address + " not found");
+                return;
+            }
+        }
+
+        // If no address provided, try to connect to first available printer
+        if (!discoveredDevices.isEmpty()) {
+            BluetoothDevice firstPrinter = discoveredDevices.get(0);
+            Log.d(TAG, "🔌 Connecting to first available printer: " + firstPrinter.getName());
+            connectToDevice(firstPrinter);
+            JSObject result = new JSObject();
+            result.put("success", true);
+            result.put("connected", false);
+            result.put("name", firstPrinter.getName());
+            result.put("address", firstPrinter.getAddress());
+            result.put("type", "bluetooth");
+            result.put("message", "Connecting to printer...");
+            call.resolve(result);
+        } else {
+            Log.e(TAG, "❌ No printers discovered");
+            call.reject("No printers found", "No Zebra printers discovered. Please scan for printers first.");
+        }
+    }
+
+    @PluginMethod
+    public void printText(PluginCall call) {
+        String text = call.getString("text");
+        if (text == null)
+            text = "";
+        Integer fontSize = call.getInt("fontSize");
+        Boolean bold = call.getBoolean("bold");
+        String alignment = call.getString("alignment");
+
+        Log.d(TAG, "🖨️ Printing text: " + text);
+
+        // CRITICAL FIX: Check connection status and verify socket is still connected
+        if (!isConnected) {
+            Log.e(TAG, "❌ Not connected to printer");
+            call.reject("Print failed", "Not connected to printer");
+            return;
+        }
+
+        // CRITICAL FIX: Verify SPP socket is still connected
+        // But don't disconnect immediately - try to reconnect first
+        if (useSPP && sppSocket != null) {
+            try {
+                if (!sppSocket.isConnected()) {
+                    Log.w(TAG, "⚠️ SPP socket is not connected, will try to reconnect");
+                    // CRITICAL FIX: Don't disconnect immediately - try to reconnect first
+                    // Keep connection status until reconnection attempt completes
+
+                    // Try to reconnect if we have device address
+                    if (connectedPrinterAddress != null && bluetoothAdapter != null) {
+                        Log.d(TAG, "🔄 Attempting to reconnect to: " + connectedPrinterAddress);
+                        try {
+                            BluetoothDevice device = bluetoothAdapter.getRemoteDevice(connectedPrinterAddress);
+                            if (device != null) {
+                                // CRITICAL FIX: Reconnect synchronously to ensure it completes before continuing
+                                // Don't start background thread - reconnect directly
+                                boolean reconnected = connectSPP(device);
+                                
+                                if (reconnected && sppSocket != null && sppSocket.isConnected()) {
+                                    Log.d(TAG, "✅ Socket reconnected, continuing with print");
+                                    // CRITICAL FIX: Ensure isConnected is set after successful reconnection
+                                    if (!isConnected) {
+                                        isConnected = true;
+                                        useSPP = true;
+                                        Log.d(TAG, "✅ Connection status updated after reconnection");
+                                    }
+                                    // Continue with print - don't reject
+                                } else {
+                                    Log.w(TAG, "⚠️ Reconnection failed or socket still not connected");
+                                    // CRITICAL FIX: Only disconnect if reconnection definitively failed
+                                    // Check if socket is actually invalid before disconnecting
+                                    boolean socketInvalid = true;
+                                    if (sppSocket != null) {
+                                        try {
+                                            if (sppSocket.isConnected()) {
+                                                // Socket is connected, keep connection alive
+                                                socketInvalid = false;
+                                                if (!isConnected) {
+                                                    isConnected = true;
+                                                    useSPP = true;
+                                                    Log.d(TAG, "✅ Connection status updated - socket is valid");
+                                                }
+                                            } else {
+                                                // Try to verify socket is actually invalid
+                                                try {
+                                                    sppSocket.getRemoteDevice();
+                                                    // If we can get remote device, socket might still be valid
+                                                    socketInvalid = false;
+                                                    if (!isConnected) {
+                                                        isConnected = true;
+                                                        useSPP = true;
+                                                        Log.d(TAG, "✅ Connection status updated - socket might be valid");
+                                                    }
+                                                } catch (Exception e) {
+                                                    // Socket is definitely invalid
+                                                    socketInvalid = true;
+                                                }
+                                            }
+                                        } catch (Exception e) {
+                                            // Error checking socket status, assume invalid
+                                            Log.e(TAG, "❌ Error checking socket status: " + e.getMessage());
+                                            socketInvalid = true;
+                                        }
+                                    }
+
+                                    if (socketInvalid) {
+                                        // Close invalid socket only if reconnection didn't work
+                                        if (sppSocket != null) {
+                                            try {
+                                                sppSocket.close();
+                                            } catch (IOException closeException) {
+                                                Log.e(TAG, "❌ Error closing invalid socket", closeException);
+                                            }
+                                            sppSocket = null;
+                                        }
+
+                                        useSPP = false;
+                                        isConnected = false;
+
+                                        call.reject("Print failed",
+                                                "SPP socket is not connected. Reconnection failed.");
+                                        return;
+                                    } else {
+                                        // Socket is valid, continue with print
+                                        Log.d(TAG, "✅ Socket is valid, continuing with print");
+                                    }
+                                }
+                            } else {
+                                // No device found, disconnect
+                                isConnected = false;
+                                useSPP = false;
+                                if (sppSocket != null) {
+                                    try {
+                                        sppSocket.close();
+                                    } catch (IOException closeException) {
+                                        Log.e(TAG, "❌ Error closing invalid socket", closeException);
+                                    }
+                                    sppSocket = null;
+                                    sppOutputStream = null;
+                                }
+                                call.reject("Print failed", "SPP socket is not connected and device not found");
+                                return;
+                            }
+                        } catch (Exception reconnectException) {
+                            Log.e(TAG, "❌ Error during reconnection attempt: " + reconnectException.getMessage());
+                            // Disconnect only if reconnection definitively failed
+                            isConnected = false;
+                            useSPP = false;
+                            if (sppSocket != null) {
+                                try {
+                                    sppSocket.close();
+                                } catch (IOException closeException) {
+                                    Log.e(TAG, "❌ Error closing invalid socket", closeException);
+                                }
+                                sppSocket = null;
+                                sppOutputStream = null;
+                            }
+                            call.reject("Print failed", "SPP socket is not connected. Reconnection failed.");
+                            return;
+                        }
+                    } else {
+                        // No address or adapter, disconnect
+                        isConnected = false;
+                        useSPP = false;
+                        if (sppSocket != null) {
+                            try {
+                                sppSocket.close();
+                            } catch (IOException closeException) {
+                                Log.e(TAG, "❌ Error closing invalid socket", closeException);
+                            }
+                            sppSocket = null;
+                            sppOutputStream = null;
+                        }
+                        call.reject("Print failed", "SPP socket is not connected and no device address available");
+                        return;
+                    }
+                }
+            } catch (Exception e) {
+                Log.e(TAG, "❌ Error checking SPP socket connection: " + e.getMessage());
+                // Don't disconnect on check error - socket might still be valid
+                // Only disconnect if we're sure socket is invalid
+                Log.w(TAG, "⚠️ Socket check failed, but keeping connection alive");
+            }
+        }
+
+        // Check if we have either BLE characteristic or SPP connection
+        if (!useSPP && printerCharacteristic == null) {
+            Log.e(TAG, "❌ No BLE characteristic available");
+            call.reject("Print failed", "No BLE characteristic available");
+            return;
+        }
+
+        // CRITICAL FIX: Check if it's already a ZPL command
+        String dataToSend;
+        if (text.startsWith("^XA") || text.startsWith("~") || text.startsWith("!")) {
+            // It's already a ZPL/CPCL command - send it RAW
+            Log.d(TAG, "📤 Sending RAW ZPL/CPCL command...");
+            dataToSend = text;
+        } else {
+            // It's plain text - create ZPL wrapper with proper formatting
+            Log.d(TAG, "📤 Converting plain text to ZPL...");
+            int x = "center".equals(alignment) ? 200 : ("right".equals(alignment) ? 350 : 50);
+            String fontStyle = (bold != null && bold) ? "B" : "N";
+            int size = (fontSize != null) ? fontSize : 12;
+            // Improved ZPL command with proper line breaks and formatting
+            dataToSend = "^XA\n^FO" + x + ",50^A0" + fontStyle + "," + size + "," + size + "^FD" + text + "^FS\n^XZ";
+        }
+
+        Log.d(TAG, "📦 Final data to send: " + dataToSend);
+
+        // CRITICAL FIX: Store call reference for async completion
+        currentPrintCall = call;
+
+        // Send to printer using async chunking system
+        if (sendDataToPrinter(dataToSend)) {
+            Log.d(TAG, "✅ Started sending data (async)");
+            // Don't resolve here - wait for sendNextChunkAsync to complete
+        } else {
+            Log.e(TAG, "❌ Failed to start sending data");
+            currentPrintCall = null;
+            call.reject("Print failed", "Failed to start sending data to printer");
+        }
+    }
+
+    // ASYNC: Async sendDataToPrinter with proper callback handling
+    private boolean sendDataToPrinter(String data) {
+        if (!isConnected) {
+            Log.e(TAG, "❌ Not connected to printer");
+            return false;
+        }
+
+        // Use SPP if available (more reliable for printing)
+        if (useSPP && sppOutputStream != null) {
+            Log.d(TAG, "📤 Using SPP for data transmission");
+            return sendDataToPrinterSPP(data);
+        }
+
+        // Fallback to BLE with async chunking
+        if (printerCharacteristic == null) {
+            Log.e(TAG, "❌ No BLE characteristic available");
+            return false;
+        }
+
+        try {
+            currentData = data.getBytes("UTF-8");
+            currentOffset = 0;
+            isWriting = false;
+
+            Log.d(TAG, "📏 Total data size: " + currentData.length + " bytes");
+            Log.d(TAG, "📏 MTU size: " + BLE_MTU_SIZE + " bytes");
+
+            // Start async chunking
+            sendNextChunkAsync();
+            return true;
+
+        } catch (Exception e) {
+            Log.e(TAG, "❌ Error preparing data for printer", e);
+            return false;
+        }
+    }
+
+    // ASYNC: Send next chunk with proper async handling
+    private void sendNextChunkAsync() {
+        if (currentOffset >= currentData.length) {
+            // All chunks sent successfully
+            Log.d(TAG, "✅ All data sent successfully");
+            Log.d(TAG, "📋 Data length: " + currentData.length + " bytes");
+
+            // Resolve the call
+            if (currentPrintCall != null) {
+                JSObject result = new JSObject();
+                result.put("success", true);
+                result.put("message", "Data sent to printer successfully");
+                result.put("bytes", currentData.length);
+                result.put("processed", true);
+                currentPrintCall.resolve(result);
+                currentPrintCall = null;
+            }
+            return;
+        }
+
+        if (isWriting) {
+            Log.d(TAG, "⏳ Still writing previous chunk, waiting...");
+            // Retry after delay
+            new Handler(Looper.getMainLooper()).postDelayed(() -> {
+                sendNextChunkAsync();
+            }, 50);
+            return;
+        }
+
+        int chunkSize = Math.min(BLE_MTU_SIZE, currentData.length - currentOffset);
+        byte[] chunk = new byte[chunkSize];
+        System.arraycopy(currentData, currentOffset, chunk, 0, chunkSize);
+
+        Log.d(TAG, "📤 Sending chunk at offset " + currentOffset + ": " + chunkSize + " bytes");
+
+        printerCharacteristic.setValue(chunk);
+        printerCharacteristic.setWriteType(BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT);
+
+        isWriting = true;
+        boolean writeResult = bluetoothGatt.writeCharacteristic(printerCharacteristic);
+        Log.d(TAG, "📤 Write result: " + writeResult);
+
+        if (!writeResult) {
+            Log.e(TAG, "❌ Failed to write characteristic at offset " + currentOffset);
+            isWriting = false;
+
+            // Retry after delay
+            new Handler(Looper.getMainLooper()).postDelayed(() -> {
+                Log.d(TAG, "🔄 Retrying chunk at offset " + currentOffset);
+                sendNextChunkAsync();
+            }, 100);
+        }
+        // If writeResult is true, wait for onCharacteristicWrite callback
+    }
+
+    @PluginMethod
+    public void getStatus(PluginCall call) {
+        JSObject result = new JSObject();
+        result.put("connected", isConnected);
+        result.put("status", isConnected ? "connected" : "disconnected");
+        if (isConnected) {
+            result.put("printerAddress", connectedPrinterAddress);
+            result.put("printerType", useSPP ? "spp" : "ble");
+            result.put("connectionMethod", useSPP ? "SPP (Classic Bluetooth)" : "BLE (Bluetooth Low Energy)");
+        }
+        call.resolve(result);
+    }
+
+    // NEW: Check printer status with ZPL command
+    @PluginMethod
+    public void checkPrinterStatus(PluginCall call) {
+        if (!isConnected) {
+            call.reject("Status check failed", "Not connected to printer");
+            return;
+        }
+
+        // Check if we have either BLE characteristic or SPP connection
+        if (!useSPP && printerCharacteristic == null) {
+            call.reject("Status check failed", "No BLE characteristic available");
+            return;
+        }
+
+        // Send printer status command
+        String statusCommand = "~HS"; // Zebra printer status command
+        Log.d(TAG, "🔍 Sending status command: " + statusCommand);
+
+        if (sendDataToPrinter(statusCommand)) {
+            JSObject result = new JSObject();
+            result.put("success", true);
+            result.put("message", "Status command sent");
+            result.put("command", statusCommand);
+            result.put("connectionType", useSPP ? "SPP" : "BLE");
+            call.resolve(result);
+        } else {
+            call.reject("Status check failed", "Failed to send status command");
+        }
+    }
+
+    @PluginMethod
+    public void scanForPrinters(PluginCall call) {
+        Log.d(TAG, "🔍 Starting printer scan...");
+
+        // Check permissions first
+        if (!checkBluetoothPermissions()) {
+            Log.e(TAG, "❌ Missing Bluetooth permissions");
+            JSObject result = new JSObject();
+            result.put("success", false);
+            result.put("error", "Missing Bluetooth permissions. Please request permissions first.");
+            call.resolve(result);
+            return;
+        }
+
+        if (bluetoothAdapter == null) {
+            Log.e(TAG, "❌ Bluetooth not supported");
+            JSObject result = new JSObject();
+            result.put("success", false);
+            result.put("error", "Bluetooth not supported");
+            call.resolve(result);
+            return;
+        }
+
+        if (!bluetoothAdapter.isEnabled()) {
+            Log.e(TAG, "❌ Bluetooth is disabled");
+            JSObject result = new JSObject();
+            result.put("success", false);
+            result.put("error", "Bluetooth is disabled");
+            call.resolve(result);
+            return;
+        }
+
+        // Start scanning (Classic Bluetooth for Zebra printers)
+        startScanning();
+
+        // Wait a bit for scanning to find devices, then return results
+        new Handler(Looper.getMainLooper()).postDelayed(new Runnable() {
+            @Override
+            public void run() {
+                List<JSObject> printers = new ArrayList<>();
+                for (BluetoothDevice device : discoveredDevices) {
+                    String deviceName = device.getName();
+                    if (deviceName != null && (deviceName.toLowerCase().contains("zebra") ||
+                            deviceName.toLowerCase().contains("zt") ||
+                            deviceName.toLowerCase().contains("xxzhn") ||
+                            deviceName.toLowerCase().contains("printer") ||
+                            deviceName.toLowerCase().contains("label"))) {
+                        JSObject printer = new JSObject();
+                        printer.put("name", deviceName);
+                        printer.put("address", device.getAddress());
+                        printer.put("type", "bluetooth");
+                        printer.put("paired", device.getBondState() == BluetoothDevice.BOND_BONDED);
+                        printers.add(printer);
+                    }
+                }
+
+                JSObject result = new JSObject();
+                result.put("success", true);
+                result.put("printers", printers.toArray(new JSObject[0]));
+                result.put("count", printers.size());
+                result.put("message", "Found " + printers.size() + " printer(s)");
+                call.resolve(result);
+            }
+        }, 3000); // Wait 3 seconds for scanning
+    }
+
+    private void startScanning() {
+        if (isScanning) {
+            Log.d(TAG, "🔍 Already scanning...");
+            return;
+        }
+
+        Log.d(TAG, "🔍 Starting Classic Bluetooth scan (for Zebra printers)...");
+        isScanning = true;
+
+        // Clear previous discoveries
+        discoveredDevices.clear();
+
+        // Start Classic Bluetooth scan (Zebra printers use Classic Bluetooth SPP)
+        if (bluetoothAdapter.isDiscovering()) {
+            bluetoothAdapter.cancelDiscovery();
+        }
+
+        bluetoothAdapter.startDiscovery();
+        Log.d(TAG, "🔍 Classic Bluetooth scan started for Zebra printers");
+
+        // Also try BLE scan as fallback (but don't auto-connect)
+        if (bluetoothLeScanner != null) {
+            bluetoothLeScanner.startScan(new ScanCallback() {
+                @Override
+                public void onScanResult(int callbackType, ScanResult result) {
+                    BluetoothDevice device = result.getDevice();
+                    String deviceName = device.getName();
+
+                    Log.d(TAG, "📱 Found BLE device: " + (deviceName != null ? deviceName : "Unknown"));
+
+                    // Save BLE Zebra printer but don't auto-connect
+                    if (deviceName != null && (deviceName.toLowerCase().contains("zebra") ||
+                            deviceName.toLowerCase().contains("zt") ||
+                            deviceName.toLowerCase().contains("xxzhn"))) {
+                        Log.d(TAG, "🖨️ Found Zebra printer via BLE: " + deviceName);
+
+                        // Save device if not already discovered
+                        if (!discoveredDevices.contains(device)) {
+                            discoveredDevices.add(device);
+                        }
+                    }
+                }
+
+                @Override
+                public void onScanFailed(int errorCode) {
+                    Log.e(TAG, "❌ BLE scan failed with error: " + errorCode);
+                }
+            });
+        }
+
+        // Stop scanning after 15 seconds (Classic Bluetooth needs more time)
+        new Handler(Looper.getMainLooper()).postDelayed(new Runnable() {
+
+    @Override
+    public void run() {
+        if (isScanning) {
+            Log.d(TAG, "⏹️ Stopping scan after timeout");
+            if (bluetoothLeScanner != null) {
+                bluetoothLeScanner.stopScan(new ScanCallback() {
+                });
+            }
+            if (bluetoothAdapter.isDiscovering()) {
+                bluetoothAdapter.cancelDiscovery();
+            }
+            isScanning = false;
+        }
+    }},15000);}
+
+    // Classic Bluetooth discovery callback
+    private final BroadcastReceiver bluetoothReceiver=new BroadcastReceiver(){@Override public void onReceive(Context context,Intent intent){String action=intent.getAction();Log.d(TAG,"📡 Bluetooth receiver action: "+action);
+
+    if(BluetoothDevice.ACTION_FOUND.equals(action)){BluetoothDevice device=intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);String deviceName=device.getName();
+
+    Log.d(TAG,"📱 Found Classic Bluetooth device: "+(deviceName!=null?deviceName:"Unknown")+" ("+device.getAddress()+")");Log.d(TAG,"📱 Device bond state: "+device.getBondState());Log.d(TAG,"📱 Device type: "+device.getType());
+
+    // Check if it's a Zebra printer (expanded filter)
+    if(deviceName!=null&&(deviceName.toLowerCase().contains("zebra")||deviceName.toLowerCase().contains("zt")||deviceName.toLowerCase().contains("xxzhn")||deviceName.toLowerCase().contains("printer")||deviceName.toLowerCase().contains("label")||deviceName.toLowerCase().contains("zebraprinter")||deviceName.toLowerCase().contains("zebra_printer"))){Log.d(TAG,"🖨️ Found Zebra printer via Classic Bluetooth: "+deviceName);
+
+    // Save device if not already discovered
+    if(!discoveredDevices.contains(device)){discoveredDevices.add(device);}
+
+    // Auto-connect if not already connected
+    // CRITICAL FIX: Always try to connect, but connectToDevice will check if
+    // already connected
+    Log.d(TAG,"🔌 Auto-connecting to printer via Classic Bluetooth...");connectToDevice(device);}}else if(BluetoothDevice.ACTION_BOND_STATE_CHANGED.equals(action)){BluetoothDevice device=intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);int bondState=intent.getIntExtra(BluetoothDevice.EXTRA_BOND_STATE,BluetoothDevice.BOND_NONE);Log.d(TAG,"🔗 Bond state changed for "+device.getName()+": "+bondState);
+
+    if(bondState==BluetoothDevice.BOND_BONDED){Log.d(TAG,"✅ Device bonded successfully: "+device.getName());
+    // Try to connect via SPP after bonding
+    // CRITICAL FIX: Check if already connected to this device
+    if((!isConnected||connectedPrinterAddress==null||!connectedPrinterAddress.equals(device.getAddress()))&&discoveredDevices.contains(device)){Log.d(TAG,"🔌 Attempting SPP connection after bonding...");new Thread(()->{if(connectSPP(device)){Log.d(TAG,"✅ Connected via SPP after bonding");
+    // Ensure isConnected is set (it should be set in connectSPP, but double-check)
+    if(!isConnected){isConnected=true;connectedPrinterAddress=device.getAddress();useSPP=true;Log.d(TAG,"✅ Connection status updated after bonding");}}else{Log.e(TAG,"❌ Failed to connect via SPP after bonding");}}).start();}else{Log.d(TAG,"✅ Already connected to this printer, skipping connection after bonding");}}else if(bondState==BluetoothDevice.BOND_NONE){Log.d(TAG,"❌ Device bonding failed: "+device.getName());}}}};
+
+    @PluginMethod
+    public void connect(PluginCall call) {
+        Log.d(TAG, "🔌 Connect method called");
+
+        String address = call.getString("address");
+        String type = call.getString("type", "bluetooth");
+
+        Log.d(TAG, "📱 Connection request - Address: " + (address != null ? address : "none") + ", Type: " + type);
+
+        // For Android, we only support Bluetooth connections
+        if (!"bluetooth".equals(type)) {
+            call.reject("Unsupported connection type", "Android only supports Bluetooth connections");
+            return;
+        }
+
+        // If address is provided, try to connect to specific device
+        if (address != null && !address.isEmpty()) {
+            // Find device with matching address
+            BluetoothDevice targetDevice = null;
+            for (BluetoothDevice device : discoveredDevices) {
+                if (address.equals(device.getAddress())) {
+                    targetDevice = device;
+                    break;
+                }
+            }
+
+            if (targetDevice != null) {
+                Log.d(TAG, "🔌 Connecting to specific printer: " + targetDevice.getName());
+                connectToDevice(targetDevice);
+                JSObject result = new JSObject();
+                result.put("success", true);
+                result.put("connected", false);
+                result.put("address", address);
+                result.put("type", "bluetooth");
+                result.put("message", "Connecting to printer...");
+                call.resolve(result);
+                return;
+            } else {
+                call.reject("Printer not found", "Printer with address " + address + " not found");
+                return;
+            }
+        }
+
+        // If no address provided, try to connect to first available printer
+        if (!discoveredDevices.isEmpty()) {
+            BluetoothDevice firstPrinter = discoveredDevices.get(0);
+            Log.d(TAG, "🔌 Connecting to first available printer: " + firstPrinter.getName());
+            connectToDevice(firstPrinter);
+            JSObject result = new JSObject();
+            result.put("success", true);
+            result.put("connected", false);
+            result.put("address", firstPrinter.getAddress());
+            result.put("type", "bluetooth");
+            result.put("message", "Connecting to printer...");
+            call.resolve(result);
+        } else {
+            Log.e(TAG, "❌ No printers discovered");
+            call.reject("No printers found", "No Zebra printers discovered. Please scan for printers first.");
+        }
+    }
+
+    private boolean checkBluetoothPermissions() {
+        // Check basic Bluetooth permissions
+        if (ContextCompat.checkSelfPermission(getContext(),
+                Manifest.permission.BLUETOOTH) != PackageManager.PERMISSION_GRANTED) {
+            return false;
+        }
+
+        if (ContextCompat.checkSelfPermission(getContext(),
+                Manifest.permission.BLUETOOTH_ADMIN) != PackageManager.PERMISSION_GRANTED) {
+            return false;
+        }
+
+        // Check location permissions (required for BLE scanning)
+        if (ContextCompat.checkSelfPermission(getContext(),
+                Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
+            return false;
+        }
+
+        // Check Android 12+ Bluetooth permissions
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            if (ContextCompat.checkSelfPermission(getContext(),
+                    Manifest.permission.BLUETOOTH_CONNECT) != PackageManager.PERMISSION_GRANTED) {
+                return false;
+            }
+
+            if (ContextCompat.checkSelfPermission(getContext(),
+                    Manifest.permission.BLUETOOTH_SCAN) != PackageManager.PERMISSION_GRANTED) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    private void connectToDevice(BluetoothDevice device) {
+        Log.d(TAG, "Connecting to device: " + device.getName());
+
+        // CRITICAL FIX: Check if already connected to this device
+        // But don't skip if connection is not valid - always verify socket is actually
+        // connected
+        if (isConnected && useSPP && sppSocket != null && connectedPrinterAddress != null) {
+            if (connectedPrinterAddress.equals(device.getAddress())) {
+                try {
+                    // CRITICAL FIX: Always verify socket is actually connected, not just check
+                    // isConnected flag
+                    boolean socketActuallyConnected = sppSocket.isConnected();
+                    if (socketActuallyConnected && sppOutputStream != null) {
+                        // Double-check by trying to get remote device
+                        try {
+                            sppSocket.getRemoteDevice();
+                            Log.d(TAG, "✅ Already connected to this device, socket is valid");
+                            // Verify connection is still valid by checking socket
+                            return; // Already connected to this device, no need to reconnect
+                        } catch (Exception e) {
+                            Log.w(TAG, "⚠️ Socket check failed, will reconnect: " + e.getMessage());
+                            // Socket check failed, need to reconnect
+                            isConnected = false;
+                            useSPP = false;
+                            if (sppSocket != null) {
+                                try {
+                                    sppSocket.close();
+                                } catch (IOException closeException) {
+                                    Log.e(TAG, "Error closing invalid socket", closeException);
+                                }
+                            }
+                            sppSocket = null;
+                            sppOutputStream = null;
+                        }
+                    } else {
+                        Log.w(TAG, "⚠️ Socket exists but not connected (isConnected=" + socketActuallyConnected
+                                + "), will reconnect");
+                        // Socket exists but not connected, need to reconnect
+                        isConnected = false;
+                        useSPP = false;
+                        if (sppSocket != null) {
+                            try {
+                                sppSocket.close();
+                            } catch (IOException e) {
+                                Log.e(TAG, "❌ Error closing invalid socket", e);
+                            }
+                        }
+                        sppSocket = null;
+                        sppOutputStream = null;
+                    }
+                } catch (Exception e) {
+                    Log.w(TAG, "⚠️ Error checking existing connection: " + e.getMessage());
+                    // Connection check failed, need to reconnect
+                    isConnected = false;
+                    useSPP = false;
+                    if (sppSocket != null) {
+                        try {
+                            sppSocket.close();
+                        } catch (IOException closeException) {
+                            Log.e(TAG, "❌ Error closing invalid socket", closeException);
+                        }
+                    }
+                    sppSocket = null;
+                    sppOutputStream = null;
+                }
+            } else {
+                Log.d(TAG, "🔌 Connected to different device, will reconnect to new device");
+                // Connected to different device, need to disconnect first
+            }
+        } else {
+            // CRITICAL FIX: If isConnected is true but socket is null, reset isConnected
+            if (isConnected && (sppSocket == null || !useSPP)) {
+                Log.w(TAG, "⚠️ isConnected is true but socket is null or useSPP is false, resetting connection status");
+                isConnected = false;
+                useSPP = false;
+                connectedPrinterAddress = null;
+            }
+        }
+
+        // Disconnect from current device if connected to different device
+        if (bluetoothGatt != null) {
+            bluetoothGatt.disconnect();
+            bluetoothGatt.close();
+        }
+
+        // Close SPP connection if exists and connected to different device
+        if (sppSocket != null
+                && (connectedPrinterAddress == null || !connectedPrinterAddress.equals(device.getAddress()))) {
+            try {
+                sppSocket.close();
+            } catch (IOException e) {
+                Log.e(TAG, "❌ Error closing SPP socket", e);
+            }
+            sppSocket = null;
+            sppOutputStream = null;
+        }
+
+        // Try SPP first (Bluetooth Classic - more reliable for printing)
+        Log.d(TAG, "🔌 Attempting Bluetooth Classic (SPP) connection first...");
+        if (connectSPP(device)) {
+            Log.d(TAG, "✅ Connected via Bluetooth Classic (SPP)");
+            // CRITICAL FIX: Ensure isConnected is set after successful connection
+            if (!isConnected) {
+                Log.w(TAG, "⚠️ Connection successful but isConnected not set, setting now...");
+                isConnected = true;
+                connectedPrinterAddress = device.getAddress();
+                useSPP = true;
+            }
+            Log.d(TAG, "✅ Final connection status in connectToDevice: isConnected=" + isConnected + ", address="
+                    + connectedPrinterAddress);
+            return;
+        }
+
+        // CRITICAL: Don't use BLE fallback - only use Classic Bluetooth (SPP)
+        // If SPP fails, check if bonding is in progress
+        Log.d(TAG, "⏳ Bluetooth Classic (SPP) connection pending...");
+        Log.d(TAG, "⚠️ NOT using BLE fallback - Classic Bluetooth (SPP) is required for reliable printing");
+
+        // Check if device is bonding - if so, wait for bonding to complete
+        if (device.getBondState() == BluetoothDevice.BOND_BONDING) {
+            Log.d(TAG, "⏳ Device is bonding, will connect automatically after bonding completes...");
+            // Connection will happen automatically after bonding completes via
+            // BroadcastReceiver
+            return;
+        }
+
+        // If device is not bonded and not bonding, try to bond first
+        if (device.getBondState() != BluetoothDevice.BOND_BONDED) {
+            Log.d(TAG, "🔗 Device not bonded, attempting to pair...");
+            if (ActivityCompat.checkSelfPermission(getContext(),
+                    Manifest.permission.BLUETOOTH_CONNECT) == PackageManager.PERMISSION_GRANTED) {
+                boolean bondResult = device.createBond();
+                Log.d(TAG, "🔗 Bonding initiated: " + bondResult);
+                // Connection will happen automatically after bonding completes via
+                // BroadcastReceiver
+                return;
+            } else {
+                Log.e(TAG, "❌ Missing BLUETOOTH_CONNECT permission for bonding");
+                return;
+            }
+        }
+
+        // If we get here, device is bonded but SPP connection failed
+        // Try to connect again after a short delay
+        Log.d(TAG, "🔄 Device is bonded but SPP connection failed, will retry...");
+        new Thread(() -> {
+            try {
+                Thread.sleep(1000); // Wait 1 second (reduced from 2 for faster connection)
+                if (connectSPP(device)) {
+                    Log.d(TAG, "✅ Connected via SPP after retry");
+                    // Ensure isConnected is set (it should be set in connectSPP, but double-check)
+                    if (!isConnected) {
+                        isConnected = true;
+                        connectedPrinterAddress = device.getAddress();
+                        useSPP = true;
+                        Log.d(TAG, "✅ Connection status updated after retry");
+                    }
+                } else {
+                    Log.e(TAG, "❌ SPP connection failed after retry");
+                }
+            } catch (InterruptedException e) {
+                Log.e(TAG, "❌ Retry thread interrupted", e);
+            }
+        }).start();
+    }
+
+    // SPP connection method for Bluetooth Classic - FIXED for ZQ320 (no ANR, stable)
+    private boolean connectSPP(BluetoothDevice device) {
+        // 1. Bonding
+        if (device.getBondState() != BluetoothDevice.BOND_BONDED) {
+            Log.d(TAG, "Not bonded → creating bond (PIN usually 0000)");
+            if (ActivityCompat.checkSelfPermission(getContext(), Manifest.permission.BLUETOOTH_CONNECT)
+                    == PackageManager.PERMISSION_GRANTED) {
+                device.createBond();
+            }
+            return false; // Wait for BOND_BONDED via receiver
+        }
+
+        // 2. Clean old socket
+        if (sppSocket != null) {
+            try {
+                sppSocket.close();
+            } catch (Exception ignored) {
+            }
+            sppSocket = null;
+            sppOutputStream = null;
+        }
+
+        // 3. Connect with timeout (runs in background, keeps main thread free)
+        ExecutorService executor = Executors.newSingleThreadExecutor();
+        Future<Boolean> future = executor.submit(() -> {
+            try {
+                sppSocket = device.createRfcommSocketToServiceRecord(SPP_UUID);
+                sppSocket.connect();
+                sppOutputStream = sppSocket.getOutputStream();
+                return true;
+            } catch (Exception e) {
+                Log.e(TAG, "SPP connect failed: " + e.getMessage());
+                return false;
+            }
+        });
+
+        boolean success = false;
+        try {
+            success = future.get(10, TimeUnit.SECONDS); // 10s timeout
+            if (success && sppSocket != null && sppSocket.isConnected()) {
+                isConnected = true;
+                connectedPrinterAddress = device.getAddress();
+                useSPP = true;
+                Log.d(TAG, "ZQ320 CONNECTED VIA SPP! ✅");
+                return true;
+            }
+        } catch (TimeoutException e) {
+            Log.e(TAG, "SPP timeout while connecting: " + e.getMessage());
+            future.cancel(true); // interrupt background connect to avoid races
+        } catch (Exception e) {
+            Log.e(TAG, "SPP connect error: " + e.getMessage());
+        } finally {
+            executor.shutdownNow(); // ensure the task stops before fallback
+            try {
+                executor.awaitTermination(2, TimeUnit.SECONDS);
+            } catch (InterruptedException ie) {
+                Thread.currentThread().interrupt();
+            }
+        }
+
+        // Clean any half-open socket before trying fallback to avoid races
+        if (sppSocket != null) {
+            try {
+                sppSocket.close();
+            } catch (Exception ignored) {
+            }
+            sppSocket = null;
+            sppOutputStream = null;
+        }
+
+        // If connection failed, try fallback UUID (rarely needed)
+        try {
+            Method m = device.getClass().getMethod("createRfcommSocket", new Class[] { int.class });
+            sppSocket = (BluetoothSocket) m.invoke(device, 1);
+            sppSocket.connect();
+            sppOutputStream = sppSocket.getOutputStream();
+            isConnected = true;
+            useSPP = true;
+            connectedPrinterAddress = device.getAddress();
+            Log.d(TAG, "ZQ320 connected via fallback socket! ✅");
+            return true;
+        } catch (Exception e) {
+            Log.e(TAG, "Fallback also failed: " + e.getMessage());
+        }
+
+        return false;
+    }
+
+    // SPP data sending method for Bluetooth Classic
+    private boolean sendDataToPrinterSPP(String data) {
+        // CRITICAL FIX: Check connection status and socket validity
+        if (!isConnected || sppOutputStream == null || sppSocket == null) {
+            Log.e(TAG, "❌ SPP (Bluetooth Classic) not connected");
+            if (currentPrintCall != null) {
+                currentPrintCall.reject("Send failed", "SPP (Bluetooth Classic) not connected");
+                currentPrintCall = null;
+            }
+            return false;
+        }
+
+        // Socket might be temporarily disconnected but still valid
+        boolean socketConnected = false;
+        try {
+            socketConnected = sppSocket.isConnected();
+            if (!socketConnected) {
+                Log.w(TAG, "⚠️ SPP socket is not connected, but will try to send anyway (socket might reconnect)");
+                // Don't disconnect immediately - socket might reconnect
+                // Only mark as disconnected if send actually fails
+            }
+        } catch (Exception e) {
+            Log.w(TAG, "⚠️ Error checking socket connection: " + e.getMessage() + ", will try to send anyway");
+            // Don't disconnect on check error - socket might still be valid
+            // Only disconnect if send actually fails
+        }
+
+        try {
+            byte[] bytes = data.getBytes("UTF-8");
+            Log.d(TAG, "📤 Sending via SPP (Bluetooth Classic): " + bytes.length + " bytes");
+            Log.d(TAG, "📤 Data preview: " + data.substring(0, Math.min(50, data.length())) + "...");
+
+            sppOutputStream.write(bytes);
+            sppOutputStream.flush();
+
+            Log.d(TAG, "✅ SPP (Bluetooth Classic) data sent successfully");
+
+            // CRITICAL FIX: Resolve the call after successful send
+            if (currentPrintCall != null) {
+                JSObject result = new JSObject();
+                result.put("success", true);
+                result.put("message", "Data sent to printer successfully");
+                result.put("bytes", bytes.length);
+                result.put("connectionType", "SPP (Classic Bluetooth)");
+                currentPrintCall.resolve(result);
+                currentPrintCall = null;
+            }
+            return true;
+        } catch (IOException e) {
+            Log.e(TAG, "❌ SPP (Bluetooth Classic) send failed: " + e.getMessage());
+            Log.e(TAG, "❌ Error details: " + e.getClass().getSimpleName());
+
+            // CRITICAL FIX: Don't immediately disconnect - check if socket is actually
+            // closed
+            // IOException can occur even if socket is still valid (e.g., temporary network
+            // issues)
+            boolean socketClosed = false;
+            if (sppSocket != null) {
+                try {
+                    if (sppSocket.isConnected()) {
+                        Log.d(TAG, "🔍 Socket still connected despite IOException, keeping connection alive");
+                        // Socket is still connected, might be temporary issue
+                        // Don't disconnect - connection is still valid
+                        socketClosed = false;
+                    } else {
+                        Log.w(TAG, "⚠️ Socket not connected after IOException");
+                        // Check if socket is actually closed by trying to read its state
+                        try {
+                            // Try to check socket state more thoroughly
+                            sppSocket.getRemoteDevice();
+                            Log.d(TAG, "🔍 Socket might still be valid, keeping connection alive");
+                            socketClosed = false;
+                        } catch (Exception socketCheckException) {
+                            Log.w(TAG, "⚠️ Socket appears to be closed: " + socketCheckException.getMessage());
+                            socketClosed = true;
+                        }
+                    }
+                } catch (Exception checkException) {
+                    Log.w(TAG, "⚠️ Error checking socket status: " + checkException.getMessage());
+                    // Don't assume socket is closed on check error
+                    // Only mark as closed if we're certain
+                    try {
+                        sppSocket.getRemoteDevice();
+                        socketClosed = false;
+                    } catch (Exception e2) {
+                        socketClosed = true;
+                    }
+                }
+            } else {
+                socketClosed = true;
+            }
+
+            // Only disconnect if socket is definitively closed
+            if (socketClosed) {
+                Log.w(TAG, "⚠️ Marking as disconnected due to confirmed socket closure");
+                isConnected = false;
+                useSPP = false;
+
+                // Clean up socket
+                if (sppSocket != null) {
+                    try {
+                        sppSocket.close();
+                    } catch (IOException closeException) {
+                        Log.e(TAG, "❌ Error closing socket", closeException);
+                    }
+                    sppSocket = null;
+                    sppOutputStream = null;
+                }
+            } else {
+                Log.d(TAG, "✅ Keeping connection alive - socket still valid despite IOException");
+            }
+
+            // CRITICAL FIX: Reject the call on failure
+            if (currentPrintCall != null) {
+                currentPrintCall.reject("Send failed", "SPP (Bluetooth Classic) send failed: " + e.getMessage());
+                currentPrintCall = null;
+            }
+            return false;
+        }
+    }
+
+    @PluginMethod
+    public void disconnect(PluginCall call) {
+        Log.d(TAG, "🔌 Disconnect method called");
+
+        if (bluetoothGatt != null) {
+            bluetoothGatt.disconnect();
+            bluetoothGatt.close();
+            bluetoothGatt = null;
+        }
+
+        // Disconnect SPP
+        if (sppSocket != null) {
+            try {
+                sppSocket.close();
+            } catch (IOException e) {
+                Log.e(TAG, "❌ Error closing SPP socket", e);
+            }
+            sppSocket = null;
+            sppOutputStream = null;
+        }
+
+        isConnected = false;
+        connectedPrinterAddress = null;
+        printerCharacteristic = null;
+        useSPP = false;
+        isWriting = false;
+
+        Log.d(TAG, "✅ Disconnected from printer");
+
+        JSObject result = new JSObject();
+        result.put("success", true);
+        result.put("connected", false);
+        call.resolve(result);
+    }
+}