@ruhiverse/thermal-printer-plugin 1.0.7 → 1.0.9

package/android/src/main/java/com/ruhiverse/thermalprinter/ThermalPrinterPlugin.java

@@ -4,6 +4,8 @@ import android.Manifest;
 import android.app.Activity;
 import android.app.AlertDialog;
 import android.app.PendingIntent;
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
@@ -11,6 +13,8 @@ import android.content.IntentFilter;
 import android.content.pm.PackageManager;
 import android.hardware.usb.UsbDevice;
 import android.hardware.usb.UsbManager;
+import android.os.Handler;
+import android.os.Looper;
 import android.util.Log;
 import androidx.core.app.ActivityCompat;
 import androidx.core.content.ContextCompat;
@@ -35,6 +39,8 @@ import com.ruhiverse.thermalprinter.AsyncBluetoothEscPosPrint;
 import com.ruhiverse.thermalprinter.AsyncEscPosPrint;
 import com.ruhiverse.thermalprinter.AsyncEscPosPrinter;
 import com.ruhiverse.thermalprinter.AsyncUsbEscPosPrint;
+import java.util.HashSet;
+import java.util.Set;
 
 @CapacitorPlugin(
     name = "ThermalPrinter",
@@ -60,6 +66,12 @@ public class ThermalPrinterPlugin extends Plugin {
     public static final int PERMISSION_BLUETOOTH_CONNECT = 3;
     public static final int PERMISSION_BLUETOOTH_SCAN = 4;
     private static final String ACTION_USB_PERMISSION = "com.ruhiverse.thermalprinter.USB_PERMISSION";
+    
+    // Bluetooth discovery
+    private Set<BluetoothDevice> discoveredDevices = new HashSet<>();
+    private PluginCall discoveryCall;
+    private BroadcastReceiver discoveryReceiver;
+    private Handler discoveryHandler = new Handler(Looper.getMainLooper());
 
     private final BroadcastReceiver usbReceiver = new BroadcastReceiver() {
         public void onReceive(Context context, Intent intent) {
@@ -263,43 +275,203 @@ public class ThermalPrinterPlugin extends Plugin {
         this.checkBluetoothPermissions(
             () -> {
                 try {
-                    BluetoothConnection[] bluetoothPrinters = (new BluetoothPrintersConnections()).getList();
                     JSArray printers = new JSArray();
-                    if (bluetoothPrinters != null) {
+                    discoveredDevices.clear();
+                    discoveryCall = call;
+                    
+                    // First, get paired printers
+                    BluetoothConnection[] bluetoothPrinters = (new BluetoothPrintersConnections()).getList();
+                    Set<String> pairedAddresses = new HashSet<>();
+                    
+                    if (bluetoothPrinters != null && bluetoothPrinters.length > 0) {
                         for (BluetoothConnection printer : bluetoothPrinters) {
-                            JSObject printerObj = new JSObject();
-                            printerObj.put("name", printer.getDevice().getName());
-                            printerObj.put("address", printer.getDevice().getAddress());
-                            printers.put(printerObj);
+                            try {
+                                JSObject printerObj = new JSObject();
+                                String name = printer.getDevice().getName();
+                                String address = printer.getDevice().getAddress();
+                                
+                                // Handle null/empty names
+                                if (name == null || name.isEmpty()) {
+                                    name = "Unknown Device";
+                                }
+                                
+                                printerObj.put("name", name);
+                                printerObj.put("address", address != null ? address : "");
+                                printers.put(printerObj);
+                                pairedAddresses.add(address);
+                                
+                                Log.d(TAG, "Found paired Bluetooth printer: " + name + " (" + address + ")");
+                            } catch (Exception e) {
+                                Log.e(TAG, "Error processing printer: " + e.getMessage());
+                            }
                         }
+                    } else {
+                        Log.d(TAG, "No paired Bluetooth printers found. Starting discovery...");
                     }
-                    JSObject ret = new JSObject();
-                    ret.put("printers", printers);
-                    call.resolve(ret);
+                    
+                    // Start Bluetooth discovery for unpaired devices
+                    startBluetoothDiscovery(printers, pairedAddresses);
                 } catch (Exception e) {
+                    Log.e(TAG, "Error listing Bluetooth printers: " + e.getMessage(), e);
                     call.reject("Error listing Bluetooth printers: " + e.getMessage());
                 }
             }
         );
     }
+    
+    private void startBluetoothDiscovery(JSArray printers, java.util.Set<String> pairedAddresses) {
+        BluetoothAdapter bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
+        
+        if (bluetoothAdapter == null) {
+            Log.d(TAG, "Bluetooth not supported on this device");
+            JSObject ret = new JSObject();
+            ret.put("printers", printers);
+            if (discoveryCall != null) {
+                discoveryCall.resolve(ret);
+                discoveryCall = null;
+            }
+            return;
+        }
+        
+        if (!bluetoothAdapter.isEnabled()) {
+            Log.d(TAG, "Bluetooth is not enabled");
+            JSObject ret = new JSObject();
+            ret.put("printers", printers);
+            if (discoveryCall != null) {
+                discoveryCall.resolve(ret);
+                discoveryCall = null;
+            }
+            return;
+        }
+        
+        // Register receiver for discovered devices
+        discoveryReceiver = new BroadcastReceiver() {
+            @Override
+            public void onReceive(Context context, Intent intent) {
+                String action = intent.getAction();
+                if (BluetoothDevice.ACTION_FOUND.equals(action)) {
+                    BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
+                    if (device != null && !pairedAddresses.contains(device.getAddress())) {
+                        discoveredDevices.add(device);
+                        String name = device.getName();
+                        if (name == null || name.isEmpty()) {
+                            name = "Unknown Device";
+                        }
+                        Log.d(TAG, "Discovered Bluetooth device: " + name + " (" + device.getAddress() + ")");
+                    }
+                } else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED.equals(action)) {
+                    // Discovery finished, add discovered devices to results
+                    JSArray finalPrinters = printers;
+                    for (BluetoothDevice device : discoveredDevices) {
+                        try {
+                            JSObject printerObj = new JSObject();
+                            String name = device.getName();
+                            if (name == null || name.isEmpty()) {
+                                name = "Unknown Device";
+                            }
+                            printerObj.put("name", name);
+                            printerObj.put("address", device.getAddress());
+                            finalPrinters.put(printerObj);
+                            Log.d(TAG, "Added discovered device: " + name + " (" + device.getAddress() + ")");
+                        } catch (Exception e) {
+                            Log.e(TAG, "Error adding discovered device: " + e.getMessage());
+                        }
+                    }
+                    
+                    // Unregister receiver
+                    try {
+                        getContext().unregisterReceiver(discoveryReceiver);
+                    } catch (Exception e) {
+                        Log.e(TAG, "Error unregistering receiver: " + e.getMessage());
+                    }
+                    
+                    // Return results
+                    JSObject ret = new JSObject();
+                    ret.put("printers", finalPrinters);
+                    if (discoveryCall != null) {
+                        discoveryCall.resolve(ret);
+                        discoveryCall = null;
+                    }
+                    discoveryReceiver = null;
+                }
+            }
+        };
+        
+        // Register receiver
+        IntentFilter filter = new IntentFilter();
+        filter.addAction(BluetoothDevice.ACTION_FOUND);
+        filter.addAction(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
+        getContext().registerReceiver(discoveryReceiver, filter);
+        
+        // Start discovery
+        if (bluetoothAdapter.isDiscovering()) {
+            bluetoothAdapter.cancelDiscovery();
+        }
+        
+        Log.d(TAG, "Starting Bluetooth discovery...");
+        boolean started = bluetoothAdapter.startDiscovery();
+        
+        if (!started) {
+            Log.d(TAG, "Failed to start Bluetooth discovery");
+            try {
+                getContext().unregisterReceiver(discoveryReceiver);
+            } catch (Exception e) {
+                Log.e(TAG, "Error unregistering receiver: " + e.getMessage());
+            }
+            JSObject ret = new JSObject();
+            ret.put("printers", printers);
+            if (discoveryCall != null) {
+                discoveryCall.resolve(ret);
+                discoveryCall = null;
+            }
+            discoveryReceiver = null;
+        } else {
+            // Stop discovery after 8 seconds
+            discoveryHandler.postDelayed(() -> {
+                if (bluetoothAdapter.isDiscovering()) {
+                    bluetoothAdapter.cancelDiscovery();
+                    Log.d(TAG, "Discovery timeout, stopping scan");
+                }
+            }, 8000);
+        }
+    }
 
     @PluginMethod
     public void listUsbPrinters(PluginCall call) {
         try {
             UsbConnection[] usbPrinters = (new UsbPrintersConnections(getContext())).getList();
             JSArray printers = new JSArray();
-            if (usbPrinters != null) {
+            
+            if (usbPrinters != null && usbPrinters.length > 0) {
                 for (UsbConnection printer : usbPrinters) {
-                    JSObject printerObj = new JSObject();
-                    printerObj.put("name", printer.getDevice().getDeviceName());
-                    printerObj.put("address", printer.getDevice().getSerialNumber()); // Using serial number as address for USB
-                    printers.put(printerObj);
+                    try {
+                        JSObject printerObj = new JSObject();
+                        String name = printer.getDevice().getDeviceName();
+                        String serial = printer.getDevice().getSerialNumber();
+                        
+                        // Handle null/empty names
+                        if (name == null || name.isEmpty()) {
+                            name = "USB Printer";
+                        }
+                        
+                        printerObj.put("name", name);
+                        printerObj.put("address", serial != null ? serial : printer.getDevice().getDeviceId() + "");
+                        printers.put(printerObj);
+                        
+                        Log.d(TAG, "Found USB printer: " + name + " (ID: " + printer.getDevice().getDeviceId() + ")");
+                    } catch (Exception e) {
+                        Log.e(TAG, "Error processing USB printer: " + e.getMessage());
+                    }
                 }
+            } else {
+                Log.d(TAG, "No USB printers found. Make sure printer is connected via USB.");
             }
+            
             JSObject ret = new JSObject();
             ret.put("printers", printers);
             call.resolve(ret);
         } catch (Exception e) {
+            Log.e(TAG, "Error listing USB printers: " + e.getMessage(), e);
             call.reject("Error listing USB printers: " + e.getMessage());
         }
     }

package/ios/Plugin/ThermalPrinterPlugin.swift

@@ -283,22 +283,27 @@ public class ThermalPrinterPlugin: CAPPlugin, CBCentralManagerDelegate, CBPeriph
     }
     
     @objc func listBluetoothPrinters(_ call: CAPPluginCall) {
+        print("ThermalPrinter: listBluetoothPrinters called")
         var printers: [[String: String]] = []
         
         // First, get MFi/ExternalAccessory printers
         let manager = EAAccessoryManager.shared()
         let accessories = manager.connectedAccessories
         
+        print("ThermalPrinter: Found \(accessories.count) ExternalAccessory devices")
+        
         let mfiPrinters: [[String: String]] = accessories.compactMap { accessory in
             guard accessory.protocolStrings.contains(where: { supportedPrinterProtocols.contains($0) }) else {
                 return nil
             }
+            print("ThermalPrinter: Found MFi printer: \(accessory.name)")
             return [
                 "name": accessory.name,
                 "address": accessory.serialNumber.isEmpty ? "\(accessory.connectionID)" : accessory.serialNumber,
             ]
         }
         printers.append(contentsOf: mfiPrinters)
+        print("ThermalPrinter: Found \(mfiPrinters.count) MFi printers")
         
         // Then scan for BLE printers
         discoveredPeripherals.removeAll()
@@ -306,30 +311,40 @@ public class ThermalPrinterPlugin: CAPPlugin, CBCentralManagerDelegate, CBPeriph
         
         // Initialize central manager if needed
         if centralManager == nil {
+            print("ThermalPrinter: Initializing CBCentralManager")
             centralManager = CBCentralManager(delegate: self, queue: DispatchQueue.main)
         }
         
         guard let centralManager = centralManager else {
+            print("ThermalPrinter: Central manager is nil, returning \(printers.count) printers")
             call.resolve(["printers": printers])
             return
         }
         
+        print("ThermalPrinter: Bluetooth state: \(centralManager.state.rawValue)")
+        
         // Check Bluetooth state
         switch centralManager.state {
         case .poweredOn:
             // Start scanning immediately
+            print("ThermalPrinter: Bluetooth powered on, starting scan")
             startBLEScan(for: call, existingPrinters: printers)
         case .poweredOff:
+            print("ThermalPrinter: Bluetooth powered off, returning \(printers.count) printers")
             call.resolve(["printers": printers])
         case .unauthorized:
+            print("ThermalPrinter: Bluetooth unauthorized")
             call.reject("Bluetooth access denied. Please enable Bluetooth permissions in Settings.")
         case .unsupported:
+            print("ThermalPrinter: Bluetooth unsupported")
             call.reject("Bluetooth is not supported on this device.")
         case .resetting, .unknown:
+            print("ThermalPrinter: Bluetooth state unknown/resetting, waiting for update")
             // Wait for state update
             // The state will be updated via centralManagerDidUpdateState
             break
         @unknown default:
+            print("ThermalPrinter: Unknown Bluetooth state, returning \(printers.count) printers")
             call.resolve(["printers": printers])
         }
     }
@@ -345,28 +360,32 @@ public class ThermalPrinterPlugin: CAPPlugin, CBCentralManagerDelegate, CBPeriph
             return
         }
         
+        // Clear previous discoveries
+        discoveredPeripherals.removeAll()
+        
         // Scan for all peripherals
+        print("ThermalPrinter: Starting BLE scan...")
         centralManager.scanForPeripherals(withServices: nil, options: [CBCentralManagerScanOptionAllowDuplicatesKey: false])
         
-        // Stop scanning after 5 seconds
-        DispatchQueue.main.asyncAfter(deadline: .now() + 5.0) {
+        // Stop scanning after 8 seconds (increased from 5 to give more time)
+        DispatchQueue.main.asyncAfter(deadline: .now() + 8.0) {
             centralManager.stopScan()
+            print("ThermalPrinter: Stopped BLE scan. Found \(self.discoveredPeripherals.count) peripherals")
             
             var printers = existingPrinters
             
-            // Add discovered BLE printers - return all devices with names
+            // Add discovered BLE printers - return all devices, even without names
             let blePrinters: [[String: String]] = self.discoveredPeripherals.compactMap { peripheral in
-                // Return all peripherals with names, not just those matching keywords
-                // This allows users to see all Bluetooth devices and select their printer
-                guard let name = peripheral.name, !name.isEmpty else {
-                    return nil
-                }
+                // Include all peripherals, even if they don't have names
+                // Some printers don't advertise names until connected
+                let name = peripheral.name ?? "Unknown Device"
                 return [
                     "name": name,
                     "address": peripheral.identifier.uuidString,
                 ]
             }
             
+            print("ThermalPrinter: Returning \(blePrinters.count) BLE printers")
             printers.append(contentsOf: blePrinters)
             call.resolve(["printers": printers])
             self.listPrintersCall = nil
@@ -376,10 +395,13 @@ public class ThermalPrinterPlugin: CAPPlugin, CBCentralManagerDelegate, CBPeriph
     // MARK: - CBCentralManagerDelegate
     
     public func centralManagerDidUpdateState(_ central: CBCentralManager) {
+        print("ThermalPrinter: Central manager state updated: \(central.state.rawValue)")
+        
         // If we're waiting to list printers, start scanning now
         if let call = listPrintersCall {
             switch central.state {
             case .poweredOn:
+                print("ThermalPrinter: Bluetooth now powered on, starting scan")
                 // Get existing MFi printers first
                 let manager = EAAccessoryManager.shared()
                 let accessories = manager.connectedAccessories
@@ -394,15 +416,19 @@ public class ThermalPrinterPlugin: CAPPlugin, CBCentralManagerDelegate, CBPeriph
                 }
                 startBLEScan(for: call, existingPrinters: mfiPrinters)
             case .poweredOff:
+                print("ThermalPrinter: Bluetooth powered off")
                 call.resolve(["printers": []])
                 listPrintersCall = nil
             case .unauthorized:
+                print("ThermalPrinter: Bluetooth unauthorized")
                 call.reject("Bluetooth access denied. Please enable Bluetooth permissions in Settings.")
                 listPrintersCall = nil
             case .unsupported:
+                print("ThermalPrinter: Bluetooth unsupported")
                 call.reject("Bluetooth is not supported on this device.")
                 listPrintersCall = nil
             default:
+                print("ThermalPrinter: Bluetooth state: \(central.state.rawValue)")
                 break
             }
         }
@@ -412,6 +438,8 @@ public class ThermalPrinterPlugin: CAPPlugin, CBCentralManagerDelegate, CBPeriph
         // Avoid duplicates
         if !discoveredPeripherals.contains(where: { $0.identifier == peripheral.identifier }) {
             discoveredPeripherals.append(peripheral)
+            let name = peripheral.name ?? "Unknown"
+            print("ThermalPrinter: Discovered peripheral: \(name) (\(peripheral.identifier.uuidString))")
         }
         
         // If we're looking for a specific printer to print to

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ruhiverse/thermal-printer-plugin",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "Capacitor plugin for thermal printing via USB and Bluetooth",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",