@delicity/capacitor-thermal-printer 7.0.0

package/android/src/main/java/com/delicity/thermalprinter/image/ImageCache.kt

@@ -0,0 +1,88 @@
+package com.delicity.thermalprinter.image
+
+import android.content.Context
+import com.delicity.thermalprinter.Logger
+import com.delicity.thermalprinter.model.ErrorCode
+import com.delicity.thermalprinter.model.PrinterException
+import java.io.File
+import java.net.HttpURLConnection
+import java.net.URL
+import java.security.MessageDigest
+
+/**
+ * Cache local des images à imprimer.
+ *
+ * Objectif : éviter de re-télécharger une même URL et fournir un chemin fichier
+ * stable au pipeline (le mode fichier local est le plus fiable/performant).
+ *
+ * Emplacement : context.cacheDir/thermal-images/
+ * Clé de cache : SHA-1 de l'URL.
+ * Politique : LRU best-effort par date de modification, plafonné à MAX_BYTES.
+ */
+class ImageCache(context: Context) {
+
+    private val dir: File = File(context.cacheDir, "thermal-images").apply { mkdirs() }
+
+    /** Télécharge l'URL (si absente du cache) et renvoie le fichier local. */
+    fun fetch(url: String, timeoutMs: Int = 10000): File {
+        val key = sha1(url)
+        val cached = File(dir, "$key.img")
+        if (cached.exists() && cached.length() > 0) {
+            cached.setLastModified(System.currentTimeMillis())
+            Logger.log("image", "cache hit", mapOf("url" to url, "bytes" to cached.length()))
+            return cached
+        }
+        return download(url, cached, timeoutMs)
+    }
+
+    private fun download(url: String, dest: File, timeoutMs: Int): File {
+        var conn: HttpURLConnection? = null
+        try {
+            conn = (URL(url).openConnection() as HttpURLConnection).apply {
+                connectTimeout = timeoutMs
+                readTimeout = timeoutMs
+                requestMethod = "GET"
+                instanceFollowRedirects = true
+            }
+            val code = conn.responseCode
+            if (code !in 200..299) {
+                throw PrinterException(ErrorCode.IMAGE_INVALID, "HTTP $code en téléchargeant $url")
+            }
+            conn.inputStream.use { input ->
+                dest.outputStream().use { out -> input.copyTo(out, 8192) }
+            }
+            Logger.log("image", "downloaded", mapOf("url" to url, "bytes" to dest.length()))
+            enforceQuota()
+            return dest
+        } catch (e: PrinterException) {
+            throw e
+        } catch (e: Exception) {
+            throw PrinterException(ErrorCode.IMAGE_INVALID, "Téléchargement image échoué", e.message, retryable = true)
+        } finally {
+            conn?.disconnect()
+        }
+    }
+
+    /** Supprime les fichiers les plus anciens si le cache dépasse le quota. */
+    private fun enforceQuota() {
+        val files = dir.listFiles()?.sortedBy { it.lastModified() } ?: return
+        var total = files.sumOf { it.length() }
+        var i = 0
+        while (total > MAX_BYTES && i < files.size) {
+            total -= files[i].length()
+            files[i].delete()
+            i++
+        }
+    }
+
+    fun clear() {
+        dir.listFiles()?.forEach { it.delete() }
+    }
+
+    private fun sha1(s: String): String =
+        MessageDigest.getInstance("SHA-1").digest(s.toByteArray()).joinToString("") { "%02x".format(it) }
+
+    companion object {
+        private const val MAX_BYTES = 32L * 1024 * 1024 // 32 Mo
+    }
+}

package/android/src/main/java/com/delicity/thermalprinter/image/ImageProcessor.kt

@@ -0,0 +1,220 @@
+package com.delicity.thermalprinter.image
+
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.Canvas
+import android.graphics.Color
+import android.util.Base64
+import com.delicity.thermalprinter.model.ErrorCode
+import com.delicity.thermalprinter.model.PrinterException
+import com.delicity.thermalprinter.model.RenderOptions
+import java.io.ByteArrayOutputStream
+import java.io.File
+
+/**
+ * Pipeline de traitement image -> raster thermique.
+ *
+ * Étapes :
+ *   1. decode (fichier local / base64) en Bitmap ARGB
+ *   2. resize à la largeur cible (widthDots), hauteur proportionnelle
+ *   3. aplatir sur fond blanc (gérer la transparence PNG)
+ *   4. niveaux de gris (luminance ITU-R BT.601)
+ *   5. binarisation 1-bit (threshold / Floyd-Steinberg / Atkinson)
+ *   6. encodage raster ESC/POS GS v 0 (pour les adapters ESC/POS)
+ *
+ * Garde-fous mémoire : MAX_HEIGHT borne la hauteur pour éviter les OOM /
+ * débordements de buffer imprimante.
+ */
+object ImageProcessor {
+
+    /** Hauteur max d'un ticket en points (~ plusieurs mètres @203dpi). */
+    private const val MAX_HEIGHT = 20_000
+
+    // ---------------------------------------------------------------------
+    // 1. Décodage
+    // ---------------------------------------------------------------------
+
+    fun decodeFile(path: String): Bitmap {
+        val clean = path.removePrefix("file://")
+        val file = File(clean)
+        if (!file.exists()) {
+            throw PrinterException(ErrorCode.IMAGE_INVALID, "Fichier introuvable: $clean")
+        }
+        // Pré-lecture des bornes pour calculer un inSampleSize si l'image est énorme.
+        val bounds = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+        BitmapFactory.decodeFile(clean, bounds)
+        val opts = BitmapFactory.Options().apply {
+            inSampleSize = 1 // le resize final fait le vrai downscale
+            inPreferredConfig = Bitmap.Config.ARGB_8888
+        }
+        return BitmapFactory.decodeFile(clean, opts)
+            ?: throw PrinterException(ErrorCode.IMAGE_INVALID, "Décodage impossible: $clean")
+    }
+
+    fun decodeBase64(b64: String): Bitmap {
+        val payload = b64.substringAfter("base64,", b64) // tolère le préfixe data:
+        val bytes = try {
+            Base64.decode(payload, Base64.DEFAULT)
+        } catch (e: IllegalArgumentException) {
+            throw PrinterException(ErrorCode.IMAGE_INVALID, "Base64 invalide", e.message)
+        }
+        return BitmapFactory.decodeByteArray(bytes, 0, bytes.size)
+            ?: throw PrinterException(ErrorCode.IMAGE_INVALID, "Décodage base64 impossible")
+    }
+
+    // ---------------------------------------------------------------------
+    // 2 + 3. Resize sur fond blanc
+    // ---------------------------------------------------------------------
+
+    /** Redimensionne à [targetWidth] px, hauteur proportionnelle, fond blanc opaque. */
+    fun resizeToWidth(src: Bitmap, targetWidth: Int): Bitmap {
+        val w = targetWidth.coerceAtLeast(8)
+        val ratio = w.toDouble() / src.width.toDouble()
+        var h = Math.round(src.height * ratio).toInt().coerceAtLeast(1)
+        if (h > MAX_HEIGHT) {
+            throw PrinterException(
+                ErrorCode.IMAGE_TOO_LARGE,
+                "Image trop haute après resize: ${h}px (max $MAX_HEIGHT)",
+            )
+        }
+        val scaled = Bitmap.createScaledBitmap(src, w, h, true)
+        // Aplatir sur blanc pour neutraliser l'alpha (PNG transparents).
+        val flat = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888)
+        val canvas = Canvas(flat)
+        canvas.drawColor(Color.WHITE)
+        canvas.drawBitmap(scaled, 0f, 0f, null)
+        if (scaled != src) scaled.recycle()
+        return flat
+    }
+
+    // ---------------------------------------------------------------------
+    // 4 + 5. Niveaux de gris + binarisation
+    // ---------------------------------------------------------------------
+
+    /**
+     * Convertit en niveaux de gris (0=noir..255=blanc) dans un IntArray pixel-par-pixel.
+     */
+    private fun toGrayscale(bmp: Bitmap): IntArray {
+        val w = bmp.width
+        val h = bmp.height
+        val pixels = IntArray(w * h)
+        bmp.getPixels(pixels, 0, w, 0, 0, w, h)
+        val gray = IntArray(w * h)
+        for (i in pixels.indices) {
+            val p = pixels[i]
+            val r = (p shr 16) and 0xff
+            val g = (p shr 8) and 0xff
+            val b = p and 0xff
+            // luminance perceptuelle
+            gray[i] = ((0.299 * r) + (0.587 * g) + (0.114 * b)).toInt().coerceIn(0, 255)
+        }
+        return gray
+    }
+
+    /**
+     * Produit un MonoBitmap (1 = encre/noir) selon l'option de dithering.
+     * Si `options.grayscale == false`, on considère l'image déjà préparée
+     * (noir/blanc) : seuil simple, jamais de dithering.
+     */
+    fun toMono(bmp: Bitmap, options: RenderOptions): MonoBitmap {
+        val w = bmp.width
+        val h = bmp.height
+        val gray = toGrayscale(bmp)
+        if (options.invert) {
+            for (i in gray.indices) gray[i] = 255 - gray[i]
+        }
+        val data = when {
+            !options.grayscale -> threshold(gray, options.threshold)
+            options.dithering == "none" -> threshold(gray, options.threshold)
+            options.dithering == "atkinson" -> atkinson(gray, w, h)
+            else -> floydSteinberg(gray, w, h)
+        }
+        return MonoBitmap(w, h, data)
+    }
+
+    private fun threshold(gray: IntArray, t: Int): ByteArray {
+        val out = ByteArray(gray.size)
+        for (i in gray.indices) out[i] = if (gray[i] < t) 1 else 0
+        return out
+    }
+
+    private fun floydSteinberg(grayInput: IntArray, w: Int, h: Int): ByteArray {
+        val gray = FloatArray(grayInput.size) { grayInput[it].toFloat() }
+        val out = ByteArray(grayInput.size)
+        fun at(x: Int, y: Int) = y * w + x
+        for (y in 0 until h) {
+            for (x in 0 until w) {
+                val idx = at(x, y)
+                val old = gray[idx]
+                val new = if (old < 128f) 0f else 255f
+                out[idx] = if (new == 0f) 1 else 0
+                val err = old - new
+                if (x + 1 < w) gray[at(x + 1, y)] += err * 7f / 16f
+                if (x - 1 >= 0 && y + 1 < h) gray[at(x - 1, y + 1)] += err * 3f / 16f
+                if (y + 1 < h) gray[at(x, y + 1)] += err * 5f / 16f
+                if (x + 1 < w && y + 1 < h) gray[at(x + 1, y + 1)] += err * 1f / 16f
+            }
+        }
+        return out
+    }
+
+    private fun atkinson(grayInput: IntArray, w: Int, h: Int): ByteArray {
+        val gray = FloatArray(grayInput.size) { grayInput[it].toFloat() }
+        val out = ByteArray(grayInput.size)
+        fun at(x: Int, y: Int) = y * w + x
+        fun spread(x: Int, y: Int, e: Float) {
+            if (x in 0 until w && y in 0 until h) gray[at(x, y)] += e
+        }
+        for (y in 0 until h) {
+            for (x in 0 until w) {
+                val idx = at(x, y)
+                val old = gray[idx]
+                val new = if (old < 128f) 0f else 255f
+                out[idx] = if (new == 0f) 1 else 0
+                val err = (old - new) / 8f
+                spread(x + 1, y, err); spread(x + 2, y, err)
+                spread(x - 1, y + 1, err); spread(x, y + 1, err); spread(x + 1, y + 1, err)
+                spread(x, y + 2, err)
+            }
+        }
+        return out
+    }
+
+    // ---------------------------------------------------------------------
+    // 6. Encodage raster ESC/POS GS v 0
+    // ---------------------------------------------------------------------
+
+    /**
+     * Encode un MonoBitmap en commande raster ESC/POS `GS v 0` (mode normal).
+     * Largeur paddée au multiple de 8. Voir spec dans src/core/imaging.ts.
+     */
+    fun encodeEscPosRaster(mono: MonoBitmap): ByteArray {
+        val w = mono.width
+        val h = mono.height
+        val bytesPerRow = (w + 7) / 8
+        val xL = bytesPerRow and 0xff
+        val xH = (bytesPerRow shr 8) and 0xff
+        val yL = h and 0xff
+        val yH = (h shr 8) and 0xff
+        val header = byteArrayOf(0x1D, 0x76, 0x30, 0x00, xL.toByte(), xH.toByte(), yL.toByte(), yH.toByte())
+        val body = ByteArray(bytesPerRow * h)
+        for (y in 0 until h) {
+            val rowOff = y * bytesPerRow
+            val srcOff = y * w
+            for (x in 0 until w) {
+                if (mono.data[srcOff + x].toInt() == 1) {
+                    val byteIndex = rowOff + (x shr 3)
+                    val bit = 7 - (x and 7)
+                    body[byteIndex] = (body[byteIndex].toInt() or (1 shl bit)).toByte()
+                }
+            }
+        }
+        val out = ByteArrayOutputStream(header.size + body.size)
+        out.write(header)
+        out.write(body)
+        return out.toByteArray()
+    }
+}
+
+/** Image 1-bit : data[i]=1 => point noir/encre. */
+class MonoBitmap(val width: Int, val height: Int, val data: ByteArray)

package/android/src/main/java/com/delicity/thermalprinter/image/TextRasterizer.kt

@@ -0,0 +1,99 @@
+package com.delicity.thermalprinter.image
+
+import android.graphics.Bitmap
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Paint
+import android.graphics.Typeface
+import com.delicity.thermalprinter.model.PrintItem
+
+/**
+ * Rend une liste d'items texte (`printText`) en **bitmap monochrome**, pour les
+ * adapters dont le SDK ne propose pas de builder texte natif (Brother, Zebra).
+ * Le moteur appelle ensuite `printBitmap` → le SDK imprime l'image.
+ *
+ * Police monospace (alignement colonne fiable). Supporte : texte (align, gras,
+ * souligné, multiplicateurs de taille), séparateur, saut de ligne. Les items
+ * QR/code-barres sont rendus en texte de repli ; image/raw/cut/tiroir sont ignorés
+ * (utiliser `printImage` pour un QR/code-barres précis sur ces marques).
+ */
+object TextRasterizer {
+
+    private data class Line(
+        val text: String,
+        val sizeMul: Int,
+        val widthMul: Int,
+        val bold: Boolean,
+        val underline: Boolean,
+        val align: String,
+    )
+
+    fun render(items: List<PrintItem>, widthDots: Int): Bitmap {
+        val width = widthDots.coerceAtLeast(128)
+        val columns = if (width <= 420) 32 else 48
+
+        // Taille de base : caler la largeur de N caractères monospace sur la largeur cible.
+        val base = Paint(Paint.ANTI_ALIAS_FLAG).apply {
+            typeface = Typeface.MONOSPACE
+            textSize = 24f
+        }
+        val charW = base.measureText("M").coerceAtLeast(1f)
+        val baseTextSize = (24f * (width.toFloat() / columns) / charW)
+        base.textSize = baseTextSize
+        val baseLineH = base.fontMetrics.let { it.descent - it.ascent + it.leading }
+
+        // Pass 1 : construire la liste de lignes + hauteur totale.
+        val lines = mutableListOf<Line?>() // null = ligne vide (feed)
+        for (item in items) {
+            when (item) {
+                is PrintItem.Text -> {
+                    val s = item.style
+                    item.value.split("\n").forEachIndexed { idx, raw ->
+                        lines.add(Line(raw, s.heightMultiplier.coerceIn(1, 6), s.widthMultiplier.coerceIn(1, 6), s.bold, s.underline != "none", s.align ?: "left"))
+                        // newline=false sur le dernier fragment : on garde quand même une ligne (simplifié).
+                        if (!s.newline && idx == 0) Unit
+                    }
+                }
+                is PrintItem.Divider -> {
+                    val cols = item.columns ?: columns
+                    lines.add(Line(item.char.take(1).ifEmpty { "-" }.repeat(cols.coerceIn(1, 96)), 1, 1, item.bold, false, item.align ?: "left"))
+                }
+                is PrintItem.Feed -> repeat(item.lines.coerceIn(1, 20)) { lines.add(null) }
+                is PrintItem.QrCode -> lines.add(Line("[QR] ${item.value}", 1, 1, false, false, item.align))
+                is PrintItem.Barcode -> lines.add(Line("[${item.symbology}] ${item.value}", 1, 1, false, false, item.align))
+                is PrintItem.Cut, is PrintItem.CashDrawer, is PrintItem.Image, is PrintItem.Raw -> Unit
+            }
+        }
+        if (lines.isEmpty()) lines.add(null)
+
+        val totalHeight = lines.sumOf { line ->
+            ((line?.sizeMul ?: 1) * baseLineH).toDouble()
+        }.toInt().coerceAtLeast(baseLineH.toInt())
+
+        // Pass 2 : dessiner.
+        val bmp = Bitmap.createBitmap(width, totalHeight + 8, Bitmap.Config.ARGB_8888)
+        val canvas = Canvas(bmp)
+        canvas.drawColor(Color.WHITE)
+        val paint = Paint(Paint.ANTI_ALIAS_FLAG).apply { color = Color.BLACK; typeface = Typeface.MONOSPACE }
+
+        var y = 0f
+        for (line in lines) {
+            if (line == null) { y += baseLineH; continue }
+            paint.textSize = baseTextSize * line.sizeMul
+            paint.textScaleX = line.widthMul.toFloat()
+            paint.isFakeBoldText = line.bold
+            paint.isUnderlineText = line.underline
+            val lineH = baseLineH * line.sizeMul
+            val textW = paint.measureText(line.text)
+            val x = when (line.align) {
+                "center" -> (width - textW) / 2f
+                "right" -> width - textW
+                else -> 0f
+            }.coerceAtLeast(0f)
+            // baseline = y - ascent
+            canvas.drawText(line.text, x, y - paint.fontMetrics.ascent, paint)
+            y += lineH
+        }
+        return bmp
+    }
+}

package/android/src/main/java/com/delicity/thermalprinter/model/Models.kt

@@ -0,0 +1,206 @@
+package com.delicity.thermalprinter.model
+
+import org.json.JSONArray
+import org.json.JSONObject
+
+/** Transports physiques. Doit rester aligné avec PrinterTransport (TypeScript). */
+enum class Transport(val value: String) {
+    WIFI("wifi"),
+    ETHERNET("ethernet"),
+    BLUETOOTH("bluetooth"),
+    BLE("ble"),
+    USB("usb");
+
+    companion object {
+        fun from(v: String?): Transport =
+            entries.firstOrNull { it.value == v } ?: WIFI
+    }
+}
+
+/** Identifiants d'adapter. Aligné avec PrinterAdapterId (TypeScript). */
+enum class AdapterId(val value: String) {
+    ESCPOS("escpos"),
+    EPSON("epson"),
+    STAR("star"),
+    BROTHER("brother"),
+    ZEBRA("zebra"),
+    RAW_TCP("rawTcp");
+
+    companion object {
+        fun from(v: String?): AdapterId =
+            entries.firstOrNull { it.value == v } ?: ESCPOS
+    }
+}
+
+/** Codes d'erreur normalisés. Aligné avec PrintErrorCode (TypeScript). */
+enum class ErrorCode {
+    PRINTER_NOT_FOUND, PRINTER_OFFLINE, CONNECTION_FAILED, PERMISSION_DENIED,
+    BLUETOOTH_DISABLED, WIFI_NOT_CONNECTED, PAIRING_REQUIRED, UNSUPPORTED_TRANSPORT,
+    UNSUPPORTED_PRINTER, IMAGE_INVALID, IMAGE_TOO_LARGE, PRINT_FAILED, PAPER_EMPTY,
+    COVER_OPEN, SDK_NOT_AVAILABLE, TIMEOUT, UNKNOWN
+}
+
+/** Exception interne portant un code normalisé, convertie en rejet Capacitor. */
+class PrinterException(
+    val code: ErrorCode,
+    message: String,
+    val detail: String? = null,
+    val retryable: Boolean = false,
+) : Exception(message)
+
+data class Capabilities(
+    val paperWidthMm: Int = 80,
+    val printableDots: Int = 576,
+    val dpi: Int = 203,
+    val supportsCut: Boolean = true,
+    val supportsCashDrawer: Boolean = false,
+    val supportsStatus: Boolean = false,
+    val supportsRasterImage: Boolean = true,
+    val supportsQrCode: Boolean = false,
+    val supportsBarcode: Boolean = false,
+) {
+    fun toJson(): JSONObject = JSONObject()
+        .put("paperWidthMm", paperWidthMm)
+        .put("printableDots", printableDots)
+        .put("dpi", dpi)
+        .put("supportsCut", supportsCut)
+        .put("supportsCashDrawer", supportsCashDrawer)
+        .put("supportsStatus", supportsStatus)
+        .put("supportsRasterImage", supportsRasterImage)
+        .put("supportsQrCode", supportsQrCode)
+        .put("supportsBarcode", supportsBarcode)
+
+    companion object {
+        fun fromJson(o: JSONObject?): Capabilities {
+            if (o == null) return Capabilities()
+            return Capabilities(
+                paperWidthMm = o.optInt("paperWidthMm", 80),
+                printableDots = o.optInt("printableDots", 576),
+                dpi = o.optInt("dpi", 203),
+                supportsCut = o.optBoolean("supportsCut", true),
+                supportsCashDrawer = o.optBoolean("supportsCashDrawer", false),
+                supportsStatus = o.optBoolean("supportsStatus", false),
+                supportsRasterImage = o.optBoolean("supportsRasterImage", true),
+                supportsQrCode = o.optBoolean("supportsQrCode", false),
+                supportsBarcode = o.optBoolean("supportsBarcode", false),
+            )
+        }
+    }
+}
+
+/** Imprimante découverte/normalisée. */
+data class DiscoveredPrinter(
+    val id: String,
+    val name: String,
+    val brand: String? = null,
+    val model: String? = null,
+    val transport: Transport,
+    val adapter: AdapterId,
+    val address: String,
+    val capabilities: Capabilities? = null,
+    val discoveredBy: MutableSet<AdapterId> = mutableSetOf(),
+    var lastSeenAt: Long = System.currentTimeMillis(),
+    var isDefault: Boolean = false,
+    var isConnected: Boolean = false,
+) {
+    fun toJson(): JSONObject = JSONObject().apply {
+        put("id", id)
+        put("name", name)
+        brand?.let { put("brand", it) }
+        model?.let { put("model", it) }
+        put("transport", transport.value)
+        put("adapter", adapter.value)
+        put("address", address)
+        capabilities?.let { put("capabilities", it.toJson()) }
+        put("discoveredBy", JSONArray(discoveredBy.map { it.value }))
+        put("lastSeenAt", lastSeenAt)
+        put("isDefault", isDefault)
+        put("isConnected", isConnected)
+    }
+}
+
+/** Profil persistant. */
+data class PrinterProfile(
+    val id: String,
+    val adapter: AdapterId,
+    val transport: Transport,
+    val address: String,
+    val brand: String?,
+    val model: String?,
+    val name: String,
+    val capabilities: Capabilities,
+    val adapterMeta: JSONObject = JSONObject(),
+    var isDefault: Boolean = false,
+    val createdAt: Long = System.currentTimeMillis(),
+    var updatedAt: Long = System.currentTimeMillis(),
+) {
+    fun toJson(): JSONObject = JSONObject().apply {
+        put("id", id)
+        put("adapter", adapter.value)
+        put("transport", transport.value)
+        put("address", address)
+        brand?.let { put("brand", it) }
+        model?.let { put("model", it) }
+        put("name", name)
+        put("capabilities", capabilities.toJson())
+        put("adapterMeta", adapterMeta)
+        put("isDefault", isDefault)
+        put("createdAt", createdAt)
+        put("updatedAt", updatedAt)
+    }
+
+    companion object {
+        fun fromJson(o: JSONObject): PrinterProfile = PrinterProfile(
+            id = o.getString("id"),
+            adapter = AdapterId.from(o.optString("adapter")),
+            transport = Transport.from(o.optString("transport")),
+            address = o.getString("address"),
+            brand = o.optString("brand").ifEmpty { null },
+            model = o.optString("model").ifEmpty { null },
+            name = o.optString("name"),
+            capabilities = Capabilities.fromJson(o.optJSONObject("capabilities")),
+            adapterMeta = o.optJSONObject("adapterMeta") ?: JSONObject(),
+            isDefault = o.optBoolean("isDefault", false),
+            createdAt = o.optLong("createdAt", System.currentTimeMillis()),
+            updatedAt = o.optLong("updatedAt", System.currentTimeMillis()),
+        )
+    }
+}
+
+/** Statut temps réel. */
+data class PrinterStatus(
+    val id: String,
+    val connection: String, // disconnected|connecting|connected|error
+    val online: Boolean,
+    val paper: String, // ok|near_end|empty|unknown
+    val coverOpen: Boolean? = null,
+    val errorCode: ErrorCode? = null,
+    val rawStatus: String? = null,
+    val checkedAt: Long = System.currentTimeMillis(),
+) {
+    fun toJson(): JSONObject = JSONObject().apply {
+        put("id", id)
+        put("connection", connection)
+        put("online", online)
+        put("paper", paper)
+        coverOpen?.let { put("coverOpen", it) }
+        errorCode?.let { put("errorCode", it.name) }
+        rawStatus?.let { put("rawStatus", it) }
+        put("checkedAt", checkedAt)
+    }
+}
+
+/** Options de rendu résolues passées à l'adapter. */
+data class RenderOptions(
+    val widthDots: Int,
+    val resize: Boolean = true,
+    val grayscale: Boolean = true,
+    val threshold: Int = 128,
+    val dithering: String = "floyd_steinberg", // none|floyd_steinberg|atkinson
+    val align: String = "center", // left|center|right
+    val invert: Boolean = false,
+    val cut: Boolean = true,
+    val feedLines: Int = 3,
+    val openCashDrawer: Boolean = false,
+    val copies: Int = 1,
+)