@bricks-soft/capacitor-thermal-printer 0.0.0-stage → 8.0.0

package/ios/Sources/ThermalPrinter/EscPosBluetoothRules.swift

@@ -0,0 +1,78 @@
+import CoreBluetooth
+import Foundation
+
+enum EscPosBluetoothRules {
+    static let printerServices: [CBUUID] = [
+        CBUUID(string: "18F0"),
+        CBUUID(string: "E7810A71-73AE-499D-8C15-FAA9AEF0C3F2"),
+        CBUUID(string: "49535343-FE7D-4AE5-8FA9-9FAFD205E455"),
+        CBUUID(string: "FF00"),
+        CBUUID(string: "FFE0"),
+        CBUUID(string: "6E400001-B5A3-F393-E0A9-E50E24DCCA9E"),
+    ]
+
+    static let printerCharacteristics: [CBUUID] = [
+        CBUUID(string: "2AF1"),
+        CBUUID(string: "BEF8D6C9-9C21-4C9E-B632-BD58C1009F9F"),
+        CBUUID(string: "49535343-8841-43F4-A8D4-ECBE34729BB3"),
+        CBUUID(string: "FF02"),
+        CBUUID(string: "FFE1"),
+        CBUUID(string: "6E400002-B5A3-F393-E0A9-E50E24DCCA9E"),
+    ]
+
+    static let standardServices: [CBUUID] = [
+        CBUUID(string: "1800"),
+        CBUUID(string: "1801"),
+        CBUUID(string: "180A"),
+        CBUUID(string: "180F"),
+    ]
+
+    static let printerNameFragments = ["print", "thermal", "receipt"]
+    static let printerNamePrefixes = ["mpt", "mtp", "rpp", "xp-", "pt-", "zj-", "pos", "goojprt", "peripage"]
+
+    static func isPrinterCandidate(name: String?, advertisedServices: [CBUUID], connectable: Bool?) -> Bool {
+        if connectable == false {
+            return false
+        }
+        if advertisedServices.contains(where: { printerServices.contains($0) }) {
+            return true
+        }
+        guard let name = name?.lowercased(), !name.isEmpty else {
+            return false
+        }
+        return printerNameFragments.contains { name.contains($0) } || printerNamePrefixes.contains { name.hasPrefix($0) }
+    }
+
+    static func writeType(for properties: CBCharacteristicProperties) -> CBCharacteristicWriteType? {
+        if properties.contains(.writeWithoutResponse) {
+            return .withoutResponse
+        }
+        if properties.contains(.write) {
+            return .withResponse
+        }
+        return nil
+    }
+
+    static func selectCharacteristic(in services: [CBService]) -> (CBCharacteristic, CBCharacteristicWriteType)? {
+        let characteristics = services.flatMap { $0.characteristics ?? [] }
+        for uuid in printerCharacteristics {
+            if let match = characteristics.first(where: { $0.uuid == uuid }), let type = writeType(for: match.properties) {
+                return (match, type)
+            }
+        }
+        for uuid in printerServices {
+            for service in services where service.uuid == uuid {
+                for characteristic in service.characteristics ?? [] {
+                    if let type = writeType(for: characteristic.properties) {
+                        return (characteristic, type)
+                    }
+                }
+            }
+        }
+        let vendorWritable = services
+            .filter { !standardServices.contains($0.uuid) }
+            .flatMap { $0.characteristics ?? [] }
+            .compactMap { characteristic in writeType(for: characteristic.properties).map { (characteristic, $0) } }
+        return vendorWritable.count == 1 ? vendorWritable[0] : nil
+    }
+}

package/ios/Sources/ThermalPrinter/EscPosCharsetEncoding.swift

@@ -0,0 +1,115 @@
+import Foundation
+
+struct EscPosCharsetEncoding: Equatable {
+    let name: String
+    let command: [UInt8]
+
+    init(name: String, escPosCharsetId: Int) {
+        self.name = name
+        self.command = [0x1B, 0x74, UInt8(truncatingIfNeeded: escPosCharsetId)]
+    }
+
+    func encode(_ text: JavaString) throws -> [UInt8] {
+        let encoding = try EscPosCharsetEncoding.stringEncoding(for: name)
+        if let data = text.string.data(using: encoding, allowLossyConversion: false), !EscPosCharsetEncoding.hasLoneSurrogate(text) {
+            return EscPosCharsetEncoding.dropByteOrderMark([UInt8](data), encoding: encoding)
+        }
+        var bytes: [UInt8] = []
+        var index = 0
+        let units = text.units
+        while index < units.count {
+            let unit = units[index]
+            var codePointUnits = [unit]
+            if UTF16.isLeadSurrogate(unit), index + 1 < units.count, UTF16.isTrailSurrogate(units[index + 1]) {
+                codePointUnits.append(units[index + 1])
+            }
+            index += codePointUnits.count
+            let isLoneSurrogate = codePointUnits.count == 1 && (UTF16.isLeadSurrogate(unit) || UTF16.isTrailSurrogate(unit))
+            if !isLoneSurrogate,
+               let data = String(decoding: codePointUnits, as: UTF16.self).data(using: encoding, allowLossyConversion: false) {
+                bytes.append(contentsOf: EscPosCharsetEncoding.dropByteOrderMark([UInt8](data), encoding: encoding))
+            } else {
+                bytes.append(contentsOf: EscPosCharsetEncoding.replacement(for: encoding))
+            }
+        }
+        return bytes
+    }
+
+    static func stringEncoding(for charsetName: String) throws -> String.Encoding {
+        for candidate in candidates(for: charsetName) {
+            let cfEncoding = CFStringConvertIANACharSetNameToEncoding(candidate as CFString)
+            if cfEncoding != kCFStringEncodingInvalidId {
+                return String.Encoding(rawValue: CFStringConvertEncodingToNSStringEncoding(cfEncoding))
+            }
+        }
+        throw EscPosError.encoding(charsetName)
+    }
+
+    private static func candidates(for charsetName: String) -> [String] {
+        let trimmed = charsetName.trimmingCharacters(in: .whitespaces)
+        guard !trimmed.isEmpty else { return [] }
+        let lower = trimmed.lowercased()
+        var names = [trimmed]
+        if let digits = suffixDigits(lower, prefixes: ["cp", "ibm", "ibm-", "cp-"]) {
+            if digits.count == 4, digits.hasPrefix("12") {
+                names.append("windows-\(digits)")
+            } else {
+                names.append("IBM\(digits)")
+                names.append("cp\(digits)")
+            }
+        }
+        if let digits = suffixDigits(lower, prefixes: ["windows-", "windows"]) {
+            names.append("windows-\(digits)")
+        }
+        if let digits = suffixDigits(lower, prefixes: ["iso8859_", "iso8859-", "iso-8859_", "iso_8859-", "iso_8859_"]) {
+            names.append("ISO-8859-\(digits)")
+        }
+        if lower == "utf8" { names.append("UTF-8") }
+        if lower == "ascii" || lower == "us-ascii" { names.append("US-ASCII") }
+        return names
+    }
+
+    private static func suffixDigits(_ name: String, prefixes: [String]) -> String? {
+        for prefix in prefixes where name.hasPrefix(prefix) {
+            let rest = String(name.dropFirst(prefix.count))
+            if !rest.isEmpty, rest.allSatisfy({ $0.isASCII && $0.isNumber }) {
+                return rest
+            }
+        }
+        return nil
+    }
+
+    private static func hasLoneSurrogate(_ text: JavaString) -> Bool {
+        var index = 0
+        let units = text.units
+        while index < units.count {
+            let unit = units[index]
+            if UTF16.isLeadSurrogate(unit) {
+                if index + 1 < units.count, UTF16.isTrailSurrogate(units[index + 1]) {
+                    index += 2
+                    continue
+                }
+                return true
+            }
+            if UTF16.isTrailSurrogate(unit) {
+                return true
+            }
+            index += 1
+        }
+        return false
+    }
+
+    private static func dropByteOrderMark(_ bytes: [UInt8], encoding: String.Encoding) -> [UInt8] {
+        if encoding == .utf8, bytes.starts(with: [0xEF, 0xBB, 0xBF]) {
+            return Array(bytes.dropFirst(3))
+        }
+        return bytes
+    }
+
+    private static func replacement(for encoding: String.Encoding) -> [UInt8] {
+        if let data = "?".data(using: encoding, allowLossyConversion: false) {
+            return dropByteOrderMark([UInt8](data), encoding: encoding)
+        }
+        return [0x3F]
+    }
+}

package/ios/Sources/ThermalPrinter/EscPosCoreBluetoothLink.swift

@@ -0,0 +1,287 @@
+import CoreBluetooth
+import Foundation
+
+protocol EscPosPeripheralDriver: AnyObject {
+    var isAvailable: Bool { get }
+    var isConnected: Bool { get }
+    var canSendWriteWithoutResponse: Bool { get }
+    var services: [CBService] { get }
+    func attach(_ delegate: CBPeripheralDelegate)
+    func maximumWriteValueLength(for type: CBCharacteristicWriteType) -> Int
+    func connect()
+    func cancelConnection()
+    func discoverServices()
+    func discoverCharacteristics(for service: CBService)
+    func write(_ data: Data, for characteristic: CBCharacteristic, type: CBCharacteristicWriteType)
+}
+
+final class EscPosCBPeripheralDriver: EscPosPeripheralDriver {
+    let peripheral: CBPeripheral
+    private unowned let central: EscPosBluetoothCentral
+
+    init(peripheral: CBPeripheral, central: EscPosBluetoothCentral) {
+        self.peripheral = peripheral
+        self.central = central
+    }
+
+    var isAvailable: Bool { central.isPoweredOn }
+
+    var isConnected: Bool { peripheral.state == .connected }
+
+    var canSendWriteWithoutResponse: Bool { peripheral.canSendWriteWithoutResponse }
+
+    var services: [CBService] { peripheral.services ?? [] }
+
+    func attach(_ delegate: CBPeripheralDelegate) {
+        peripheral.delegate = delegate
+    }
+
+    func maximumWriteValueLength(for type: CBCharacteristicWriteType) -> Int {
+        peripheral.maximumWriteValueLength(for: type)
+    }
+
+    func connect() {
+        central.startConnecting(peripheral)
+    }
+
+    func cancelConnection() {
+        central.cancelConnection(peripheral)
+    }
+
+    func discoverServices() {
+        peripheral.discoverServices(nil)
+    }
+
+    func discoverCharacteristics(for service: CBService) {
+        peripheral.discoverCharacteristics(nil, for: service)
+    }
+
+    func write(_ data: Data, for characteristic: CBCharacteristic, type: CBCharacteristicWriteType) {
+        peripheral.writeValue(data, for: characteristic, type: type)
+    }
+}
+
+final class EscPosCoreBluetoothLink: NSObject, EscPosBluetoothLink, CBPeripheralDelegate {
+    weak var events: EscPosBluetoothLinkEvents?
+    let driver: EscPosPeripheralDriver
+    private var session: Int?
+    private var pendingConnect: Int?
+    private var closing: Int?
+    private var queuedConnect: Int?
+    private var pendingDiscovery: Int?
+    private var pendingWrites: [Int] = []
+    private var characteristic: CBCharacteristic?
+    private var pendingCharacteristicDiscoveries = 0
+
+    init(driver: EscPosPeripheralDriver) {
+        self.driver = driver
+        super.init()
+    }
+
+    var isCancelling: Bool { closing != nil }
+
+    var isConnected: Bool { closing == nil && driver.isConnected }
+
+    var canSendWriteWithoutResponse: Bool { driver.canSendWriteWithoutResponse }
+
+    func maximumWriteValueLength(for type: CBCharacteristicWriteType) -> Int {
+        driver.maximumWriteValueLength(for: type)
+    }
+
+    func connect(attempt: Int) {
+        resetSession()
+        if closing != nil {
+            queuedConnect = attempt
+            return
+        }
+        startConnecting(attempt)
+    }
+
+    func adopt(attempt: Int) {
+        resetSession()
+        if closing != nil {
+            queuedConnect = attempt
+            return
+        }
+        session = attempt
+        driver.attach(self)
+    }
+
+    func cancel() {
+        let open = session ?? pendingConnect
+        queuedConnect = nil
+        resetSession()
+        pendingConnect = nil
+        guard let open = open else { return }
+        closing = open
+        driver.cancelConnection()
+    }
+
+    func discoverPrinterCharacteristic(attempt: Int) {
+        guard session == attempt else { return }
+        characteristic = nil
+        pendingCharacteristicDiscoveries = 0
+        pendingDiscovery = attempt
+        driver.discoverServices()
+    }
+
+    func write(_ data: Data, type: CBCharacteristicWriteType, token: Int) {
+        guard session != nil, let characteristic = characteristic else {
+            if type == .withResponse {
+                events?.linkDidWrite(token: token, error: EscPosError.connection("Unable to send data to device."))
+            }
+            return
+        }
+        if type == .withResponse {
+            pendingWrites.append(token)
+        }
+        driver.write(data, for: characteristic, type: type)
+    }
+
+    func handleConnected() {
+        if closing != nil {
+            return
+        }
+        guard let attempt = pendingConnect else { return }
+        pendingConnect = nil
+        session = attempt
+        events?.linkDidConnect(attempt: attempt)
+    }
+
+    func handleFailedToConnect(_ error: Error?) {
+        if let ended = closing {
+            finishCancellation { $0.linkDidFailToConnect(attempt: ended, error: error) }
+            return
+        }
+        guard let attempt = pendingConnect else { return }
+        pendingConnect = nil
+        events?.linkDidFailToConnect(attempt: attempt, error: error)
+    }
+
+    func handleDisconnected(_ error: Error?) {
+        if let ended = closing {
+            finishCancellation { $0.linkDidDisconnect(attempt: ended, error: error) }
+            return
+        }
+        guard let live = session else { return }
+        resetSession()
+        events?.linkDidDisconnect(attempt: live, error: error)
+    }
+
+    func handleUnavailable() {
+        let cancelled = closing
+        let live = session
+        let pending = pendingConnect
+        let queued = queuedConnect
+        resetSession()
+        closing = nil
+        pendingConnect = nil
+        queuedConnect = nil
+        guard let events = events else { return }
+        if let cancelled = cancelled {
+            events.linkDidDisconnect(attempt: cancelled, error: nil)
+        }
+        if let live = live {
+            events.linkDidDisconnect(attempt: live, error: nil)
+        }
+        if let pending = pending {
+            events.linkDidFailToConnect(attempt: pending, error: nil)
+        }
+        if let queued = queued {
+            events.linkDidFailToConnect(attempt: queued, error: nil)
+        }
+    }
+
+    func handleServicesDiscovered(error: Error?) {
+        guard session != nil, let attempt = pendingDiscovery else { return }
+        if let error = error {
+            pendingDiscovery = nil
+            events?.linkDidDiscover(attempt: attempt, writeType: nil, error: error)
+            return
+        }
+        let services = driver.services
+        if services.isEmpty {
+            finishDiscovery()
+            return
+        }
+        pendingCharacteristicDiscoveries = services.count
+        for service in services {
+            driver.discoverCharacteristics(for: service)
+        }
+    }
+
+    func handleCharacteristicsDiscovered() {
+        guard session != nil, pendingDiscovery != nil else { return }
+        pendingCharacteristicDiscoveries -= 1
+        if pendingCharacteristicDiscoveries == 0 {
+            finishDiscovery()
+        }
+    }
+
+    func handleWriteResponse(error: Error?) {
+        guard session != nil, !pendingWrites.isEmpty else { return }
+        events?.linkDidWrite(token: pendingWrites.removeFirst(), error: error)
+    }
+
+    func handleReadyToSend() {
+        guard let attempt = session else { return }
+        events?.linkIsReadyToSend(attempt: attempt)
+    }
+
+    func peripheral(_ peripheral: CBPeripheral, didDiscoverServices error: Error?) {
+        handleServicesDiscovered(error: error)
+    }
+
+    func peripheral(_ peripheral: CBPeripheral, didDiscoverCharacteristicsFor service: CBService, error: Error?) {
+        handleCharacteristicsDiscovered()
+    }
+
+    func peripheral(_ peripheral: CBPeripheral, didWriteValueFor characteristic: CBCharacteristic, error: Error?) {
+        handleWriteResponse(error: error)
+    }
+
+    func peripheralIsReady(toSendWriteWithoutResponse peripheral: CBPeripheral) {
+        handleReadyToSend()
+    }
+
+    private func startConnecting(_ attempt: Int) {
+        guard driver.isAvailable else {
+            events?.linkDidFailToConnect(attempt: attempt, error: nil)
+            return
+        }
+        pendingConnect = attempt
+        driver.attach(self)
+        driver.connect()
+    }
+
+    private func finishCancellation(_ report: (EscPosBluetoothLinkEvents) -> Void) {
+        closing = nil
+        let next = queuedConnect
+        queuedConnect = nil
+        if let events = events {
+            report(events)
+        }
+        if let next = next {
+            startConnecting(next)
+        }
+    }
+
+    private func finishDiscovery() {
+        guard let attempt = pendingDiscovery else { return }
+        pendingDiscovery = nil
+        if let (found, type) = EscPosBluetoothRules.selectCharacteristic(in: driver.services) {
+            characteristic = found
+            events?.linkDidDiscover(attempt: attempt, writeType: type, error: nil)
+        } else {
+            events?.linkDidDiscover(attempt: attempt, writeType: nil, error: nil)
+        }
+    }
+
+    private func resetSession() {
+        session = nil
+        pendingDiscovery = nil
+        pendingWrites = []
+        characteristic = nil
+        pendingCharacteristicDiscoveries = 0
+    }
+}

package/ios/Sources/ThermalPrinter/EscPosDeviceConnection.swift

@@ -0,0 +1,47 @@
+import Foundation
+
+class EscPosDeviceConnection: NSObject {
+    private(set) var data: [UInt8] = []
+    var pacesSends = true
+
+    var isConnected: Bool { false }
+
+    @discardableResult
+    func connect() throws -> EscPosDeviceConnection { self }
+
+    @discardableResult
+    func disconnect() -> EscPosDeviceConnection {
+        data = []
+        return self
+    }
+
+    func transmit(_ bytes: [UInt8]) throws {}
+
+    func write(_ bytes: [UInt8]) {
+        data.append(contentsOf: bytes)
+    }
+
+    func send(_ addWaitingTime: Int = 0) throws {
+        guard isConnected else {
+            data = []
+            throw EscPosError.connection("Unable to send data to device.")
+        }
+        let payload = data
+        do {
+            try transmit(payload)
+        } catch {
+            data = []
+            disconnect()
+            throw error
+        }
+        let waitingTime = addWaitingTime + payload.count / 16
+        data = []
+        if pacesSends && waitingTime > 0 {
+            Thread.sleep(forTimeInterval: Double(waitingTime) / 1000.0)
+        }
+    }
+
+    func clearBuffer() {
+        data = []
+    }
+}