@delicity/capacitor-thermal-printer 7.0.0

package/ios/Plugin/ThermalPrinterEngine.swift

@@ -0,0 +1,395 @@
+import Foundation
+import UIKit
+
+/// Cœur applicatif iOS (miroir de ThermalPrinterEngine.kt). Indépendant de Capacitor.
+final class ThermalPrinterEngine {
+
+    private let store = PrinterStore()
+    private let imageCache = ImageCache()
+
+    /// Registry d'adapters (l'ordre n'importe pas, priorité gérée ailleurs).
+    private lazy var adapters: [PrinterAdapter] = [
+        EpsonAdapter(), StarAdapter(), BrotherAdapter(), ZebraAdapter(),
+        EscPosAdapter(), RawTcpAdapter(),
+    ]
+
+    private var lastDiscovered: [DiscoveredPrinter] = []
+    private let lock = NSLock()
+
+    /// Émetteur d'états de job (branché par le plugin sur notifyListeners).
+    var onJobUpdate: ((JobUpdate) -> Void)?
+
+    /// Émetteur de changement de statut (branché par le plugin sur 'statusChange').
+    var onStatusChange: ((PrinterStatus) -> Void)?
+
+    /// Registre des moniteurs de statut actifs (Phase 6).
+    private var monitors: [String: Task<Void, Never>] = [:]
+    private let monitorLock = NSLock()
+
+    private func emitJob(_ jobId: String, _ printerId: String, _ state: String,
+                         holdReason: String? = nil, progress: Double? = nil,
+                         errorCode: ErrorCode? = nil, message: String? = nil) {
+        onJobUpdate?(JobUpdate(jobId: jobId, printerId: printerId, state: state,
+                               holdReason: holdReason, progress: progress, errorCode: errorCode, message: message))
+    }
+
+    // MARK: Découverte
+
+    func discover(_ options: DiscoveryManager.Options, emitPartial: @escaping (DiscoveredPrinter) -> Void) async -> (printers: [DiscoveredPrinter], failed: [String]) {
+        Logger.shared.log("discovery", "start")
+        let manager = DiscoveryManager(adapters: adapters)
+        var (printers, failed) = await manager.discover(options, emitPartial: emitPartial)
+        let defaultId = store.getDefault()?.id
+        for i in printers.indices {
+            printers[i].isDefault = printers[i].id == defaultId
+            printers[i].isConnected = adapterFor(printers[i].adapter)?.isConnected(printers[i].id) ?? false
+        }
+        lock.lock(); lastDiscovered = printers; lock.unlock()
+        Logger.shared.log("discovery", "complete", ["count": printers.count])
+        return (printers, failed)
+    }
+
+    // MARK: Connexion
+
+    func connect(_ printerId: String, timeoutMs: Int, forceAdapter: AdapterId?, setAsDefault: Bool = false) async throws -> Bool {
+        let profile = try resolveProfile(printerId, forceAdapter: forceAdapter)
+        guard let adapter = adapterFor(profile.adapter) else {
+            throw PrinterError(.UNSUPPORTED_PRINTER, "Aucun adapter pour \(profile.adapter.rawValue)")
+        }
+        guard adapter.isAvailable() else {
+            throw PrinterError(.SDK_NOT_AVAILABLE, "Adapter \(profile.adapter.rawValue) indisponible")
+        }
+        try await adapter.connect(profile, timeoutMs: timeoutMs)
+        let connected = adapter.isConnected(printerId)
+        // setAsDefault UNIQUEMENT si la connexion a réussi.
+        if connected && setAsDefault {
+            store.upsert(profile)
+            store.setDefault(printerId)
+            Logger.shared.log("connect", "set-default-after-connect", ["id": printerId])
+        }
+        return connected
+    }
+
+    func disconnect(_ printerId: String) async {
+        guard let profile = store.get(printerId) ?? ephemeral(for: printerId),
+              let adapter = adapterFor(profile.adapter) else { return }
+        await adapter.disconnect(printerId)
+    }
+
+    private static let reconnectAttempts = 3
+
+    /// Reconnexion auto avec **backoff exponentiel** (300ms, 600ms, 1200ms…, plafonné).
+    /// Les erreurs non-retryables court-circuitent.
+    private func ensureConnected(_ profile: PrinterProfile, timeoutMs: Int) async throws {
+        guard let adapter = adapterFor(profile.adapter) else {
+            throw PrinterError(.UNSUPPORTED_PRINTER, "Adapter introuvable")
+        }
+        if adapter.isConnected(profile.id) { return }
+
+        var backoff: UInt64 = 300
+        var lastError: Error?
+        for attempt in 1...Self.reconnectAttempts {
+            do {
+                Logger.shared.log("connect", "auto-reconnect", ["id": profile.id, "attempt": attempt])
+                try await adapter.connect(profile, timeoutMs: timeoutMs)
+                if adapter.isConnected(profile.id) {
+                    if attempt > 1 { Logger.shared.log("connect", "reconnect-recovered", ["id": profile.id, "attempt": attempt]) }
+                    return
+                }
+                lastError = PrinterError(.CONNECTION_FAILED, "Connexion non établie", retryable: true)
+            } catch let e as PrinterError {
+                lastError = e
+                if !e.retryable { throw e }
+            } catch {
+                lastError = error
+            }
+            if attempt < Self.reconnectAttempts {
+                Logger.shared.log("connect", "backoff", ["id": profile.id, "delayMs": backoff])
+                try? await Task.sleep(nanoseconds: backoff * 1_000_000)
+                backoff = min(backoff * 2, 3000)
+            }
+        }
+        throw lastError ?? PrinterError(.CONNECTION_FAILED, "Reconnexion échouée (\(Self.reconnectAttempts) tentatives)", retryable: true)
+    }
+
+    // MARK: Impression
+
+    struct PrintRequest {
+        let printerId: String?
+        let filePath: String?
+        let url: String?
+        let base64: String?
+        let render: RenderOptions?
+        let timeoutMs: Int
+        let autoReconnect: Bool
+    }
+
+    struct PrintTextRequest {
+        let printerId: String?
+        let items: [PrintItem]
+        let defaultCodePage: String
+        let cut: Bool
+        let feedLines: Int
+        let timeoutMs: Int
+        let autoReconnect: Bool
+    }
+
+    struct PrintOutcome {
+        let printerId: String
+        let adapter: AdapterId
+        let jobId: String
+        let state: String
+        let bytesSent: Int
+        let durationMs: Int
+        let status: PrinterStatus?
+    }
+
+    func printImage(_ req: PrintRequest) async throws -> PrintOutcome {
+        let started = Date()
+        let jobId = UUID().uuidString
+        let profile = try resolveTargetProfile(req.printerId)
+        emitJob(jobId, profile.id, "pending")
+        guard let adapter = adapterFor(profile.adapter) else {
+            let e = PrinterError(.UNSUPPORTED_PRINTER, "Adapter introuvable")
+            emitJob(jobId, profile.id, "failed", errorCode: e.code, message: e.message); throw e
+        }
+        do {
+            if !adapter.isConnected(profile.id) {
+                guard req.autoReconnect else { throw PrinterError(.CONNECTION_FAILED, "Imprimante non connectée") }
+                try await ensureConnected(profile, timeoutMs: req.timeoutMs)
+            }
+            try await preflightHold(adapter, profile, jobId)
+
+            let image = try await loadImage(req)
+            let render = resolveRenderOptions(profile, req.render)
+            let resized = render.resize ? try ImageProcessor.resizeToWidth(image, targetWidth: render.widthDots) : image
+
+            emitJob(jobId, profile.id, "printing", progress: 0.1)
+            let bytes = try await adapter.printImage(profile, image: resized, options: render)
+            let status = try? await adapter.getStatus(profile)
+            let duration = Int(Date().timeIntervalSince(started) * 1000)
+            emitJob(jobId, profile.id, "completed", progress: 1.0)
+            return PrintOutcome(printerId: profile.id, adapter: profile.adapter, jobId: jobId, state: "completed", bytesSent: bytes, durationMs: duration, status: status)
+        } catch let e as PrinterError {
+            emitJob(jobId, profile.id, "failed", errorCode: e.code, message: e.message); throw e
+        }
+    }
+
+    func printText(_ req: PrintTextRequest) async throws -> PrintOutcome {
+        let started = Date()
+        let jobId = UUID().uuidString
+        let profile = try resolveTargetProfile(req.printerId)
+        emitJob(jobId, profile.id, "pending")
+        guard let adapter = adapterFor(profile.adapter) else {
+            let e = PrinterError(.UNSUPPORTED_PRINTER, "Adapter introuvable")
+            emitJob(jobId, profile.id, "failed", errorCode: e.code, message: e.message); throw e
+        }
+        do {
+            if !adapter.isConnected(profile.id) {
+                guard req.autoReconnect else { throw PrinterError(.CONNECTION_FAILED, "Imprimante non connectée") }
+                try await ensureConnected(profile, timeoutMs: req.timeoutMs)
+            }
+            try await preflightHold(adapter, profile, jobId)
+
+            emitJob(jobId, profile.id, "printing", progress: 0.1)
+            let bytes: Int
+            if adapter.supportsTextItems() {
+                bytes = try await adapter.printItems(profile, items: req.items, defaultCodePage: req.defaultCodePage, cut: req.cut, feedLines: req.feedLines)
+            } else {
+                // Repli : rendre les items en image puis imprimer via le SDK image (Brother/Zebra).
+                let width = profile.capabilities.printableDots > 0 ? profile.capabilities.printableDots : 576
+                let image = TextRasterizer.render(req.items, widthDots: width)
+                var render = RenderOptions(widthDots: width)
+                render.resize = false
+                render.cut = req.cut
+                render.feedLines = req.feedLines
+                bytes = try await adapter.printImage(profile, image: image, options: render)
+            }
+            let status = try? await adapter.getStatus(profile)
+            let duration = Int(Date().timeIntervalSince(started) * 1000)
+            emitJob(jobId, profile.id, "completed", progress: 1.0)
+            return PrintOutcome(printerId: profile.id, adapter: profile.adapter, jobId: jobId, state: "completed", bytesSent: bytes, durationMs: duration, status: status)
+        } catch let e as PrinterError {
+            emitJob(jobId, profile.id, "failed", errorCode: e.code, message: e.message); throw e
+        }
+    }
+
+    /// Lit le statut avant impression ; émet HOLD + lève si papier/capot bloquant.
+    private func preflightHold(_ adapter: PrinterAdapter, _ profile: PrinterProfile, _ jobId: String) async throws {
+        guard profile.capabilities.supportsStatus else { return }
+        guard let st = try? await adapter.getStatus(profile) else { return }
+        if st.paper == "empty" {
+            emitJob(jobId, profile.id, "hold", holdReason: "paper_empty")
+            throw PrinterError(.PAPER_EMPTY, "Plus de papier", retryable: true)
+        }
+        if st.coverOpen == true {
+            emitJob(jobId, profile.id, "hold", holdReason: "cover_open")
+            throw PrinterError(.COVER_OPEN, "Capot ouvert", retryable: true)
+        }
+    }
+
+    // MARK: Profils
+
+    func savedProfiles() -> [PrinterProfile] { store.all() }
+    func defaultProfile() -> PrinterProfile? { store.getDefault() }
+    func removeProfile(_ id: String) { store.remove(id) }
+
+    func setDefault(_ printerId: String) throws -> PrinterProfile {
+        if store.get(printerId) != nil {
+            guard let updated = store.setDefault(printerId) else {
+                throw PrinterError(.PRINTER_NOT_FOUND, "Profil introuvable")
+            }
+            return updated
+        }
+        guard let d = ephemeralDiscovered(printerId) else {
+            throw PrinterError(.PRINTER_NOT_FOUND, "Imprimante inconnue: \(printerId)")
+        }
+        var profile = toEphemeralProfile(d)
+        profile.isDefault = true
+        store.upsert(profile)
+        return store.setDefault(printerId) ?? profile
+    }
+
+    func getStatus(_ printerId: String?) async throws -> PrinterStatus {
+        let profile = try resolveTargetProfile(printerId)
+        guard let adapter = adapterFor(profile.adapter) else {
+            throw PrinterError(.UNSUPPORTED_PRINTER, "Adapter introuvable")
+        }
+        return try await adapter.getStatus(profile)
+    }
+
+    // MARK: Monitoring de statut (Phase 6)
+
+    /// Démarre un polling périodique du statut et émet `statusChange` uniquement
+    /// quand l'état pertinent change (connexion/online/papier/capot). Idempotent.
+    func startStatusMonitor(_ printerId: String, intervalMs: Int) {
+        stopStatusMonitor(printerId)
+        let interval = min(max(intervalMs, 1000), 300_000)
+        let task = Task { [weak self] in
+            var lastKey: String?
+            var lastBlocked = false
+            while !Task.isCancelled {
+                guard let self = self else { return }
+                let status: PrinterStatus
+                do {
+                    status = try await self.getStatus(printerId)
+                } catch let e as PrinterError {
+                    status = PrinterStatus(id: printerId, connection: "error", online: false, paper: "unknown", errorCode: e.code, rawStatus: e.message)
+                } catch {
+                    status = PrinterStatus(id: printerId, connection: "error", online: false, paper: "unknown", rawStatus: "\(error)")
+                }
+                // "Bloqué" = condition qui mettrait un job en hold (papier/capot/offline).
+                let blocked = status.paper == "empty" || status.coverOpen == true || !status.online
+                let key = "\(status.connection)|\(status.online)|\(status.paper)|\(String(describing: status.coverOpen))|\(String(describing: status.errorCode))"
+                if key != lastKey {
+                    lastKey = key
+                    self.onStatusChange?(status)
+                    if lastBlocked && !blocked {
+                        // Reprise après hold (papier rechargé / capot fermé / retour online).
+                        Logger.shared.log("status", "recovered", ["id": printerId])
+                    }
+                    Logger.shared.log("status", "change", ["id": printerId, "paper": status.paper])
+                }
+                lastBlocked = blocked
+                try? await Task.sleep(nanoseconds: UInt64(interval) * 1_000_000)
+            }
+        }
+        monitorLock.lock(); monitors[printerId] = task; monitorLock.unlock()
+        Logger.shared.log("status", "monitor-start", ["id": printerId, "intervalMs": interval])
+    }
+
+    /// Arrête le moniteur d'une imprimante (no-op si absent).
+    func stopStatusMonitor(_ printerId: String) {
+        monitorLock.lock(); let t = monitors.removeValue(forKey: printerId); monitorLock.unlock()
+        t?.cancel()
+    }
+
+    /// Arrête tous les moniteurs.
+    func stopAllMonitors() {
+        monitorLock.lock(); let all = monitors; monitors.removeAll(); monitorLock.unlock()
+        all.values.forEach { $0.cancel() }
+    }
+
+    /// État courant de chaque adapter/SDK (cf. getActiveSdks).
+    func activeSdks() -> [[String: Any]] {
+        let star = adapters.first { $0 is StarAdapter }?.isAvailable() ?? false
+        let epson = adapters.first { $0 is EpsonAdapter }?.isAvailable() ?? false
+        let brother = adapters.first { $0 is BrotherAdapter }?.isAvailable() ?? false
+        let zebra = adapters.first { $0 is ZebraAdapter }?.isAvailable() ?? false
+        return [
+            ["adapter": "escpos", "label": "ESC/POS générique", "available": true, "requiresSdk": false, "transports": ["wifi", "ethernet"]],
+            ["adapter": "star", "label": "Star StarXpand", "available": star, "requiresSdk": true, "transports": ["wifi", "bluetooth", "ble"]],
+            ["adapter": "epson", "label": "Epson ePOS2", "available": epson, "requiresSdk": true, "transports": ["wifi", "bluetooth"]],
+            ["adapter": "brother", "label": "Brother", "available": brother, "requiresSdk": true, "transports": ["wifi", "bluetooth", "ble"]],
+            ["adapter": "zebra", "label": "Zebra Link-OS", "available": zebra, "requiresSdk": true, "transports": ["wifi", "bluetooth"]],
+            ["adapter": "rawTcp", "label": "TCP brut", "available": true, "requiresSdk": false, "transports": ["wifi", "ethernet"]],
+        ]
+    }
+
+    func debugLog() -> [[String: Any]] { Logger.shared.snapshot() }
+
+    // MARK: Helpers
+
+    private func adapterFor(_ id: AdapterId) -> PrinterAdapter? { adapters.first { $0.id == id } }
+
+    private func ephemeralDiscovered(_ id: String) -> DiscoveredPrinter? {
+        lock.lock(); defer { lock.unlock() }
+        return lastDiscovered.first { $0.id == id }
+    }
+
+    private func ephemeral(for id: String) -> PrinterProfile? {
+        ephemeralDiscovered(id).map(toEphemeralProfile)
+    }
+
+    private func resolveTargetProfile(_ printerId: String?) throws -> PrinterProfile {
+        guard let id = printerId else {
+            guard let def = store.getDefault() else {
+                throw PrinterError(.PRINTER_NOT_FOUND, "Aucune imprimante par défaut")
+            }
+            return def
+        }
+        return try resolveProfile(id, forceAdapter: nil)
+    }
+
+    private func resolveProfile(_ printerId: String, forceAdapter: AdapterId?) throws -> PrinterProfile {
+        if var p = store.get(printerId) {
+            if let f = forceAdapter { p.adapter = f }
+            return p
+        }
+        guard let d = ephemeralDiscovered(printerId) else {
+            throw PrinterError(.PRINTER_NOT_FOUND, "Imprimante inconnue: \(printerId)")
+        }
+        var base = toEphemeralProfile(d)
+        if let f = forceAdapter { base.adapter = f }
+        return base
+    }
+
+    private func toEphemeralProfile(_ d: DiscoveredPrinter) -> PrinterProfile {
+        PrinterProfile(
+            id: d.id, adapter: d.adapter, transport: d.transport, address: d.address,
+            brand: d.brand, model: d.model, name: d.name,
+            capabilities: d.capabilities ?? Capabilities()
+        )
+    }
+
+    private func loadImage(_ req: PrintRequest) async throws -> UIImage {
+        if let path = req.filePath, !path.isEmpty { return try ImageProcessor.decodeFile(path) }
+        if let url = req.url, !url.isEmpty {
+            let local = try await imageCache.fetch(url)
+            return try ImageProcessor.decodeFile(local)
+        }
+        if let b64 = req.base64, !b64.isEmpty { return try ImageProcessor.decodeBase64(b64) }
+        throw PrinterError(.IMAGE_INVALID, "Aucune source image fournie")
+    }
+
+    private func resolveRenderOptions(_ profile: PrinterProfile, _ req: RenderOptions?) -> RenderOptions {
+        var width = req?.widthDots ?? 0
+        if width <= 0 { width = profile.capabilities.printableDots }
+        if width <= 0 {
+            width = profile.capabilities.paperWidthMm == 58 ? 384 : (profile.capabilities.paperWidthMm == 112 ? 832 : 576)
+        }
+        var opts = req ?? RenderOptions(widthDots: width)
+        opts.widthDots = width
+        return opts
+    }
+}

package/ios/Plugin/ThermalPrinterPlugin.m

@@ -0,0 +1,22 @@
+#import <Foundation/Foundation.h>
+#import <Capacitor/Capacitor.h>
+
+// Enregistrement du plugin auprès du runtime Capacitor (Objective-C bridge).
+// Doit refléter les méthodes déclarées dans pluginMethods (ThermalPrinterPlugin.swift).
+CAP_PLUGIN(ThermalPrinterPlugin, "ThermalPrinter",
+    CAP_PLUGIN_METHOD(discoverPrinters, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(connectPrinter, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(disconnectPrinter, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(setDefaultPrinter, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(getDefaultPrinter, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(getSavedPrinters, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(removePrinter, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(printImage, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(printText, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(getPrinterStatus, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(requestPermissions, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(checkPermissions, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(startStatusMonitor, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(stopStatusMonitor, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(getDebugLog, CAPPluginReturnPromise);
+)

package/ios/Plugin/ThermalPrinterPlugin.swift

@@ -0,0 +1,258 @@
+import Foundation
+import Capacitor
+
+/// Pont Capacitor iOS (bridge JS <-> Swift). Conforme Capacitor 7 (CAPBridgedPlugin).
+///
+/// Mappe l'API publique (definitions.ts) vers ThermalPrinterEngine. Les opérations
+/// async tournent dans des Task ; les PrinterError sont converties en rejets
+/// avec code normalisé.
+@objc(ThermalPrinterPlugin)
+public class ThermalPrinterPlugin: CAPPlugin, CAPBridgedPlugin {
+
+    public let identifier = "ThermalPrinterPlugin"
+    public let jsName = "ThermalPrinter"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "discoverPrinters", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "connectPrinter", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "disconnectPrinter", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setDefaultPrinter", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getDefaultPrinter", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getSavedPrinters", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "removePrinter", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "printImage", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "printText", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getPrinterStatus", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "requestPermissions", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "checkPermissions", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "startStatusMonitor", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "stopStatusMonitor", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getActiveSdks", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getDebugLog", returnType: CAPPluginReturnPromise),
+    ]
+
+    private let engine = ThermalPrinterEngine()
+
+    override public func load() {
+        // Relaye les états de job vers le JS (event printJobStatus).
+        engine.onJobUpdate = { [weak self] update in
+            self?.notifyListeners("printJobStatus", data: ["job": update.toDict()])
+        }
+        // Relaye les changements de statut vers le JS (event statusChange).
+        engine.onStatusChange = { [weak self] status in
+            self?.notifyListeners("statusChange", data: ["status": status.toDict()])
+        }
+    }
+
+    // MARK: Permissions
+    //
+    // iOS n'a pas de permission runtime pour le Bluetooth Classic (inexistant) ni
+    // pour le réseau local au sens "demande explicite" : la pop-up Local Network
+    // apparaît à la première connexion. Le BLE déclenche une autorisation gérée par
+    // CoreBluetooth si on instancie un CBCentralManager (à activer avec BleAdapter).
+
+    @objc func checkPermissions(_ call: CAPPluginCall) {
+        call.resolve(permissionStatus())
+    }
+
+    @objc override public func requestPermissions(_ call: CAPPluginCall) {
+        // Rien à demander explicitement ici (voir note ci-dessus).
+        call.resolve(permissionStatus())
+    }
+
+    private func permissionStatus() -> [String: Any] {
+        [
+            "bluetooth": "unavailable",       // BT Classic générique impossible sur iOS
+            "bluetoothScan": "unavailable",
+            "bluetoothConnect": "unavailable",
+            "location": "granted",
+            "localNetwork": "prompt",          // pop-up système à la 1re connexion locale
+        ]
+    }
+
+    // MARK: Découverte
+
+    @objc func discoverPrinters(_ call: CAPPluginCall) {
+        let sources: Set<String>? = (call.getArray("sources") as? [String]).map { Set($0) }
+        let options = DiscoveryManager.Options(
+            sources: sources,
+            timeoutMs: call.getInt("timeoutMs") ?? 8000,
+            networkCidr: call.getString("networkCidr"),
+            tcpPorts: (call.getArray("tcpPorts") as? [Int]) ?? [9100]
+        )
+        let emitPartial = call.getBool("emitPartialResults") ?? true
+
+        Task {
+            let result = await engine.discover(options) { [weak self] p in
+                if emitPartial { self?.notifyListeners("printerFound", data: ["printer": p.toDict()]) }
+            }
+            let printersDict = result.printers.map { $0.toDict() }
+            self.notifyListeners("discoveryComplete", data: ["printers": printersDict, "failedSources": result.failed])
+            call.resolve(["printers": printersDict])
+        }
+    }
+
+    // MARK: Connexion
+
+    @objc func connectPrinter(_ call: CAPPluginCall) {
+        guard let printerId = call.getString("printerId") else {
+            return reject(call, .PRINTER_NOT_FOUND, "printerId requis")
+        }
+        let timeout = call.getInt("timeoutMs") ?? 10000
+        let force = call.getString("forceAdapter").map { AdapterId.from($0) }
+        let setAsDefault = call.getBool("setAsDefault") ?? false
+        Task { await self.guarded(call) {
+            let connected = try await self.engine.connect(printerId, timeoutMs: timeout, forceAdapter: force, setAsDefault: setAsDefault)
+            call.resolve(["connected": connected])
+        } }
+    }
+
+    @objc func disconnectPrinter(_ call: CAPPluginCall) {
+        let id = call.getString("printerId") ?? ""
+        Task { await self.engine.disconnect(id); call.resolve() }
+    }
+
+    // MARK: Profils
+
+    @objc func setDefaultPrinter(_ call: CAPPluginCall) {
+        guard let id = call.getString("printerId") else { return reject(call, .PRINTER_NOT_FOUND, "printerId requis") }
+        do {
+            let profile = try engine.setDefault(id)
+            call.resolve(["profile": profile.toDict()])
+        } catch { rejectError(call, error) }
+    }
+
+    @objc func getDefaultPrinter(_ call: CAPPluginCall) {
+        if let p = engine.defaultProfile() { call.resolve(["profile": p.toDict()]) }
+        else { call.resolve(["profile": NSNull()]) }
+    }
+
+    @objc func getSavedPrinters(_ call: CAPPluginCall) {
+        call.resolve(["profiles": engine.savedProfiles().map { $0.toDict() }])
+    }
+
+    @objc func removePrinter(_ call: CAPPluginCall) {
+        engine.removeProfile(call.getString("printerId") ?? "")
+        call.resolve()
+    }
+
+    // MARK: Impression / statut
+
+    @objc func printImage(_ call: CAPPluginCall) {
+        guard let image = call.getObject("image") else { return reject(call, .IMAGE_INVALID, "image requise") }
+        var render: RenderOptions?
+        if let r = call.getObject("render") {
+            render = RenderOptions(
+                widthDots: r["widthDots"] as? Int ?? 0,
+                resize: r["resize"] as? Bool ?? true,
+                grayscale: r["grayscale"] as? Bool ?? true,
+                threshold: r["threshold"] as? Int ?? 128,
+                dithering: r["dithering"] as? String ?? "floyd_steinberg",
+                align: r["align"] as? String ?? "center",
+                invert: r["invert"] as? Bool ?? false,
+                cut: r["cut"] as? Bool ?? true,
+                feedLines: r["feedLines"] as? Int ?? 3,
+                openCashDrawer: r["openCashDrawer"] as? Bool ?? false,
+                copies: r["copies"] as? Int ?? 1
+            )
+        }
+        let req = ThermalPrinterEngine.PrintRequest(
+            printerId: call.getString("printerId"),
+            filePath: image["filePath"] as? String,
+            url: image["url"] as? String,
+            base64: image["base64"] as? String,
+            render: render,
+            timeoutMs: call.getInt("timeoutMs") ?? 15000,
+            autoReconnect: call.getBool("autoReconnect") ?? true
+        )
+        Task { await self.guarded(call) {
+            let out = try await self.engine.printImage(req)
+            call.resolve(self.printResultDict(out))
+        } }
+    }
+
+    @objc func printText(_ call: CAPPluginCall) {
+        guard let rawItems = call.getArray("items") as? [[String: Any]] else {
+            return reject(call, .IMAGE_INVALID, "items requis")
+        }
+        let req = ThermalPrinterEngine.PrintTextRequest(
+            printerId: call.getString("printerId"),
+            items: PrintItem.parseList(rawItems),
+            defaultCodePage: call.getString("defaultCodePage") ?? "WPC1252",
+            cut: call.getBool("cut") ?? false,
+            feedLines: call.getInt("feedLines") ?? 3,
+            timeoutMs: call.getInt("timeoutMs") ?? 15000,
+            autoReconnect: call.getBool("autoReconnect") ?? true
+        )
+        Task { await self.guarded(call) {
+            let out = try await self.engine.printText(req)
+            call.resolve(self.printResultDict(out))
+        } }
+    }
+
+    private func printResultDict(_ out: ThermalPrinterEngine.PrintOutcome) -> [String: Any] {
+        var result: [String: Any] = [
+            "success": out.state == "completed",
+            "printerId": out.printerId,
+            "adapter": out.adapter.rawValue,
+            "jobId": out.jobId,
+            "state": out.state,
+            "bytesSent": out.bytesSent,
+            "durationMs": out.durationMs,
+        ]
+        if let status = out.status { result["status"] = status.toDict() }
+        return result
+    }
+
+    @objc func getPrinterStatus(_ call: CAPPluginCall) {
+        Task { await self.guarded(call) {
+            let status = try await self.engine.getStatus(call.getString("printerId"))
+            call.resolve(status.toDict())
+        } }
+    }
+
+    // MARK: Monitoring (Phase 6)
+
+    @objc func startStatusMonitor(_ call: CAPPluginCall) {
+        guard let printerId = call.getString("printerId") else {
+            return reject(call, .PRINTER_NOT_FOUND, "printerId requis")
+        }
+        engine.startStatusMonitor(printerId, intervalMs: call.getInt("intervalMs") ?? 5000)
+        call.resolve()
+    }
+
+    @objc func stopStatusMonitor(_ call: CAPPluginCall) {
+        guard let printerId = call.getString("printerId") else {
+            return reject(call, .PRINTER_NOT_FOUND, "printerId requis")
+        }
+        engine.stopStatusMonitor(printerId)
+        call.resolve()
+    }
+
+    @objc func getActiveSdks(_ call: CAPPluginCall) {
+        call.resolve(["sdks": engine.activeSdks()])
+    }
+
+    @objc func getDebugLog(_ call: CAPPluginCall) {
+        call.resolve(["log": engine.debugLog()])
+    }
+
+    // MARK: Plomberie erreurs
+
+    private func guarded(_ call: CAPPluginCall, _ block: () async throws -> Void) async {
+        do { try await block() } catch { rejectError(call, error) }
+    }
+
+    private func reject(_ call: CAPPluginCall, _ code: ErrorCode, _ message: String) {
+        call.reject(message, code.rawValue, nil, ["code": code.rawValue, "retryable": false])
+    }
+
+    private func rejectError(_ call: CAPPluginCall, _ error: Error) {
+        if let pe = error as? PrinterError {
+            Logger.shared.error("plugin", "\(pe.code.rawValue): \(pe.message)")
+            call.reject(pe.message, pe.code.rawValue, nil, ["code": pe.code.rawValue, "detail": pe.detail ?? "", "retryable": pe.retryable])
+        } else {
+            Logger.shared.error("plugin", "UNKNOWN: \(error.localizedDescription)")
+            call.reject(error.localizedDescription, ErrorCode.UNKNOWN.rawValue, error)
+        }
+    }
+}