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

package/ios/Sources/ThermalPrinter/EscPosBluetooth.swift

@@ -0,0 +1,341 @@
+import CoreBluetooth
+import Foundation
+
+protocol EscPosCentralManaging: AnyObject {
+    var state: CBManagerState { get }
+    func scanForPeripherals(withServices serviceUUIDs: [CBUUID]?, options: [String: Any]?)
+    func stopScan()
+    func retrievePeripherals(withIdentifiers identifiers: [UUID]) -> [CBPeripheral]
+    func retrieveConnectedPeripherals(withServices serviceUUIDs: [CBUUID]) -> [CBPeripheral]
+    func connect(_ peripheral: CBPeripheral, options: [String: Any]?)
+    func cancelPeripheralConnection(_ peripheral: CBPeripheral)
+}
+
+extension CBCentralManager: EscPosCentralManaging {}
+
+protocol EscPosDiscoveredPeripheral: AnyObject {
+    var identifier: UUID { get }
+    var name: String? { get }
+}
+
+extension CBPeripheral: EscPosDiscoveredPeripheral {}
+
+struct EscPosBluetoothDevice {
+    let peripheral: EscPosDiscoveredPeripheral
+    let name: String?
+    let services: [CBUUID]
+    let isPrinterCandidate: Bool
+
+    var identifier: UUID { peripheral.identifier }
+}
+
+final class EscPosBluetoothCentral: NSObject, CBCentralManagerDelegate {
+    static var scanDuration: TimeInterval = 3
+    static var stateTimeout: TimeInterval = 10
+    static var authorizationTimeout: TimeInterval = 60
+
+    static func fallbackName(for identifier: UUID) -> String {
+        "BLE Printer \(identifier.uuidString.prefix(4))"
+    }
+
+    let queue = EscPosQueue(label: "de.paystory.thermal-printer.bluetooth")
+    private let authorizationSource: () -> CBManagerAuthorization
+    private let makeManager: (EscPosBluetoothCentral) -> EscPosCentralManaging
+    private let store: EscPosKnownPrinterStore
+    private var manager: EscPosCentralManaging?
+    private var stateEvent: DispatchSemaphore?
+    private var authorizationRequests: [(CBManagerAuthorization?) -> Void] = []
+    private var scanEvent: DispatchSemaphore?
+    private var scanMatch: ((EscPosBluetoothDevice) -> Bool)?
+    private var scanResults: [EscPosBluetoothDevice] = []
+    private var lastScanResults: [EscPosBluetoothDevice] = []
+    private var displayNames: [UUID: String] = [:]
+    private var connections: [UUID: EscPosBluetoothConnection] = [:]
+    private var links: [UUID: EscPosCoreBluetoothLink] = [:]
+    private var linkedPeripherals: [UUID: CBPeripheral] = [:]
+
+    init(
+        authorization: @escaping () -> CBManagerAuthorization = { CBManager.authorization },
+        store: EscPosKnownPrinterStore = EscPosKnownPrinterStore(),
+        makeManager: ((EscPosBluetoothCentral) -> EscPosCentralManaging)? = nil
+    ) {
+        self.authorizationSource = authorization
+        self.store = store
+        self.makeManager = makeManager ?? { central in
+            CBCentralManager(delegate: central, queue: central.queue.queue, options: [CBCentralManagerOptionShowPowerAlertKey: false])
+        }
+        super.init()
+    }
+
+    var authorization: CBManagerAuthorization {
+        authorizationSource()
+    }
+
+    func requestAuthorization(_ completion: @escaping (CBManagerAuthorization?) -> Void) {
+        queue.sync {
+            let current = authorization
+            guard current == .notDetermined else {
+                completion(current)
+                return
+            }
+            authorizationRequests.append(completion)
+            ensureManager()
+        }
+    }
+
+    func cancelAuthorizationRequests() {
+        queue.sync { finishAuthorizationRequests(nil) }
+    }
+
+    func waitForAuthorization() -> CBManagerAuthorization {
+        let answered = DispatchSemaphore(value: 0)
+        requestAuthorization { _ in answered.signal() }
+        _ = answered.wait(timeout: .now() + EscPosBluetoothCentral.authorizationTimeout)
+        return authorization
+    }
+
+    private func finishAuthorizationRequests(_ answer: CBManagerAuthorization?) {
+        let requests = authorizationRequests
+        authorizationRequests = []
+        requests.forEach { $0(answer) }
+    }
+
+    func waitForState() -> CBManagerState {
+        let deadline = Date().addingTimeInterval(EscPosBluetoothCentral.stateTimeout)
+        while true {
+            let (state, event) = queue.sync { () -> (CBManagerState, DispatchSemaphore) in
+                let current = ensureManager().state
+                let semaphore = DispatchSemaphore(value: 0)
+                stateEvent = semaphore
+                return (current, semaphore)
+            }
+            if state != .unknown && state != .resetting {
+                return state
+            }
+            if Date() >= deadline {
+                return state
+            }
+            _ = event.wait(timeout: .now() + 0.5)
+        }
+    }
+
+    func handleStateUpdate() {
+        queue.sync {
+            stateEvent?.signal()
+            let current = authorization
+            if current != .notDetermined {
+                finishAuthorizationRequests(current)
+            }
+            guard let manager = manager, manager.state != .poweredOn else { return }
+            for link in links.values {
+                link.handleUnavailable()
+            }
+        }
+    }
+
+    func knownDevices() -> [EscPosBluetoothDevice] {
+        queue.sync {
+            guard let manager = manager else { return [] }
+            var devices: [EscPosBluetoothDevice] = []
+            var seen = Set<UUID>()
+            func add(_ peripheral: CBPeripheral) {
+                guard !seen.contains(peripheral.identifier) else { return }
+                seen.insert(peripheral.identifier)
+                devices.append(EscPosBluetoothDevice(peripheral: peripheral, name: displayName(for: peripheral), services: [], isPrinterCandidate: true))
+            }
+            for (identifier, link) in links where link.isConnected {
+                if let peripheral = linkedPeripherals[identifier] {
+                    add(peripheral)
+                }
+            }
+            let remembered = store.load().keys.compactMap { UUID(uuidString: $0) }
+            if !remembered.isEmpty {
+                manager.retrievePeripherals(withIdentifiers: remembered).forEach(add)
+            }
+            manager.retrieveConnectedPeripherals(withServices: EscPosBluetoothRules.printerServices).forEach(add)
+            return devices
+        }
+    }
+
+    func scan(duration: TimeInterval, until match: ((EscPosBluetoothDevice) -> Bool)? = nil) -> [EscPosBluetoothDevice] {
+        let event: DispatchSemaphore? = queue.sync {
+            guard let manager = manager, manager.state == .poweredOn else { return nil }
+            let semaphore = DispatchSemaphore(value: 0)
+            scanResults = []
+            scanMatch = match
+            scanEvent = semaphore
+            manager.scanForPeripherals(withServices: nil, options: [CBCentralManagerScanOptionAllowDuplicatesKey: false])
+            return semaphore
+        }
+        guard let semaphore = event else { return [] }
+        _ = semaphore.wait(timeout: .now() + duration)
+        return queue.sync {
+            manager?.stopScan()
+            scanEvent = nil
+            scanMatch = nil
+            lastScanResults = scanResults
+            return scanResults
+        }
+    }
+
+    func listDevices() -> [EscPosBluetoothDevice] {
+        var devices = knownDevices()
+        var seen = Set(devices.map(\.identifier))
+        for device in scan(duration: EscPosBluetoothCentral.scanDuration) where device.isPrinterCandidate && !seen.contains(device.identifier) {
+            seen.insert(device.identifier)
+            devices.append(device)
+        }
+        return devices
+    }
+
+    func findPeripheral(id: String, address: String?) -> CBPeripheral? {
+        let keys = [id, address ?? ""].filter { !$0.isEmpty }
+        let byIdentifier: CBPeripheral? = queue.sync {
+            guard let manager = manager else { return nil }
+            for key in keys {
+                if let uuid = UUID(uuidString: key), let peripheral = manager.retrievePeripherals(withIdentifiers: [uuid]).first {
+                    return peripheral
+                }
+            }
+            return nil
+        }
+        if let peripheral = byIdentifier {
+            return peripheral
+        }
+        let matchesName: (EscPosBluetoothDevice) -> Bool = { device in
+            device.name == id || device.peripheral.name == id
+        }
+        if let peripheral = queue.sync({ lastScanResults.first(where: matchesName)?.peripheral as? CBPeripheral }) {
+            return peripheral
+        }
+        if let peripheral = knownDevices().first(where: matchesName)?.peripheral as? CBPeripheral {
+            return peripheral
+        }
+        return scan(duration: EscPosBluetoothCentral.scanDuration, until: matchesName).first(where: matchesName)?.peripheral as? CBPeripheral
+    }
+
+    func candidatesForFirst() -> [CBPeripheral] {
+        let known = knownDevices()
+        if !known.isEmpty {
+            return known.compactMap { $0.peripheral as? CBPeripheral }
+        }
+        return scan(duration: EscPosBluetoothCentral.scanDuration).filter(\.isPrinterCandidate).compactMap { $0.peripheral as? CBPeripheral }
+    }
+
+    var isPoweredOn: Bool {
+        queue.sync { manager?.state == .poweredOn }
+    }
+
+    func connection(for peripheral: CBPeripheral) -> EscPosBluetoothConnection {
+        queue.sync {
+            if connections[peripheral.identifier] == nil {
+                linkedPeripherals[peripheral.identifier] = peripheral
+            }
+            return connection(for: peripheral.identifier, driver: EscPosCBPeripheralDriver(peripheral: peripheral, central: self)) { [weak self] in
+                self?.remember(peripheral)
+            }
+        }
+    }
+
+    func connection(for identifier: UUID, driver: @autoclosure () -> EscPosPeripheralDriver, onConnected: (() -> Void)? = nil) -> EscPosBluetoothConnection {
+        queue.sync {
+            if let existing = connections[identifier] {
+                return existing
+            }
+            let link = EscPosCoreBluetoothLink(driver: driver())
+            links[identifier] = link
+            let created = EscPosBluetoothConnection(link: link, queue: queue, onConnected: onConnected)
+            connections[identifier] = created
+            return created
+        }
+    }
+
+    func startConnecting(_ peripheral: CBPeripheral) {
+        queue.sync { manager?.connect(peripheral, options: nil) }
+    }
+
+    func cancelConnection(_ peripheral: CBPeripheral) {
+        queue.sync { manager?.cancelPeripheralConnection(peripheral) }
+    }
+
+    func remember(_ peripheral: CBPeripheral) {
+        let name = queue.sync { displayName(for: peripheral) ?? peripheral.name ?? EscPosBluetoothCentral.fallbackName(for: peripheral.identifier) }
+        store.remember(identifier: peripheral.identifier, name: name)
+    }
+
+    func record(_ peripheral: EscPosDiscoveredPeripheral, advertisementData: [String: Any]) {
+        guard scanEvent != nil else { return }
+        let connectable = (advertisementData[CBAdvertisementDataIsConnectable] as? NSNumber)?.boolValue
+        if connectable == false {
+            return
+        }
+        let index = scanResults.firstIndex { $0.identifier == peripheral.identifier }
+        let earlierServices = index.map { scanResults[$0].services } ?? []
+        let advertised = advertisementData[CBAdvertisementDataServiceUUIDsKey] as? [CBUUID] ?? []
+        let services = earlierServices + advertised.filter { !earlierServices.contains($0) }
+        let localName = advertisementData[CBAdvertisementDataLocalNameKey] as? String
+        let advertisedName = [localName, peripheral.name].compactMap { $0 }.first { !$0.isEmpty }
+        let isPrinterCandidate = index.map { scanResults[$0].isPrinterCandidate } == true
+            || EscPosBluetoothRules.isPrinterCandidate(name: advertisedName, advertisedServices: services, connectable: connectable)
+        guard advertisedName != nil || isPrinterCandidate else { return }
+        if let advertisedName = advertisedName {
+            displayNames[peripheral.identifier] = advertisedName
+        } else if displayNames[peripheral.identifier] == nil {
+            displayNames[peripheral.identifier] = EscPosBluetoothCentral.fallbackName(for: peripheral.identifier)
+        }
+        let device = EscPosBluetoothDevice(
+            peripheral: peripheral,
+            name: displayName(for: peripheral),
+            services: services,
+            isPrinterCandidate: isPrinterCandidate
+        )
+        if let index = index {
+            scanResults[index] = device
+        } else {
+            scanResults.append(device)
+        }
+        if let match = scanMatch, match(device) {
+            scanEvent?.signal()
+        }
+    }
+
+    private func displayName(for peripheral: EscPosDiscoveredPeripheral) -> String? {
+        if let remembered = store.load()[peripheral.identifier.uuidString], !remembered.isEmpty {
+            return remembered
+        }
+        if let name = displayNames[peripheral.identifier], !name.isEmpty {
+            return name
+        }
+        return peripheral.name
+    }
+
+    @discardableResult
+    private func ensureManager() -> EscPosCentralManaging {
+        if let manager = manager {
+            return manager
+        }
+        let created = makeManager(self)
+        manager = created
+        return created
+    }
+
+    func centralManagerDidUpdateState(_ central: CBCentralManager) {
+        handleStateUpdate()
+    }
+
+    func centralManager(_ central: CBCentralManager, didDiscover peripheral: CBPeripheral, advertisementData: [String: Any], rssi RSSI: NSNumber) {
+        record(peripheral, advertisementData: advertisementData)
+    }
+
+    func centralManager(_ central: CBCentralManager, didConnect peripheral: CBPeripheral) {
+        links[peripheral.identifier]?.handleConnected()
+    }
+
+    func centralManager(_ central: CBCentralManager, didFailToConnect peripheral: CBPeripheral, error: Error?) {
+        links[peripheral.identifier]?.handleFailedToConnect(error)
+    }
+
+    func centralManager(_ central: CBCentralManager, didDisconnectPeripheral peripheral: CBPeripheral, error: Error?) {
+        links[peripheral.identifier]?.handleDisconnected(error)
+    }
+}

package/ios/Sources/ThermalPrinter/EscPosBluetoothConnection.swift

@@ -0,0 +1,298 @@
+import CoreBluetooth
+import Foundation
+
+protocol EscPosBluetoothLinkEvents: AnyObject {
+    func linkDidConnect(attempt: Int)
+    func linkDidFailToConnect(attempt: Int, error: Error?)
+    func linkDidDisconnect(attempt: Int, error: Error?)
+    func linkDidDiscover(attempt: Int, writeType: CBCharacteristicWriteType?, error: Error?)
+    func linkDidWrite(token: Int, error: Error?)
+    func linkIsReadyToSend(attempt: Int)
+}
+
+protocol EscPosBluetoothLink: AnyObject {
+    var events: EscPosBluetoothLinkEvents? { get set }
+    var isConnected: Bool { get }
+    var canSendWriteWithoutResponse: Bool { get }
+    func maximumWriteValueLength(for type: CBCharacteristicWriteType) -> Int
+    func connect(attempt: Int)
+    func adopt(attempt: Int)
+    func cancel()
+    func discoverPrinterCharacteristic(attempt: Int)
+    func write(_ data: Data, type: CBCharacteristicWriteType, token: Int)
+}
+
+struct EscPosBluetoothTimeouts {
+    var connect: TimeInterval = 10
+    var discovery: TimeInterval = 10
+    var write: TimeInterval = 10
+    var readinessPoll: TimeInterval = 0.05
+}
+
+final class EscPosBluetoothConnection: EscPosDeviceConnection, EscPosBluetoothLinkEvents {
+    private enum OperationKind {
+        case connect
+        case discovery
+        case write
+    }
+
+    private final class Operation {
+        let kind: OperationKind
+        let token: Int
+        let semaphore = DispatchSemaphore(value: 0)
+        var finished = false
+        var error: Error?
+
+        init(kind: OperationKind, token: Int) {
+            self.kind = kind
+            self.token = token
+        }
+    }
+
+    private struct LinkFailure: Error {}
+
+    let link: EscPosBluetoothLink
+    private let queue: EscPosQueue
+    private let timeouts: EscPosBluetoothTimeouts
+    private let onConnected: (() -> Void)?
+    private var attempt = 0
+    private var lastToken = 0
+    private var linkUp = false
+    private var tearingDown = false
+    private var writeType: CBCharacteristicWriteType?
+    private var current: Operation?
+    private var readiness: DispatchSemaphore?
+    private var ignoredCallbacks = 0
+
+    init(link: EscPosBluetoothLink, queue: EscPosQueue, timeouts: EscPosBluetoothTimeouts = EscPosBluetoothTimeouts(), onConnected: (() -> Void)? = nil) {
+        self.link = link
+        self.queue = queue
+        self.timeouts = timeouts
+        self.onConnected = onConnected
+        super.init()
+        queue.sync { link.events = self }
+    }
+
+    override var isConnected: Bool {
+        queue.sync { linkUp && link.isConnected && writeType != nil }
+    }
+
+    var ignoredCallbackCount: Int {
+        queue.sync { ignoredCallbacks }
+    }
+
+    @discardableResult
+    override func connect() throws -> EscPosDeviceConnection {
+        if isConnected {
+            return self
+        }
+        do {
+            let connecting = queue.sync { () -> Operation? in
+                attempt = nextToken()
+                writeType = nil
+                if link.isConnected && !tearingDown {
+                    linkUp = true
+                    link.adopt(attempt: attempt)
+                    return nil
+                }
+                linkUp = false
+                let operation = begin(.connect, token: attempt)
+                link.connect(attempt: attempt)
+                return operation
+            }
+            if let operation = connecting {
+                try waitFor(operation, timeout: timeouts.connect)
+            }
+            let discovery = queue.sync { () -> Operation in
+                let operation = begin(.discovery, token: attempt)
+                link.discoverPrinterCharacteristic(attempt: attempt)
+                return operation
+            }
+            try waitFor(discovery, timeout: timeouts.discovery)
+            guard isConnected else {
+                throw LinkFailure()
+            }
+        } catch {
+            invalidate()
+            throw EscPosError.connection("Unable to connect to bluetooth device.")
+        }
+        onConnected?()
+        clearBuffer()
+        return self
+    }
+
+    @discardableResult
+    override func disconnect() -> EscPosDeviceConnection {
+        invalidate()
+        return super.disconnect()
+    }
+
+    override func transmit(_ bytes: [UInt8]) throws {
+        let target: (CBCharacteristicWriteType, Int)? = queue.sync {
+            guard linkUp, link.isConnected, let type = writeType else { return nil }
+            return (type, max(20, link.maximumWriteValueLength(for: type)))
+        }
+        guard let (type, chunkSize) = target else {
+            throw EscPosError.connection("Unable to send data to device.")
+        }
+        var offset = 0
+        while offset < bytes.count {
+            let end = min(offset + chunkSize, bytes.count)
+            let chunk = Data(bytes[offset..<end])
+            if type == .withoutResponse {
+                try waitUntilReadyToWrite()
+                try queue.sync {
+                    guard linkUp else { throw EscPosError.connection("Bluetooth device disconnected.") }
+                    link.write(chunk, type: .withoutResponse, token: nextToken())
+                }
+            } else {
+                let operation = try queue.sync { () -> Operation in
+                    guard linkUp else { throw EscPosError.connection("Bluetooth device disconnected.") }
+                    let operation = begin(.write, token: nextToken())
+                    link.write(chunk, type: .withResponse, token: operation.token)
+                    return operation
+                }
+                do {
+                    try waitFor(operation, timeout: timeouts.write)
+                } catch let failure as EscPosError {
+                    throw failure
+                } catch {
+                    throw EscPosError.connection(error.localizedDescription)
+                }
+            }
+            offset = end
+        }
+        if !queue.sync({ linkUp }) {
+            throw EscPosError.connection("Bluetooth device disconnected.")
+        }
+    }
+
+    func linkDidConnect(attempt connected: Int) {
+        guard connected == attempt, let operation = current, operation.kind == .connect, operation.token == connected else {
+            ignoredCallbacks += 1
+            return
+        }
+        linkUp = true
+        finish(operation, error: nil)
+    }
+
+    func linkDidFailToConnect(attempt failed: Int, error: Error?) {
+        guard failed == attempt, let operation = current, operation.kind == .connect, operation.token == failed else {
+            ignoredCallbacks += 1
+            return
+        }
+        finish(operation, error: error ?? LinkFailure())
+    }
+
+    func linkDidDisconnect(attempt ended: Int, error: Error?) {
+        guard ended == attempt else {
+            tearingDown = false
+            ignoredCallbacks += 1
+            return
+        }
+        linkUp = false
+        writeType = nil
+        readiness?.signal()
+        if let operation = current {
+            finish(operation, error: error ?? LinkFailure())
+        }
+    }
+
+    func linkDidDiscover(attempt discovered: Int, writeType found: CBCharacteristicWriteType?, error: Error?) {
+        guard discovered == attempt, let operation = current, operation.kind == .discovery, operation.token == discovered else {
+            ignoredCallbacks += 1
+            return
+        }
+        if error == nil, let found = found {
+            writeType = found
+            finish(operation, error: nil)
+        } else {
+            finish(operation, error: error ?? LinkFailure())
+        }
+    }
+
+    func linkDidWrite(token: Int, error: Error?) {
+        guard let operation = current, operation.kind == .write, operation.token == token else {
+            ignoredCallbacks += 1
+            return
+        }
+        finish(operation, error: error)
+    }
+
+    func linkIsReadyToSend(attempt ready: Int) {
+        guard ready == attempt else {
+            ignoredCallbacks += 1
+            return
+        }
+        readiness?.signal()
+    }
+
+    private func nextToken() -> Int {
+        lastToken += 1
+        return lastToken
+    }
+
+    private func begin(_ kind: OperationKind, token: Int) -> Operation {
+        let operation = Operation(kind: kind, token: token)
+        current = operation
+        return operation
+    }
+
+    private func finish(_ operation: Operation, error: Error?) {
+        guard !operation.finished else { return }
+        operation.finished = true
+        operation.error = error
+        if current === operation {
+            current = nil
+        }
+        operation.semaphore.signal()
+    }
+
+    private func waitFor(_ operation: Operation, timeout: TimeInterval) throws {
+        if operation.semaphore.wait(timeout: .now() + timeout) == .timedOut {
+            queue.sync {
+                finish(operation, error: EscPosError.connection("Timed out while waiting for the Bluetooth device."))
+            }
+        }
+        if let error = queue.sync({ operation.error }) {
+            throw error
+        }
+    }
+
+    private func waitUntilReadyToWrite() throws {
+        let deadline = Date().addingTimeInterval(timeouts.write)
+        while true {
+            let (ready, connected, semaphore) = queue.sync { () -> (Bool, Bool, DispatchSemaphore) in
+                let semaphore = DispatchSemaphore(value: 0)
+                readiness = semaphore
+                return (link.canSendWriteWithoutResponse, linkUp, semaphore)
+            }
+            if !connected {
+                throw EscPosError.connection("Bluetooth device disconnected.")
+            }
+            if ready {
+                return
+            }
+            if Date() >= deadline {
+                throw EscPosError.connection("Timed out while sending data to device.")
+            }
+            _ = semaphore.wait(timeout: .now() + timeouts.readinessPoll)
+        }
+    }
+
+    private func invalidate() {
+        queue.sync {
+            if link.isConnected {
+                tearingDown = true
+            }
+            attempt = nextToken()
+            linkUp = false
+            writeType = nil
+            if let operation = current {
+                finish(operation, error: LinkFailure())
+            }
+            readiness?.signal()
+            link.cancel()
+        }
+    }
+}