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

package/ios/Sources/ThermalPrinter/EscPosPrinterSize.swift

@@ -0,0 +1,53 @@
+import Foundation
+
+class EscPosPrinterSize {
+    static let inchToMM: Float = 25.4
+
+    let printerDpi: Int
+    let printerWidthMM: Float
+    let printerNbrCharactersPerLine: Int
+    let printerWidthPx: Int
+    let printerCharSizeWidthPx: Int
+
+    init(printerDpi: Int, printerWidthMM: Float, printerNbrCharactersPerLine: Int) throws {
+        self.printerDpi = printerDpi
+        self.printerWidthMM = printerWidthMM
+        self.printerNbrCharactersPerLine = printerNbrCharactersPerLine
+        let printingWidthPx = EscPosPrinterSize.mmToPx(printerWidthMM, dpi: printerDpi)
+        self.printerWidthPx = printingWidthPx + (printingWidthPx % 8)
+        guard printerNbrCharactersPerLine != 0 else {
+            throw EscPosError.runtime("/ by zero")
+        }
+        self.printerCharSizeWidthPx = printingWidthPx / printerNbrCharactersPerLine
+    }
+
+    func mmToPx(_ mmSize: Float) -> Int {
+        EscPosPrinterSize.mmToPx(mmSize, dpi: printerDpi)
+    }
+
+    static func mmToPx(_ mmSize: Float, dpi: Int) -> Int {
+        JavaMath.round(mmSize * Float(dpi) / inchToMM)
+    }
+
+    func bitmapToBytes(_ bitmap: EscPosBitmap) -> [UInt8] {
+        var isSizeEdit = false
+        var bitmapWidth = bitmap.width
+        var bitmapHeight = bitmap.height
+        let maxWidth = printerWidthPx
+        let maxHeight = 256
+
+        if bitmapWidth > maxWidth {
+            bitmapHeight = JavaMath.round(Float(bitmapHeight) * Float(maxWidth) / Float(bitmapWidth))
+            bitmapWidth = maxWidth
+            isSizeEdit = true
+        }
+        if bitmapHeight > maxHeight {
+            bitmapWidth = JavaMath.round(Float(bitmapWidth) * Float(maxHeight) / Float(bitmapHeight))
+            bitmapHeight = maxHeight
+            isSizeEdit = true
+        }
+
+        let source = isSizeEdit ? bitmap.scaled(width: bitmapWidth, height: bitmapHeight) : bitmap
+        return EscPosPrinterCommands.bitmapToBytes(source)
+    }
+}

package/ios/Sources/ThermalPrinter/EscPosQRCode.swift

@@ -0,0 +1,70 @@
+import CoreGraphics
+import CoreImage
+import Foundation
+
+enum EscPosQRCode {
+    private static let context = CIContext(options: [.useSoftwareRenderer: true])
+
+    static func matrix(for data: String) throws -> [[Bool]] {
+        guard let filter = CIFilter(name: "CIQRCodeGenerator") else {
+            throw EscPosError.barcode("Unable to encode QR code")
+        }
+        filter.setValue(Data(data.utf8), forKey: "inputMessage")
+        filter.setValue("L", forKey: "inputCorrectionLevel")
+        guard let output = filter.outputImage,
+              let image = context.createCGImage(output, from: output.extent)
+        else {
+            throw EscPosError.barcode("Unable to encode QR code")
+        }
+        let width = image.width
+        let height = image.height
+        var gray = [UInt8](repeating: 255, count: width * height)
+        let drawn: Bool = gray.withUnsafeMutableBytes { raw in
+            guard let bitmap = CGContext(
+                data: raw.baseAddress,
+                width: width,
+                height: height,
+                bitsPerComponent: 8,
+                bytesPerRow: width,
+                space: CGColorSpaceCreateDeviceGray(),
+                bitmapInfo: CGImageAlphaInfo.none.rawValue
+            ) else { return false }
+            bitmap.interpolationQuality = .none
+            bitmap.setFillColor(gray: 1, alpha: 1)
+            bitmap.fill(CGRect(x: 0, y: 0, width: width, height: height))
+            bitmap.draw(image, in: CGRect(x: 0, y: 0, width: width, height: height))
+            return true
+        }
+        guard drawn else {
+            throw EscPosError.barcode("Unable to encode QR code")
+        }
+
+        var minX = width
+        var minY = height
+        var maxX = -1
+        var maxY = -1
+        for y in 0..<height {
+            for x in 0..<width where gray[y * width + x] < 128 {
+                minX = min(minX, x)
+                minY = min(minY, y)
+                maxX = max(maxX, x)
+                maxY = max(maxY, y)
+            }
+        }
+        guard maxX >= minX, maxY >= minY else {
+            throw EscPosError.barcode("Unable to encode QR code")
+        }
+        let size = max(maxX - minX, maxY - minY) + 1
+        var modules = [[Bool]](repeating: [Bool](repeating: false, count: size), count: size)
+        for row in 0..<size {
+            for column in 0..<size {
+                let x = minX + column
+                let y = minY + row
+                if x < width && y < height {
+                    modules[row][column] = gray[y * width + x] < 128
+                }
+            }
+        }
+        return modules
+    }
+}

package/ios/Sources/ThermalPrinter/EscPosQueue.swift

@@ -0,0 +1,30 @@
+import Foundation
+
+final class EscPosQueue {
+    let queue: DispatchQueue
+    private let key = DispatchSpecificKey<Bool>()
+
+    init(label: String) {
+        queue = DispatchQueue(label: label)
+        queue.setSpecific(key: key, value: true)
+    }
+
+    var isCurrent: Bool {
+        DispatchQueue.getSpecific(key: key) == true
+    }
+
+    func sync<T>(_ block: () throws -> T) rethrows -> T {
+        if isCurrent {
+            return try block()
+        }
+        return try queue.sync(execute: block)
+    }
+
+    func async(after delay: TimeInterval = 0, _ block: @escaping () -> Void) {
+        if delay <= 0 {
+            queue.async(execute: block)
+        } else {
+            queue.asyncAfter(deadline: .now() + delay, execute: block)
+        }
+    }
+}

package/ios/Sources/ThermalPrinter/EscPosTcpConnection.swift

@@ -0,0 +1,265 @@
+import Foundation
+import Network
+
+protocol EscPosNetworkConnection: AnyObject {
+    var stateUpdateHandler: ((NWConnection.State) -> Void)? { get set }
+    var unsatisfiedReason: NWPath.UnsatisfiedReason? { get }
+    func start(queue: DispatchQueue)
+    func send(_ data: Data, completion: @escaping (NWError?) -> Void)
+    func receive(completion: @escaping (_ isComplete: Bool, _ error: NWError?) -> Void)
+    func cancel()
+}
+
+final class EscPosNWConnection: EscPosNetworkConnection {
+    private let connection: NWConnection
+
+    init(host: String, port: NWEndpoint.Port) {
+        let tcp = NWProtocolTCP.Options()
+        tcp.noDelay = true
+        connection = NWConnection(host: NWEndpoint.Host(host), port: port, using: NWParameters(tls: nil, tcp: tcp))
+    }
+
+    var stateUpdateHandler: ((NWConnection.State) -> Void)? {
+        get { connection.stateUpdateHandler }
+        set { connection.stateUpdateHandler = newValue }
+    }
+
+    var unsatisfiedReason: NWPath.UnsatisfiedReason? {
+        connection.currentPath?.unsatisfiedReason
+    }
+
+    func start(queue: DispatchQueue) {
+        connection.start(queue: queue)
+    }
+
+    func send(_ data: Data, completion: @escaping (NWError?) -> Void) {
+        connection.send(content: data, completion: .contentProcessed(completion))
+    }
+
+    func receive(completion: @escaping (Bool, NWError?) -> Void) {
+        connection.receive(minimumIncompleteLength: 1, maximumLength: 4096) { _, _, isComplete, error in
+            completion(isComplete, error)
+        }
+    }
+
+    func cancel() {
+        connection.cancel()
+    }
+}
+
+final class EscPosTcpConnection: EscPosDeviceConnection {
+    static var connectTimeout: TimeInterval = 5
+    static var localNetworkPermissionTimeout: TimeInterval = 60
+    static var sendTimeout: TimeInterval = 30
+    static let localNetworkPolicyDenied: Int32 = -65570
+
+    enum WaitingDisposition: Equatable {
+        case awaitLocalNetworkPermission
+        case fail
+    }
+
+    static func waitingDisposition(for error: NWError, unsatisfiedReason: NWPath.UnsatisfiedReason?) -> WaitingDisposition {
+        if unsatisfiedReason == .localNetworkDenied {
+            return .awaitLocalNetworkPermission
+        }
+        if case .dns(let code) = error, code == localNetworkPolicyDenied {
+            return .awaitLocalNetworkPermission
+        }
+        return .fail
+    }
+
+    private final class ConnectProgress {
+        private let lock = NSLock()
+        private let semaphore = DispatchSemaphore(value: 0)
+        private var settled = false
+        private var permissionPending = false
+
+        var isSettled: Bool {
+            lock.lock()
+            defer { lock.unlock() }
+            return settled
+        }
+
+        var isPermissionPending: Bool {
+            lock.lock()
+            defer { lock.unlock() }
+            return permissionPending
+        }
+
+        func settle() {
+            lock.lock()
+            let first = !settled
+            settled = true
+            lock.unlock()
+            if first {
+                semaphore.signal()
+            }
+        }
+
+        func markPermissionPending() {
+            lock.lock()
+            permissionPending = true
+            lock.unlock()
+        }
+
+        func wait(_ seconds: TimeInterval) {
+            _ = semaphore.wait(timeout: .now() + seconds)
+        }
+    }
+
+    private final class LockedError {
+        private let lock = NSLock()
+        private var stored: NWError?
+
+        var value: NWError? {
+            lock.lock()
+            defer { lock.unlock() }
+            return stored
+        }
+
+        func set(_ error: NWError?) {
+            lock.lock()
+            stored = error
+            lock.unlock()
+        }
+    }
+
+    let address: String
+    let port: Int
+
+    private let queue = DispatchQueue(label: "de.paystory.thermal-printer.tcp")
+    private let lock = NSLock()
+    private let makeConnection: (String, NWEndpoint.Port) -> EscPosNetworkConnection
+    private var connection: EscPosNetworkConnection?
+    private var ready = false
+
+    init(address: String, port: Int, makeConnection: @escaping (String, NWEndpoint.Port) -> EscPosNetworkConnection = { EscPosNWConnection(host: $0, port: $1) }) {
+        self.address = address
+        self.port = port
+        self.makeConnection = makeConnection
+    }
+
+    override var isConnected: Bool {
+        lock.lock()
+        defer { lock.unlock() }
+        return connection != nil && ready
+    }
+
+    @discardableResult
+    override func connect() throws -> EscPosDeviceConnection {
+        if isConnected {
+            return self
+        }
+        guard (0...65535).contains(port), let endpointPort = NWEndpoint.Port(rawValue: UInt16(port)) else {
+            throw EscPosError.runtime("port out of range:\(port)")
+        }
+        disconnect()
+
+        let candidate = makeConnection(address, endpointPort)
+        let progress = ConnectProgress()
+
+        candidate.stateUpdateHandler = { [weak self, weak candidate] state in
+            guard let self = self, let candidate = candidate else { return }
+            switch state {
+            case .ready:
+                self.lock.lock()
+                if self.connection === candidate {
+                    self.ready = true
+                }
+                self.lock.unlock()
+                progress.settle()
+            case .waiting(let error):
+                if EscPosTcpConnection.waitingDisposition(for: error, unsatisfiedReason: candidate.unsatisfiedReason) == .awaitLocalNetworkPermission {
+                    progress.markPermissionPending()
+                } else {
+                    self.markClosed(candidate)
+                    progress.settle()
+                }
+            case .failed, .cancelled:
+                self.markClosed(candidate)
+                progress.settle()
+            default:
+                break
+            }
+        }
+
+        lock.lock()
+        connection = candidate
+        ready = false
+        lock.unlock()
+
+        candidate.start(queue: queue)
+
+        let started = Date()
+        while !progress.isSettled {
+            let limit = progress.isPermissionPending ? EscPosTcpConnection.localNetworkPermissionTimeout : EscPosTcpConnection.connectTimeout
+            let remaining = started.addingTimeInterval(limit).timeIntervalSinceNow
+            if remaining <= 0 {
+                break
+            }
+            progress.wait(min(remaining, 0.05))
+        }
+        if !isConnected {
+            disconnect()
+            throw EscPosError.connection("Unable to connect to TCP device.")
+        }
+        receiveLoop(candidate)
+        clearBuffer()
+        return self
+    }
+
+    @discardableResult
+    override func disconnect() -> EscPosDeviceConnection {
+        clearBuffer()
+        lock.lock()
+        let current = connection
+        connection = nil
+        ready = false
+        lock.unlock()
+        current?.stateUpdateHandler = nil
+        current?.cancel()
+        return self
+    }
+
+    override func transmit(_ bytes: [UInt8]) throws {
+        lock.lock()
+        let current = connection
+        lock.unlock()
+        guard let current = current else {
+            throw EscPosError.connection("Unable to send data to device.")
+        }
+        let done = DispatchSemaphore(value: 0)
+        let outcome = LockedError()
+        current.send(Data(bytes)) { error in
+            outcome.set(error)
+            done.signal()
+        }
+        if done.wait(timeout: .now() + EscPosTcpConnection.sendTimeout) == .timedOut {
+            disconnect()
+            throw EscPosError.connection("Timed out while sending data to device.")
+        }
+        if let error = outcome.value {
+            disconnect()
+            throw EscPosError.connection(error.localizedDescription)
+        }
+    }
+
+    private func receiveLoop(_ current: EscPosNetworkConnection) {
+        current.receive { [weak self, weak current] isComplete, error in
+            guard let self = self, let current = current else { return }
+            if isComplete || error != nil {
+                self.markClosed(current)
+                return
+            }
+            self.receiveLoop(current)
+        }
+    }
+
+    private func markClosed(_ closed: EscPosNetworkConnection) {
+        lock.lock()
+        if connection === closed {
+            ready = false
+        }
+        lock.unlock()
+    }
+}