@ruhiverse/thermal-printer-plugin 1.0.3 → 1.0.5

package/ios/Plugin/ThermalPrinterPlugin.swift

@@ -8,7 +8,7 @@ import CoreBluetooth
  * Supports USB and Bluetooth printing via ESC/POS commands
  */
 @objc(ThermalPrinterPlugin)
-public class ThermalPrinterPlugin: CAPPlugin {
+public class ThermalPrinterPlugin: CAPPlugin, CBCentralManagerDelegate, CBPeripheralDelegate {
     
     /// Protocol identifiers for supported MFi ESC/POS printers.
     /// Update this list with the protocol strings for your specific printer model.
@@ -17,6 +17,23 @@ public class ThermalPrinterPlugin: CAPPlugin {
         "com.starmicronics.starprnt",
     ]
     
+    // CoreBluetooth properties
+    private var centralManager: CBCentralManager?
+    private var discoveredPeripherals: [CBPeripheral] = []
+    private var connectedPeripheral: CBPeripheral?
+    private var writeCharacteristic: CBCharacteristic?
+    private var scanCompletion: (([CBPeripheral]) -> Void)?
+    private var printCompletion: ((Bool, String?) -> Void)?
+    private var printData: Data?
+    private var targetPrintAddress: String?
+    
+    // Common BLE service UUIDs for thermal printers (Serial Port Profile)
+    private let serialPortServiceUUID = CBUUID(string: "00001101-0000-1000-8000-00805F9B34FB") // SPP
+    private let commonPrinterServiceUUIDs = [
+        CBUUID(string: "00001101-0000-1000-8000-00805F9B34FB"), // SPP
+        CBUUID(string: "E7810A71-73AE-499D-8C15-DAA9080B0E"),   // Some thermal printers
+    ]
+    
     /// Find a connected External Accessory that matches the given (optional) name
     /// and supports one of the known printer protocols.
     private func findPrinterAccessory(preferredName: String?) -> (EAAccessory, String)? {
@@ -137,72 +154,278 @@ public class ThermalPrinterPlugin: CAPPlugin {
             return
         }
         
-        // iOS Bluetooth printing using Core Bluetooth
-        // This is a basic implementation - you may need to configure
-        // Bluetooth permissions in Info.plist
-        
         DispatchQueue.global(qos: .userInitiated).async {
-            // On many MFi / ExternalAccessory-based thermal printers, the
-            // Bluetooth connection is abstracted behind the ExternalAccessory
-            // protocols (e.g., com.epson.escpos, com.starmicronics.starprnt).
-            // We reuse the same ExternalAccessory-based implementation here.
-            
             let preferredName = call.getString("name")
+            let address = call.getString("address")
             
-            guard let (accessory, protocolString) = self.findPrinterAccessory(preferredName: preferredName) else {
+            // Convert text to data
+            guard let data = (textToPrint + "\n\n").data(using: .utf8) else {
                 DispatchQueue.main.async {
-                    call.reject("No compatible Bluetooth printer found. Make sure it is paired, connected, and its protocol is listed in UISupportedExternalAccessoryProtocols.")
+                    call.reject("Failed to encode text as UTF-8.")
                 }
                 return
             }
             
-            // Minimal text → ESC/POS data conversion.
-            // Formatting tags like [C] or <b> are not parsed yet and will
-            // be sent as plain text.
-            guard let data = (textToPrint + "\n\n").data(using: .utf8) else {
+            // Try ExternalAccessory first (for MFi printers)
+            if let (accessory, protocolString) = self.findPrinterAccessory(preferredName: preferredName) {
+                do {
+                    try self.sendPrintData(data, to: accessory, using: protocolString)
+                    DispatchQueue.main.async {
+                        call.resolve([
+                            "success": true,
+                            "message": "Bluetooth print data sent to printer (MFi).",
+                            "printerName": accessory.name,
+                            "protocol": protocolString,
+                        ])
+                    }
+                    return
+                } catch {
+                    // Fall through to BLE if MFi fails
+                }
+            }
+            
+            // Try CoreBluetooth if address is provided or MFi didn't work
+            if let address = address, !address.isEmpty {
+                self.printViaBLE(address: address, data: data, call: call)
+            } else {
                 DispatchQueue.main.async {
-                    call.reject("Failed to encode text as UTF-8.")
+                    call.reject("No compatible Bluetooth printer found. Make sure it is paired/connected. If using BLE, provide the printer address from listBluetoothPrinters().")
+                }
+            }
+        }
+    }
+    
+    private func printViaBLE(address: String, data: Data, call: CAPPluginCall) {
+        if centralManager == nil {
+            centralManager = CBCentralManager(delegate: self, queue: nil)
+        }
+        
+        guard let centralManager = centralManager else {
+            DispatchQueue.main.async {
+                call.reject("Bluetooth not available")
+            }
+            return
+        }
+        
+        // Find peripheral by identifier
+        if let uuid = UUID(uuidString: address) {
+            let peripherals = centralManager.retrievePeripherals(withIdentifiers: [uuid])
+            if let peripheral = peripherals.first {
+                // Found in known peripherals, connect directly
+                printData = data
+                printCompletion = { success, error in
+                    if success {
+                        DispatchQueue.main.async {
+                            call.resolve([
+                                "success": true,
+                                "message": "Bluetooth print data sent to printer (BLE).",
+                            ])
+                        }
+                    } else {
+                        DispatchQueue.main.async {
+                            call.reject("BLE print failed: \(error ?? "Unknown error")")
+                        }
+                    }
+                }
+                
+                connectedPeripheral = peripheral
+                peripheral.delegate = self
+                
+                if centralManager.state == .poweredOn {
+                    centralManager.connect(peripheral, options: nil)
+                } else {
+                    DispatchQueue.main.async {
+                        call.reject("Bluetooth is not powered on")
+                    }
                 }
                 return
             }
-            
-            do {
-                try self.sendPrintData(data, to: accessory, using: protocolString)
+        }
+        
+        // Not found in known peripherals, scan for it
+        printData = data
+        targetPrintAddress = address
+        printCompletion = { success, error in
+            self.targetPrintAddress = nil
+            if success {
                 DispatchQueue.main.async {
                     call.resolve([
                         "success": true,
-                        "message": "Bluetooth print data sent to printer.",
-                        "printerName": accessory.name,
-                        "protocol": protocolString,
+                        "message": "Bluetooth print data sent to printer (BLE).",
                     ])
                 }
-            } catch {
+            } else {
                 DispatchQueue.main.async {
-                    call.reject("Bluetooth print failed: \(error.localizedDescription)")
+                    call.reject("BLE print failed: \(error ?? "Unknown error")")
+                }
+            }
+        }
+        
+        // Start scanning
+        if centralManager.state == .poweredOn {
+            centralManager.scanForPeripherals(withServices: nil, options: nil)
+            
+            // Timeout after 10 seconds
+            DispatchQueue.main.asyncAfter(deadline: .now() + 10.0) {
+                centralManager.stopScan()
+                if self.printCompletion != nil {
+                    self.targetPrintAddress = nil
+                    DispatchQueue.main.async {
+                        call.reject("Could not find printer with address: \(address)")
+                    }
+                    self.printCompletion = nil
+                    self.printData = nil
                 }
             }
+        } else {
+            DispatchQueue.main.async {
+                call.reject("Bluetooth is not powered on")
+            }
         }
     }
     
     @objc func listBluetoothPrinters(_ call: CAPPluginCall) {
+        var printers: [[String: String]] = []
+        
+        // First, get MFi/ExternalAccessory printers
         let manager = EAAccessoryManager.shared()
         let accessories = manager.connectedAccessories
         
-        let printers: [[String: String]] = accessories.compactMap { accessory in
+        let mfiPrinters: [[String: String]] = accessories.compactMap { accessory in
             guard accessory.protocolStrings.contains(where: { supportedPrinterProtocols.contains($0) }) else {
                 return nil
             }
             return [
                 "name": accessory.name,
-                // iOS doesn't expose a MAC address for accessories; we
-                // return the serial number or a generated identifier.
                 "address": accessory.serialNumber.isEmpty ? "\(accessory.connectionID)" : accessory.serialNumber,
             ]
         }
+        printers.append(contentsOf: mfiPrinters)
         
-        call.resolve([
-            "printers": printers,
-        ])
+        // Then scan for BLE printers
+        discoveredPeripherals.removeAll()
+        
+        if centralManager == nil {
+            centralManager = CBCentralManager(delegate: self, queue: nil)
+        }
+        
+        guard let centralManager = centralManager else {
+            call.resolve(["printers": printers])
+            return
+        }
+        
+        // Wait a bit for central manager to be ready, then scan
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
+            if centralManager.state == .poweredOn {
+                // Scan for all peripherals (we'll filter by name/characteristics)
+                centralManager.scanForPeripherals(withServices: nil, options: [CBCentralManagerScanOptionAllowDuplicatesKey: false])
+                
+                // Stop scanning after 5 seconds
+                DispatchQueue.main.asyncAfter(deadline: .now() + 5.0) {
+                    centralManager.stopScan()
+                    
+                    // Add discovered BLE printers
+                    let blePrinters: [[String: String]] = self.discoveredPeripherals.compactMap { peripheral in
+                        guard let name = peripheral.name, !name.isEmpty else {
+                            return nil
+                        }
+                        // Filter for common printer names or accept all if we found them
+                        let printerKeywords = ["printer", "print", "thermal", "pos", "epson", "star", "receipt"]
+                        let isLikelyPrinter = printerKeywords.contains { keyword in
+                            name.lowercased().contains(keyword)
+                        }
+                        
+                        // Include if it's a likely printer or if we have no other printers found
+                        if isLikelyPrinter || printers.isEmpty {
+                            return [
+                                "name": name,
+                                "address": peripheral.identifier.uuidString,
+                            ]
+                        }
+                        return nil
+                    }
+                    
+                    printers.append(contentsOf: blePrinters)
+                    call.resolve(["printers": printers])
+                }
+            } else {
+                // Bluetooth not available, return what we have
+                call.resolve(["printers": printers])
+            }
+        }
+    }
+    
+    // MARK: - CBCentralManagerDelegate
+    
+    public func centralManagerDidUpdateState(_ central: CBCentralManager) {
+        // State updated, scanning will start when ready
+    }
+    
+    public func centralManager(_ central: CBCentralManager, didDiscover peripheral: CBPeripheral, advertisementData: [String : Any], rssi RSSI: NSNumber) {
+        // Avoid duplicates
+        if !discoveredPeripherals.contains(where: { $0.identifier == peripheral.identifier }) {
+            discoveredPeripherals.append(peripheral)
+        }
+        
+        // If we're looking for a specific printer to print to
+        if let targetAddress = targetPrintAddress,
+           peripheral.identifier.uuidString == targetAddress {
+            central.stopScan()
+            connectedPeripheral = peripheral
+            peripheral.delegate = self
+            central.connect(peripheral, options: nil)
+        }
+    }
+    
+    public func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) {
+        peripheral.delegate = self
+        peripheral.discoverServices(nil)
+    }
+    
+    public func centralManager(_ central: CBCentralManager, didFailToConnect peripheral: CBPeripheral, error: Error?) {
+        printCompletion?(false, error?.localizedDescription ?? "Failed to connect")
+        printCompletion = nil
+        printData = nil
+    }
+    
+    public func centralManager(_ central: CBCentralManager, didDisconnectPeripheral peripheral: CBPeripheral, error: Error?) {
+        connectedPeripheral = nil
+        writeCharacteristic = nil
+    }
+    
+    // MARK: - CBPeripheralDelegate
+    
+    public func peripheral(_ peripheral: CBPeripheral, didDiscoverServices error: Error?) {
+        guard let services = peripheral.services else { return }
+        
+        for service in services {
+            peripheral.discoverCharacteristics(nil, for: service)
+        }
+    }
+    
+    public func peripheral(_ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error: Error?) {
+        guard let characteristics = service.characteristics else { return }
+        
+        for characteristic in characteristics {
+            // Look for write characteristics
+            if characteristic.properties.contains(.write) || characteristic.properties.contains(.writeWithoutResponse) {
+                writeCharacteristic = characteristic
+                
+                // Send print data if we have it
+                if let data = printData {
+                    peripheral.writeValue(data, for: characteristic, type: .withoutResponse)
+                    printCompletion?(true, nil)
+                    printCompletion = nil
+                    printData = nil
+                    
+                    // Disconnect after a short delay
+                    DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
+                        self.centralManager?.cancelPeripheralConnection(peripheral)
+                    }
+                }
+                break
+            }
+        }
     }
     
     @objc func listUsbPrinters(_ call: CAPPluginCall) {

package/package.json

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