@nitra/zebra 6.1.3 → 6.1.5

package/ios/Plugin/ZebraPrinterPlugin.swift

@@ -0,0 +1,404 @@
+import Foundation
+import Capacitor
+import CoreBluetooth
+
+@objc(ZebraPrinterPlugin)
+public class ZebraPrinterPlugin: CAPPlugin, CBCentralManagerDelegate, CBPeripheralDelegate {
+    private var centralManager: CBCentralManager!
+    private var connectedPeripheral: CBPeripheral?
+    private var printerService: CBService?
+    private var printerCharacteristic: CBCharacteristic?
+    private var discoveredPeripherals: [CBPeripheral] = []  // Store discovered printers
+    
+    override public func load() {
+        super.load()
+        centralManager = CBCentralManager(delegate: self, queue: nil)
+    }
+    
+    // MARK: - CBCentralManagerDelegate
+    public func centralManagerDidUpdateState(_ central: CBCentralManager) {
+        switch central.state {
+        case .poweredOn:
+            print("✅ Bluetooth is ON")
+            // Automatically start scanning when Bluetooth is turned on
+            print("🔍 Auto-starting scan...")
+            central.scanForPeripherals(withServices: nil, options: nil)
+        case .poweredOff:
+            print("❌ Bluetooth is OFF")
+        case .unauthorized:
+            print("❌ Bluetooth unauthorized")
+        case .unsupported:
+            print("❌ Bluetooth unsupported")
+        case .unknown:
+            print("❌ Bluetooth state unknown")
+        case .resetting:
+            print("🔄 Bluetooth is resetting")
+        @unknown default:
+            print("❌ Unknown Bluetooth state: \(central.state)")
+        }
+    }
+    
+    public func centralManager(_ central: CBCentralManager, didDiscover peripheral: CBPeripheral, advertisementData: [String : Any], rssi RSSI: NSNumber) {
+        print("📱 Found device: \(peripheral.name ?? "Unknown")")
+        
+        // Auto-connect to Zebra printer
+        if peripheral.name?.contains("Zebra") == true || 
+           peripheral.name?.contains("ZT") == true ||
+           peripheral.name?.contains("XXZHN") == true {  // Add specific printer ID
+            print("🖨️ Found Zebra printer: \(peripheral.name ?? "Unknown")")
+            
+            // Store the printer so we keep a reference
+            if !discoveredPeripherals.contains(where: { $0.identifier == peripheral.identifier }) {
+                discoveredPeripherals.append(peripheral)
+            }
+            
+            print("🔌 Auto-connecting to printer...")
+            central.connect(peripheral, options: nil)
+        }
+    }
+    
+    public func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) {
+        print("✅ Connected to: \(peripheral.name ?? "Unknown")")
+        connectedPeripheral = peripheral
+        peripheral.delegate = self
+        peripheral.discoverServices(nil)
+        
+        // Store the printer as the connected one
+        if !discoveredPeripherals.contains(where: { $0.identifier == peripheral.identifier }) {
+            discoveredPeripherals.append(peripheral)
+        }
+    }
+    
+    public func centralManager(_ central: CBCentralManager, didFailToConnect peripheral: CBPeripheral, error: Error?) {
+        print("❌ Failed to connect: \(error?.localizedDescription ?? "Unknown error")")
+    }
+    
+    public func centralManager(_ central: CBCentralManager, didDisconnectPeripheral peripheral: CBPeripheral, error: Error?) {
+        print("🔌 Disconnected from: \(peripheral.name ?? "Unknown")")
+        connectedPeripheral = nil
+        printerService = nil
+        printerCharacteristic = nil
+    }
+    
+    // MARK: - CBPeripheralDelegate
+    public func peripheral(_ peripheral: CBPeripheral, didDiscoverServices error: Error?) {
+        guard error == nil else {
+            print("❌ Service discovery error: \(error!.localizedDescription)")
+            return
+        }
+        
+        for service in peripheral.services ?? [] {
+            print("🔍 Found service: \(service.uuid)")
+            peripheral.discoverCharacteristics(nil, for: service)
+        }
+    }
+    
+    public func peripheral(_ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error: Error?) {
+        guard error == nil else {
+            print("❌ Characteristic discovery error: \(error!.localizedDescription)")
+            return
+        }
+        
+        for characteristic in service.characteristics ?? [] {
+            print("🔍 Found characteristic: \(characteristic.uuid)")
+            
+            // Choose the correct characteristic - usually the one that has the "write" property
+            if characteristic.properties.contains(.write) || characteristic.properties.contains(.writeWithoutResponse) {
+                // If this is the first characteristic with a write property, use it
+                if printerCharacteristic == nil {
+                    printerService = service
+                    printerCharacteristic = characteristic
+                    print("✅ Selected printer characteristic: \(characteristic.uuid)")
+                }
+            }
+        }
+    }
+    
+    // MARK: - Plugin Methods
+    @objc public override func checkPermissions(_ call: CAPPluginCall) {
+        print("🔍 Checking iOS Bluetooth permissions...")
+        
+        let bluetoothState = centralManager.state
+        let hasBluetooth = bluetoothState == .poweredOn
+        let isAuthorized = bluetoothState != .unauthorized
+        let isSupported = bluetoothState != .unsupported
+        
+        call.resolve([
+            "hasPermissions": hasBluetooth && isAuthorized,
+            "bluetoothSupported": isSupported,
+            "bleSupported": true, // iOS always supports BLE
+            "bluetoothState": bluetoothState.rawValue,
+            "missingPermissions": isAuthorized ? [] : ["NSBluetoothAlwaysUsageDescription"]
+        ])
+    }
+    
+    @objc public override func requestPermissions(_ call: CAPPluginCall) {
+        print("🔐 Requesting iOS Bluetooth permissions...")
+        
+        // On iOS, permissions are handled through Info.plist
+        // The actual permission request happens when the user first tries to use Bluetooth
+        let bluetoothState = centralManager.state
+        
+        if bluetoothState == .unauthorized {
+            call.reject("Bluetooth unauthorized", "Please allow Bluetooth access in Settings > Privacy & Security > Bluetooth")
+        } else if bluetoothState == .poweredOff {
+            call.reject("Bluetooth is OFF", "Please turn on Bluetooth in Settings")
+        } else if bluetoothState == .poweredOn {
+            call.resolve([
+                "success": true,
+                "message": "Bluetooth permissions granted"
+            ])
+        } else {
+            call.reject("Bluetooth not ready", "Bluetooth state: \(bluetoothState.rawValue)")
+        }
+    }
+    
+    @objc func echo(_ call: CAPPluginCall) {
+        let value = call.getString("value") ?? ""
+        call.resolve([
+            "value": value
+        ])
+    }
+    
+    // MARK: - Print text (FIXED - sends RAW ZPL)
+    @objc func printText(_ call: CAPPluginCall) {
+        let text = call.getString("text") ?? ""
+        let fontSize = call.getInt("fontSize") ?? 12
+        let bold = call.getBool("bold") ?? false
+        let alignment = call.getString("alignment") ?? "left"
+        
+        print("Printing text: \(text)")
+        
+        // Check printer status first
+        guard let peripheral = connectedPeripheral,
+              let characteristic = printerCharacteristic else {
+            call.reject("Print failed", "Not connected to printer")
+            return
+        }
+        
+        // CRITICAL FIX: Check if it's already a ZPL command
+        var dataToSend: String
+        if text.hasPrefix("^XA") || text.hasPrefix("~") || text.hasPrefix("!") {
+            // It's already a ZPL/CPCL command - send it RAW
+            print("Sending RAW ZPL/CPCL command...")
+            dataToSend = text
+        } else {
+            // It's plain text - create ZPL wrapper with proper formatting
+            print("Converting plain text to ZPL...")
+            let x = alignment == "center" ? 200 : (alignment == "right" ? 350 : 50)
+            let fontStyle = bold ? "B" : "N"
+            // Improved ZPL command with proper line breaks and formatting
+            dataToSend = "^XA\n^FO\(x),50^A0\(fontStyle),\(fontSize),\(fontSize)^FD\(text)^FS\n^XZ"
+        }
+        
+        print("📦 Final data to send: \(dataToSend)")
+        
+        // Send to printer
+        if let data = dataToSend.data(using: .utf8) {
+            if sendDataToPrinter(data) {
+                print("✅ Successfully sent \(data.count) bytes")
+                call.resolve([
+                    "success": true,
+                    "message": "Data sent to printer",
+                    "zpl": dataToSend,
+                    "bytes": data.count
+                ])
+            } else {
+                call.reject("Print failed", "Failed to send data to printer")
+            }
+        } else {
+            call.reject("Print failed", "Invalid data encoding")
+        }
+    }
+    
+    @objc func getStatus(_ call: CAPPluginCall) {
+        let isConnected = connectedPeripheral != nil && printerCharacteristic != nil
+        var result: [String: Any] = [
+            "connected": isConnected,
+            "status": isConnected ? "connected" : "disconnected"
+        ]
+        
+        if isConnected, let peripheral = connectedPeripheral {
+            result["printerAddress"] = peripheral.identifier.uuidString
+            result["printerType"] = "bluetooth"
+        }
+        
+        call.resolve(result)
+    }
+    
+    // NEW: Check printer status with ZPL command
+    @objc func checkPrinterStatus(_ call: CAPPluginCall) {
+        guard let peripheral = connectedPeripheral,
+              let characteristic = printerCharacteristic else {
+            call.reject("Status check failed", "Not connected to printer")
+            return
+        }
+        
+        // Send printer status command
+        let statusCommand = "~HS"  // Zebra printer status command
+        if let data = statusCommand.data(using: .utf8) {
+            if sendDataToPrinter(data) {
+                call.resolve([
+                    "success": true,
+                    "message": "Status command sent",
+                    "command": statusCommand
+                ])
+            } else {
+                call.reject("Status check failed", "Failed to send status command")
+            }
+        } else {
+            call.reject("Status check failed", "Invalid status command")
+        }
+    }
+    
+    @objc func scanForPrinters(_ call: CAPPluginCall) {
+        print("🔍 Starting printer scan...")
+        print("📱 Bluetooth state: \(centralManager.state.rawValue)")
+        
+        switch centralManager.state {
+        case .poweredOn:
+            print("✅ Bluetooth is ON, starting scan...")
+            centralManager.scanForPeripherals(withServices: nil, options: nil)
+            
+            // Return currently discovered printers
+            var printers: [[String: Any]] = []
+            for peripheral in discoveredPeripherals {
+                if let name = peripheral.name, 
+                   (name.contains("Zebra") || name.contains("ZT") || name.contains("XXZHN")) {
+                    printers.append([
+                        "name": name,
+                        "address": peripheral.identifier.uuidString,
+                        "type": "bluetooth",
+                        "paired": false // BLE devices are not "paired" in traditional sense
+                    ])
+                }
+            }
+            
+            call.resolve([
+                "success": true,
+                "printers": printers,
+                "count": printers.count,
+                "message": "Found \(printers.count) printer(s)"
+            ])
+        case .poweredOff:
+            print("❌ Bluetooth is OFF")
+            call.reject("Bluetooth is OFF", "Please turn on Bluetooth in Settings")
+        case .unauthorized:
+            print("❌ Bluetooth unauthorized")
+            call.reject("Bluetooth unauthorized", "Please allow Bluetooth access in Settings")
+        case .unsupported:
+            print("❌ Bluetooth unsupported")
+            call.reject("Bluetooth unsupported", "This device doesn't support Bluetooth")
+        case .unknown:
+            print("❌ Bluetooth state unknown")
+            call.reject("Bluetooth state unknown", "Please check Bluetooth settings")
+        case .resetting:
+            print("🔄 Bluetooth is resetting")
+            call.reject("Bluetooth is resetting", "Please wait and try again")
+        @unknown default:
+            print("❌ Unknown Bluetooth state")
+            call.reject("Unknown Bluetooth state", "Please check Bluetooth settings")
+        }
+    }
+    
+    @objc func connect(_ call: CAPPluginCall) {
+        print("🔌 Connect method called")
+        
+        // Get connection parameters
+        let address = call.getString("address")
+        let type = call.getString("type") ?? "bluetooth"
+        
+        print("📱 Connection request - Address: \(address ?? "none"), Type: \(type)")
+        
+        // For iOS, we only support Bluetooth connections
+        if type != "bluetooth" {
+            call.reject("Unsupported connection type", "iOS only supports Bluetooth connections")
+            return
+        }
+        
+        // If address is provided, try to connect to specific device
+        if let targetAddress = address {
+            // Find peripheral with matching address
+            if let targetPeripheral = discoveredPeripherals.first(where: { $0.identifier.uuidString == targetAddress }) {
+                print("🔌 Connecting to specific printer: \(targetPeripheral.name ?? "Unknown")")
+                centralManager.connect(targetPeripheral, options: nil)
+                call.resolve([
+                    "success": true,
+                    "connected": false,
+                    "address": targetAddress,
+                    "type": "bluetooth",
+                    "message": "Connecting to printer..."
+                ])
+                return
+            } else {
+                call.reject("Printer not found", "Printer with address \(targetAddress) not found")
+                return
+            }
+        }
+        
+        // If no address provided, try to connect to first available printer
+        if let firstPrinter = discoveredPeripherals.first {
+            print("🔌 Connecting to first available printer: \(firstPrinter.name ?? "Unknown")")
+            centralManager.connect(firstPrinter, options: nil)
+            call.resolve([
+                "success": true,
+                "connected": false,
+                "address": firstPrinter.identifier.uuidString,
+                "type": "bluetooth",
+                "message": "Connecting to printer..."
+            ])
+        } else {
+            print("❌ No printers discovered")
+            call.reject("No printers found", "No Zebra printers discovered. Please scan for printers first.")
+        }
+
+    }
+    
+    @objc func disconnect(_ call: CAPPluginCall) {
+        if let peripheral = connectedPeripheral {
+            centralManager.cancelPeripheralConnection(peripheral)
+        }
+        call.resolve([
+            "success": true,
+            "connected": false
+        ])
+    }
+    
+    // MARK: - Helper Methods
+    private func sendDataToPrinter(_ data: Data) -> Bool {
+        guard let peripheral = connectedPeripheral,
+              let characteristic = printerCharacteristic else {
+            print("❌ Not connected to printer")
+            return false
+        }
+        
+        // FIXED: Use proper BLE MTU size (20 bytes for BLE, 512 for BLE 4.2+)
+        // But we'll use a conservative approach with 20 bytes chunks
+        let mtuSize = 20  // Standard BLE MTU size
+        print("📏 MTU size: \(mtuSize)")
+        
+        // Split data into chunks
+        var offset = 0
+        while offset < data.count {
+            let chunkSize = min(mtuSize, data.count - offset)
+            let chunk = data.subdata(in: offset..<(offset + chunkSize))
+            
+            print("📤 Sending chunk \(offset/mtuSize + 1): \(chunkSize) bytes")
+            
+            // Add delay before sending to ensure printer is ready
+            if offset > 0 {
+                Thread.sleep(forTimeInterval: 0.05)  // 50ms delay between chunks
+            }
+            
+            peripheral.writeValue(chunk, for: characteristic, type: .withoutResponse)
+            
+            offset += chunkSize
+        }
+        
+        // Add final delay to ensure all data is processed
+        Thread.sleep(forTimeInterval: 0.1)
+        
+        return true
+    }
+}
+

package/package.json

@@ -1,17 +1,40 @@
 {
   "name": "@nitra/zebra",
-  "version": "6.1.3",
+  "version": "6.1.5",
   "description": "Nitra capacitor components",
+  "main": "dist/plugin.js",
+  "module": "dist/plugin.js",
   "type": "module",
   "exports": {
-    ".": "./index.js"
+    ".": "./index.js",
+    "./plugin": "./dist/plugin.js"
   },
+  "files": [
+    "dist/",
+    "ios/",
+    "android/",
+    "NitraZebra.podspec",
+    "README.md"
+  ],
   "scripts": {
-    "fix": "yarn dlx eslint --fix . && npx prettier --write . "
+    "build": "yarn run clean && rollup -c rollup.config.mjs",
+    "clean": "rimraf ./dist",
+    "watch": "rollup -c rollup.config.mjs --watch",
+    "prepublishOnly": "yarn run build",
+    "prettier": "prettier \"**/*.{css,html,js,java}\" --plugin=prettier-plugin-java",
+    "fix": "npx eslint --fix . && npx prettier --write . "
   },
+  "keywords": [
+    "capacitor",
+    "plugin",
+    "native",
+    "zebra",
+    "printer"
+  ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/nitra/zebra.git"
+    "url": "git+https://github.com/nitra/zebra.git",
+    "directory": "npm"
   },
   "author": "v@nitra.ai",
   "license": "ISC",
@@ -19,7 +42,38 @@
     "url": "https://github.com/nitra/zebra/issues"
   },
   "homepage": "https://github.com/nitra/zebra",
+  "engines": {
+    "node": ">=18.0.0"
+  },
   "dependencies": {
     "@capacitor/core": "^7.4.3"
+  },
+  "peerDependencies": {
+    "@capacitor/core": "^7.0.0"
+  },
+  "devDependencies": {
+    "@capacitor/android": "^7.4.2",
+    "@capacitor/cli": "^7.0.0",
+    "@capacitor/docgen": "^0.3.0",
+    "@capacitor/ios": "^7.4.2",
+    "@ionic/eslint-config": "^0.4.0",
+    "@ionic/prettier-config": "^4.0.0",
+    "@ionic/swiftlint-config": "^2.0.0",
+    "@rollup/plugin-commonjs": "^25.0.0",
+    "@rollup/plugin-node-resolve": "^15.0.0",
+    "eslint": "^8.57.0",
+    "prettier": "^3.4.2",
+    "prettier-plugin-java": "^2.6.6",
+    "rimraf": "^6.0.1",
+    "rollup": "^4.30.1",
+    "swiftlint": "^2.0.0"
+  },
+  "capacitor": {
+    "ios": {
+      "src": "ios"
+    },
+    "android": {
+      "src": "android"
+    }
   }
 }

package/README.md

@@ -1,6 +0,0 @@
-# Nitra Cap components
-
-| Папка                       | Описание                                               |
-|-----------------------------|--------------------------------------------------------|
-| [app-update](./app-apdate/) | Проверка и установка новой версии приложения в маркете |
-| [save-token](./save-token/) | Отримання та збереження push токену                    |

package/index.js

@@ -1,3 +0,0 @@
-export const print = text => {
-  console.log(text)
-}