@delicity/capacitor-thermal-printer 7.0.0

package/android/src/main/java/com/delicity/thermalprinter/adapters/EscPosTextEncoder.kt

@@ -0,0 +1,138 @@
+package com.delicity.thermalprinter.adapters
+
+import com.delicity.thermalprinter.model.PrintItem
+import com.delicity.thermalprinter.model.TextStyle
+import java.io.ByteArrayOutputStream
+import android.util.Base64
+
+/**
+ * Encodeur ESC/POS texte (miroir Kotlin de src/core/escpos-text.ts).
+ * Transforme une liste de PrintItem en flux d'octets ESC/POS.
+ *
+ * Les items `image` sont signalés via [imageIndexes] et NON encodés ici :
+ * ils sont rendus par le pipeline image (ImageProcessor) et insérés par le moteur.
+ */
+object EscPosTextEncoder {
+
+    private const val ESC = 0x1B
+    private const val GS = 0x1D
+    private const val LF = 0x0A
+
+    private val CODE_PAGE_TO_ESC_T = mapOf(
+        "CP437" to 0, "CP850" to 2, "CP858" to 19, "WPC1252" to 16, "CP852" to 18, "CP866" to 17,
+    )
+
+    private val BARCODE_M = mapOf(
+        "UPC_A" to 65, "UPC_E" to 66, "EAN13" to 67, "EAN8" to 68,
+        "CODE39" to 69, "ITF" to 70, "CODABAR" to 71, "CODE93" to 72, "CODE128" to 73,
+    )
+
+    data class Encoded(val bytes: ByteArray, val imageIndexes: List<Int>)
+
+    fun encodeString(value: String): ByteArray {
+        val out = ByteArrayOutputStream()
+        value.codePoints().forEach { cp -> out.write(if (cp <= 0xFF) cp else 0x3F) }
+        return out.toByteArray()
+    }
+
+    fun sizeByte(w: Int, h: Int): Int {
+        val ww = (w.coerceIn(1, 8)) - 1
+        val hh = (h.coerceIn(1, 8)) - 1
+        return (ww shl 4) or hh
+    }
+
+    private fun openStyle(out: ByteArrayOutputStream, s: TextStyle, defaultCodePage: String) {
+        val cp = s.codePageId ?: (CODE_PAGE_TO_ESC_T[s.codePage ?: defaultCodePage] ?: 16)
+        out.write(byteArrayOf(ESC.toByte(), 0x74, (cp and 0xFF).toByte()))
+        val align = when (s.align) { "center" -> 1; "right" -> 2; else -> 0 }
+        out.write(byteArrayOf(ESC.toByte(), 0x61, align.toByte()))
+        out.write(byteArrayOf(ESC.toByte(), 0x4D, if (s.font == "B") 1 else 0))
+        out.write(byteArrayOf(ESC.toByte(), 0x45, if (s.bold) 1 else 0))
+        out.write(byteArrayOf(ESC.toByte(), 0x47, if (s.doubleStrike) 1 else 0))
+        val ul = when (s.underline) { "single" -> 1; "double" -> 2; else -> 0 }
+        out.write(byteArrayOf(ESC.toByte(), 0x2D, ul.toByte()))
+        out.write(byteArrayOf(GS.toByte(), 0x42, if (s.invert) 1 else 0))
+        out.write(byteArrayOf(ESC.toByte(), 0x7B, if (s.upsideDown) 1 else 0))
+        out.write(byteArrayOf(ESC.toByte(), 0x56, if (s.rotate90) 1 else 0))
+        out.write(byteArrayOf(GS.toByte(), 0x21, sizeByte(s.widthMultiplier, s.heightMultiplier).toByte()))
+        s.letterSpacing?.let { out.write(byteArrayOf(ESC.toByte(), 0x20, (it and 0xFF).toByte())) }
+        if (s.lineSpacing != null) out.write(byteArrayOf(ESC.toByte(), 0x33, (s.lineSpacing and 0xFF).toByte()))
+        else out.write(byteArrayOf(ESC.toByte(), 0x32))
+    }
+
+    private fun reset(out: ByteArrayOutputStream) = out.write(byteArrayOf(ESC.toByte(), 0x40))
+
+    private fun qrCode(out: ByteArrayOutputStream, item: PrintItem.QrCode) {
+        val align = when (item.align) { "left" -> 0; "right" -> 2; else -> 1 }
+        out.write(byteArrayOf(ESC.toByte(), 0x61, align.toByte()))
+        out.write(byteArrayOf(GS.toByte(), 0x28, 0x6B, 0x04, 0x00, 0x31, 0x41, 0x32, 0x00))
+        val size = item.size.coerceIn(1, 16)
+        out.write(byteArrayOf(GS.toByte(), 0x28, 0x6B, 0x03, 0x00, 0x31, 0x43, size.toByte()))
+        val ec = when (item.ec) { "L" -> 48; "Q" -> 50; "H" -> 51; else -> 49 }
+        out.write(byteArrayOf(GS.toByte(), 0x28, 0x6B, 0x03, 0x00, 0x31, 0x45, ec.toByte()))
+        val data = encodeString(item.value)
+        val len = data.size + 3
+        out.write(byteArrayOf(GS.toByte(), 0x28, 0x6B, (len and 0xFF).toByte(), ((len shr 8) and 0xFF).toByte(), 0x31, 0x50, 0x30))
+        out.write(data)
+        out.write(byteArrayOf(GS.toByte(), 0x28, 0x6B, 0x03, 0x00, 0x31, 0x51, 0x30))
+    }
+
+    private fun barcode(out: ByteArrayOutputStream, item: PrintItem.Barcode) {
+        val align = when (item.align) { "left" -> 0; "right" -> 2; else -> 1 }
+        out.write(byteArrayOf(ESC.toByte(), 0x61, align.toByte()))
+        val hri = when (item.hri) { "above" -> 1; "both" -> 3; "none" -> 0; else -> 2 }
+        out.write(byteArrayOf(GS.toByte(), 0x48, hri.toByte()))
+        out.write(byteArrayOf(GS.toByte(), 0x68, item.height.coerceIn(1, 255).toByte()))
+        out.write(byteArrayOf(GS.toByte(), 0x77, item.width.coerceIn(2, 6).toByte()))
+        val m = BARCODE_M[item.symbology] ?: 73
+        var data = encodeString(item.value)
+        if (item.symbology == "CODE128" && !(data.isNotEmpty() && data[0].toInt() == 0x7B)) {
+            data = byteArrayOf(0x7B, 0x42) + data
+        }
+        out.write(byteArrayOf(GS.toByte(), 0x6B, m.toByte(), data.size.toByte()))
+        out.write(data)
+    }
+
+    fun encode(items: List<PrintItem>, defaultCodePage: String = "WPC1252", columns: Int = 48): Encoded {
+        val out = ByteArrayOutputStream()
+        val imageIndexes = mutableListOf<Int>()
+        reset(out)
+        items.forEachIndexed { index, item ->
+            when (item) {
+                is PrintItem.Text -> {
+                    openStyle(out, item.style, defaultCodePage)
+                    out.write(encodeString(item.value))
+                    if (item.style.newline) out.write(LF)
+                    reset(out)
+                }
+                is PrintItem.Feed -> out.write(byteArrayOf(ESC.toByte(), 0x64, item.lines.coerceIn(0, 255).toByte()))
+                is PrintItem.Divider -> {
+                    val ch = (item.char.firstOrNull() ?: '-').code
+                    val n = item.columns ?: columns
+                    val align = when (item.align) { "center" -> 1; "right" -> 2; else -> 0 }
+                    out.write(byteArrayOf(ESC.toByte(), 0x61, align.toByte()))
+                    if (item.bold) out.write(byteArrayOf(ESC.toByte(), 0x45, 1))
+                    repeat(n) { out.write(ch) }
+                    out.write(LF)
+                    reset(out)
+                }
+                is PrintItem.QrCode -> qrCode(out, item)
+                is PrintItem.Barcode -> barcode(out, item)
+                is PrintItem.CashDrawer -> out.write(
+                    if (item.pin == 5) byteArrayOf(ESC.toByte(), 0x70, 0x01, 0x19, 0xFA.toByte())
+                    else byteArrayOf(ESC.toByte(), 0x70, 0x00, 0x19, 0xFA.toByte()),
+                )
+                is PrintItem.Cut -> {
+                    if (item.feedBefore > 0) out.write(byteArrayOf(ESC.toByte(), 0x64, (item.feedBefore and 0xFF).toByte()))
+                    out.write(if (item.mode == "full") byteArrayOf(GS.toByte(), 0x56, 0x00) else byteArrayOf(GS.toByte(), 0x56, 0x01))
+                }
+                is PrintItem.Raw -> {
+                    val clean = if (item.bytesBase64.contains("base64,")) item.bytesBase64.substringAfter("base64,") else item.bytesBase64
+                    out.write(Base64.decode(clean, Base64.DEFAULT))
+                }
+                is PrintItem.Image -> imageIndexes.add(index)
+            }
+        }
+        return Encoded(out.toByteArray(), imageIndexes)
+    }
+}

package/android/src/main/java/com/delicity/thermalprinter/adapters/PrinterAdapter.kt

@@ -0,0 +1,95 @@
+package com.delicity.thermalprinter.adapters
+
+import android.graphics.Bitmap
+import com.delicity.thermalprinter.model.AdapterId
+import com.delicity.thermalprinter.model.DiscoveredPrinter
+import com.delicity.thermalprinter.model.PrinterProfile
+import com.delicity.thermalprinter.model.PrinterStatus
+import com.delicity.thermalprinter.model.RenderOptions
+
+/**
+ * Contrat commun à tous les adapters natifs Android.
+ *
+ * Un adapter encapsule TOUT ce qui est spécifique à une famille d'imprimantes :
+ *   - sa découverte (via SDK ou scan générique),
+ *   - sa connexion / reconnexion,
+ *   - la conversion d'un Bitmap déjà binarisé en commandes natives,
+ *   - l'envoi,
+ *   - la lecture de statut.
+ *
+ * Le moteur (ThermalPrinterEngine) orchestre les adapters et applique la priorité.
+ * Toutes les méthodes longues sont `suspend` (exécutées sur Dispatchers.IO).
+ */
+interface PrinterAdapter {
+
+    val id: AdapterId
+
+    /** True si le SDK requis est présent dans l'app (sinon l'adapter est ignoré). */
+    fun isAvailable(): Boolean
+
+    /**
+     * Lance une découverte propre à cet adapter. Les résultats partiels peuvent
+     * être émis via [onFound] au fil de l'eau. La méthode se termine quand le
+     * scan est fini ou que [timeoutMs] est atteint.
+     */
+    suspend fun discover(
+        timeoutMs: Long,
+        onFound: (DiscoveredPrinter) -> Unit,
+    )
+
+    /** Indique si cet adapter sait gérer ce profil (transport + identité). */
+    fun canHandle(profile: PrinterProfile): Boolean
+
+    /**
+     * True si l'adapter sait imprimer des items texte NATIVEMENT (encodeur ESC/POS
+     * ou builder texte du SDK). Si false, le moteur effectue un repli automatique :
+     * il rend les items en image (TextRasterizer) puis appelle [printBitmap].
+     * Voir docs/SDK_INTEGRATION.md (printText sur marques SDK).
+     */
+    fun supportsTextItems(): Boolean = false
+
+    /** Ouvre une connexion. Idempotent : ne rien faire si déjà connecté. */
+    suspend fun connect(profile: PrinterProfile, timeoutMs: Long)
+
+    /** True si une connexion active existe pour cette imprimante. */
+    fun isConnected(printerId: String): Boolean
+
+    /** Ferme la connexion. */
+    suspend fun disconnect(printerId: String)
+
+    /**
+     * Imprime un bitmap.
+     *
+     * IMPORTANT : `bitmap` est DÉJÀ redimensionné à la largeur cible et
+     * binarisé/dithered par le moteur (ImageProcessor). Pour les adapters ESC/POS,
+     * il suffit de l'encoder en raster GS v 0. Pour les SDK fabricants, on passe
+     * le bitmap à l'API d'impression image du SDK.
+     *
+     * @return nombre d'octets envoyés (best effort).
+     */
+    suspend fun printBitmap(profile: PrinterProfile, bitmap: Bitmap, options: RenderOptions): Int
+
+    /**
+     * Imprime une liste d'items texte stylés (+ QR/code-barres/feed/cut...).
+     * Pour ESC/POS : encodage via EscPosTextEncoder. Pour les SDK fabricants :
+     * mapping vers le builder du SDK (voir docs/SDK_INTEGRATION.md).
+     *
+     * Implémentation par défaut : non supportée (les adapters SDK la surchargent
+     * avec leur builder texte ; ESC/POS et rawTcp l'implémentent via l'encodeur).
+     *
+     * @return nombre d'octets envoyés (best effort).
+     */
+    suspend fun printItems(
+        profile: PrinterProfile,
+        items: List<com.delicity.thermalprinter.model.PrintItem>,
+        defaultCodePage: String,
+        cut: Boolean,
+        feedLines: Int,
+    ): Int = throw com.delicity.thermalprinter.model.PrinterException(
+        com.delicity.thermalprinter.model.ErrorCode.SDK_NOT_AVAILABLE,
+        "printText non implémenté pour cet adapter (${id.value}) — voir docs/SDK_INTEGRATION.md",
+    )
+
+    /** Lit le statut. Renvoie supportsStatus=false via online/paper=unknown si non supporté. */
+    suspend fun getStatus(profile: PrinterProfile): PrinterStatus
+}

package/android/src/main/java/com/delicity/thermalprinter/adapters/RawTcpAdapter.kt

@@ -0,0 +1,96 @@
+package com.delicity.thermalprinter.adapters
+
+import android.graphics.Bitmap
+import com.delicity.thermalprinter.image.ImageProcessor
+import com.delicity.thermalprinter.model.AdapterId
+import com.delicity.thermalprinter.model.DiscoveredPrinter
+import com.delicity.thermalprinter.model.ErrorCode
+import com.delicity.thermalprinter.model.PrinterException
+import com.delicity.thermalprinter.model.PrinterProfile
+import com.delicity.thermalprinter.model.PrinterStatus
+import com.delicity.thermalprinter.model.RenderOptions
+import com.delicity.thermalprinter.model.Transport
+import com.delicity.thermalprinter.transport.TcpTransport
+import java.util.concurrent.ConcurrentHashMap
+
+/**
+ * Adapter "filet de sécurité" réseau : envoie un raster ESC/POS sur un socket TCP
+ * brut sans rien présumer du dialecte de statut. Utilisé quand une imprimante
+ * réseau n'est identifiée par aucun SDK et n'a pas confirmé l'ESC/POS.
+ *
+ * Priorité la plus basse (voir priority.ts). Ne lit jamais de statut.
+ */
+class RawTcpAdapter : PrinterAdapter {
+
+    override val id = AdapterId.RAW_TCP
+    private val connections = ConcurrentHashMap<String, TcpTransport>()
+
+    override fun isAvailable(): Boolean = true
+
+    override fun supportsTextItems(): Boolean = true
+
+    override suspend fun discover(timeoutMs: Long, onFound: (DiscoveredPrinter) -> Unit) {
+        // Délégué au TcpScanner.
+    }
+
+    override fun canHandle(profile: PrinterProfile): Boolean =
+        profile.adapter == AdapterId.RAW_TCP &&
+            profile.transport in setOf(Transport.WIFI, Transport.ETHERNET)
+
+    override suspend fun connect(profile: PrinterProfile, timeoutMs: Long) {
+        if (isConnected(profile.id)) return
+        val idx = profile.address.lastIndexOf(':')
+        val host = if (idx > 0) profile.address.substring(0, idx) else profile.address
+        val port = if (idx > 0) profile.address.substring(idx + 1).toIntOrNull() ?: 9100 else 9100
+        val t = TcpTransport(host, port)
+        t.open(timeoutMs)
+        connections[profile.id] = t
+    }
+
+    override fun isConnected(printerId: String): Boolean = connections[printerId]?.isOpen == true
+
+    override suspend fun disconnect(printerId: String) {
+        connections.remove(printerId)?.close()
+    }
+
+    override suspend fun printBitmap(profile: PrinterProfile, bitmap: Bitmap, options: RenderOptions): Int {
+        val t = connections[profile.id]
+            ?: throw PrinterException(ErrorCode.CONNECTION_FAILED, "rawTcp non connecté")
+        val mono = ImageProcessor.toMono(bitmap, options)
+        val raster = ImageProcessor.encodeEscPosRaster(mono)
+        val job = EscPosCommands.buildJob(raster, options.align, options.feedLines, options.cut, options.openCashDrawer)
+        t.write(job)
+        return job.size
+    }
+
+    override suspend fun printItems(
+        profile: PrinterProfile,
+        items: List<com.delicity.thermalprinter.model.PrintItem>,
+        defaultCodePage: String,
+        cut: Boolean,
+        feedLines: Int,
+    ): Int {
+        val t = connections[profile.id]
+            ?: throw PrinterException(ErrorCode.CONNECTION_FAILED, "rawTcp non connecté")
+        val columns = if (profile.capabilities.printableDots <= 420) 32 else 48
+        val encoded = EscPosTextEncoder.encode(items, defaultCodePage, columns)
+        val out = java.io.ByteArrayOutputStream()
+        out.write(encoded.bytes)
+        if (feedLines > 0) out.write(EscPosCommands.feed(feedLines))
+        if (cut) out.write(EscPosCommands.CUT_PARTIAL)
+        val job = out.toByteArray()
+        t.write(job)
+        return job.size
+    }
+
+    override suspend fun getStatus(profile: PrinterProfile): PrinterStatus {
+        val connected = isConnected(profile.id)
+        return PrinterStatus(
+            id = profile.id,
+            connection = if (connected) "connected" else "disconnected",
+            online = connected,
+            paper = "unknown",
+            rawStatus = "rawTcp: statut non supporté",
+        )
+    }
+}

package/android/src/main/java/com/delicity/thermalprinter/adapters/SdkContract.kt

@@ -0,0 +1,158 @@
+package com.delicity.thermalprinter.adapters
+
+/**
+ * Contrat de réflexion : énumère la **surface exacte** (classes, constructeurs,
+ * méthodes, champs) que chaque adapter SDK appelle par réflexion. Sert à deux choses :
+ *
+ *  1. En CI (faux SDK présent) : un test vérifie que le faux satisfait le contrat
+ *     → garde les faux fidèles à ce que l'adapter attend.
+ *  2. Avec le VRAI SDK (binaire déposé dans l'app) : appeler [verify] confirme que
+ *     l'API réelle correspond à notre réflexion — **sans imprimante**. Tout symbole
+ *     manquant est remonté (au lieu d'échouer silencieusement à l'exécution).
+ *
+ * Usage (dans l'app, après dépôt du binaire) :
+ * ```
+ * val missing = SdkContract.verify(SdkContract.EPSON)
+ * if (missing.isNotEmpty()) Log.e("SDK", "API Epson divergente: $missing")
+ * ```
+ * Voir docs/TESTING_SDK.md.
+ */
+object SdkContract {
+
+    data class Method(val name: String, val params: List<String> = emptyList())
+    data class Requirement(
+        val className: String,
+        val constructors: List<List<String>> = emptyList(),
+        val methods: List<Method> = emptyList(),
+        val fields: List<String> = emptyList(),
+    )
+
+    /** Vérifie une liste de requirements ; renvoie les symboles manquants (vide = OK). */
+    fun verify(requirements: List<Requirement>): List<String> {
+        val missing = mutableListOf<String>()
+        for (r in requirements) {
+            val cls = try {
+                Class.forName(r.className)
+            } catch (e: Throwable) {
+                missing.add("class ${r.className}")
+                continue
+            }
+            for (c in r.constructors) {
+                try {
+                    cls.getConstructor(*c.map(::typeOf).toTypedArray())
+                } catch (e: Throwable) {
+                    missing.add("${r.className}.<init>(${c.joinToString()})")
+                }
+            }
+            for (m in r.methods) {
+                try {
+                    cls.getMethod(m.name, *m.params.map(::typeOf).toTypedArray())
+                } catch (e: Throwable) {
+                    missing.add("${r.className}#${m.name}(${m.params.joinToString()})")
+                }
+            }
+            for (f in r.fields) {
+                try {
+                    cls.getField(f)
+                } catch (e: Throwable) {
+                    missing.add("${r.className}.$f")
+                }
+            }
+        }
+        return missing
+    }
+
+    /** Vérifie toutes les marches dont le SDK est présent (les absentes sont ignorées). */
+    fun verifyAll(): Map<String, List<String>> = buildMap {
+        if (SdkReflect.exists("com.epson.epos2.printer.Printer")) put("epson", verify(EPSON))
+        if (SdkReflect.exists("com.zebra.sdk.comm.Connection")) put("zebra", verify(ZEBRA))
+        if (SdkReflect.exists("com.brother.sdk.lmprinter.PrinterDriverGenerator")) put("brother", verify(BROTHER))
+    }
+
+    private fun typeOf(name: String): Class<*> = when (name) {
+        "int" -> Int::class.javaPrimitiveType!!
+        "long" -> Long::class.javaPrimitiveType!!
+        "double" -> Double::class.javaPrimitiveType!!
+        "float" -> Float::class.javaPrimitiveType!!
+        "boolean" -> Boolean::class.javaPrimitiveType!!
+        else -> Class.forName(name)
+    }
+
+    private const val BITMAP = "android.graphics.Bitmap"
+    private const val CONTEXT = "android.content.Context"
+    private const val BT_ADAPTER = "android.bluetooth.BluetoothAdapter"
+
+    // ------------------------------------------------------------------ Epson
+    val EPSON = listOf(
+        Requirement(
+            "com.epson.epos2.printer.Printer",
+            constructors = listOf(listOf("int", "int", CONTEXT)),
+            methods = listOf(
+                Method("connect", listOf("java.lang.String", "int")),
+                Method("disconnect"),
+                Method("clearCommandBuffer"),
+                Method("beginTransaction"),
+                Method("endTransaction"),
+                Method("addImage", listOf(BITMAP, "int", "int", "int", "int", "int", "int", "int", "double", "int")),
+                Method("addCut", listOf("int")),
+                Method("addPulse", listOf("int", "int")),
+                Method("sendData", listOf("int")),
+                Method("getStatus"),
+                Method("addText", listOf("java.lang.String")),
+                Method("addTextAlign", listOf("int")),
+                Method("addTextStyle", listOf("int", "int", "int", "int")),
+                Method("addTextSize", listOf("int", "int")),
+                Method("addFeedLine", listOf("int")),
+                Method("addSymbol", listOf("java.lang.String", "int", "int", "int", "int", "int")),
+                Method("addBarcode", listOf("java.lang.String", "int", "int", "int", "int", "int")),
+            ),
+            fields = listOf(
+                "TRUE", "FALSE", "MODEL_ANK", "PARAM_DEFAULT", "COLOR_1", "MODE_MONO", "COMPRESS_AUTO",
+                "HALFTONE_DITHER", "HALFTONE_ERROR_DIFFUSION", "HALFTONE_THRESHOLD",
+                "CUT_FEED", "DRAWER_2PIN", "PULSE_100", "PAPER_EMPTY", "PAPER_NEAR_END",
+                "ALIGN_LEFT", "ALIGN_CENTER", "ALIGN_RIGHT", "LEVEL_M", "FONT_A",
+            ),
+        ),
+        Requirement("com.epson.epos2.printer.PrinterStatusInfo", fields = listOf("connection", "online", "paper", "coverOpen")),
+        Requirement(
+            "com.epson.epos2.discovery.Discovery",
+            methods = listOf(
+                Method("start", listOf(CONTEXT, "com.epson.epos2.discovery.FilterOption", "com.epson.epos2.discovery.DiscoveryListener")),
+                Method("stop"),
+            ),
+            fields = listOf("TYPE_PRINTER"),
+        ),
+        Requirement("com.epson.epos2.discovery.FilterOption", constructors = listOf(emptyList()), methods = listOf(Method("setDeviceType", listOf("int")))),
+        Requirement("com.epson.epos2.discovery.DeviceInfo", methods = listOf(Method("getTarget"), Method("getDeviceName"))),
+        Requirement("com.epson.epos2.discovery.DiscoveryListener"),
+    )
+
+    // ------------------------------------------------------------------ Zebra
+    val ZEBRA = listOf(
+        Requirement("com.zebra.sdk.comm.Connection", methods = listOf(Method("open"), Method("close"), Method("isConnected"))),
+        Requirement("com.zebra.sdk.comm.TcpConnection", constructors = listOf(listOf("java.lang.String", "int"))),
+        Requirement("com.zebra.sdk.comm.BluetoothConnection", constructors = listOf(listOf("java.lang.String"))),
+        Requirement("com.zebra.sdk.printer.ZebraPrinterFactory", methods = listOf(Method("getInstance", listOf("com.zebra.sdk.comm.Connection")))),
+        Requirement("com.zebra.sdk.graphics.ZebraImageFactory", methods = listOf(Method("getImage", listOf(BITMAP)))),
+        Requirement("com.zebra.sdk.graphics.ZebraImageI"),
+        Requirement("com.zebra.sdk.printer.discovery.NetworkDiscoverer", methods = listOf(Method("findPrinters", listOf("com.zebra.sdk.printer.discovery.DiscoveryHandler")))),
+        Requirement("com.zebra.sdk.printer.discovery.BluetoothDiscoverer", methods = listOf(Method("findPrinters", listOf(CONTEXT, "com.zebra.sdk.printer.discovery.DiscoveryHandler")))),
+        Requirement("com.zebra.sdk.printer.discovery.DiscoveryHandler"),
+    )
+
+    // ---------------------------------------------------------------- Brother
+    val BROTHER = listOf(
+        Requirement("com.brother.sdk.lmprinter.PrinterDriverGenerator", methods = listOf(Method("openChannel", listOf("com.brother.sdk.lmprinter.Channel")))),
+        Requirement(
+            "com.brother.sdk.lmprinter.Channel",
+            methods = listOf(
+                Method("newWifiChannel", listOf("java.lang.String")),
+                Method("newBluetoothChannel", listOf("java.lang.String", BT_ADAPTER)),
+                Method("newBluetoothLowEnergyChannel", listOf("java.lang.String", CONTEXT, BT_ADAPTER)),
+            ),
+        ),
+        Requirement("com.brother.sdk.lmprinter.PrinterDriver", methods = listOf(Method("printImage", listOf(BITMAP, "com.brother.sdk.lmprinter.setting.PrintImageSettings")), Method("closeChannel"))),
+        Requirement("com.brother.sdk.lmprinter.setting.PrinterModel"),
+        Requirement("com.brother.sdk.lmprinter.setting.PrintImageSettings"),
+    )
+}

package/android/src/main/java/com/delicity/thermalprinter/adapters/SdkReflect.kt

@@ -0,0 +1,104 @@
+package com.delicity.thermalprinter.adapters
+
+import java.lang.reflect.InvocationHandler
+import java.lang.reflect.Method
+import java.lang.reflect.Proxy
+
+/**
+ * Boîte à outils de réflexion pour piloter les SDK fabricants NON redistribuables
+ * (Epson ePOS2, Brother, Zebra Link-OS) SANS dépendance de compilation.
+ *
+ * Pourquoi la réflexion ? Les licences de ces SDK interdisent leur redistribution
+ * (Maven Central / CocoaPods), donc on ne peut pas compiler le plugin contre leurs
+ * types. La réflexion permet :
+ *   - de compiler/publier le plugin SANS les binaires,
+ *   - d'activer automatiquement l'adapter quand l'app fournit le binaire
+ *     (voir docs/SDK_INTEGRATION.md).
+ *
+ * ⚠️ Le code réflexif n'est pas vérifié par le compilateur : toute évolution
+ * d'API du SDK doit être testée sur device avec le binaire réel.
+ */
+object SdkReflect {
+
+    fun classOrNull(name: String): Class<*>? = try {
+        Class.forName(name)
+    } catch (e: Throwable) {
+        null
+    }
+
+    fun exists(name: String): Boolean = classOrNull(name) != null
+
+    /** Instancie une classe via un constructeur dont on donne les types de paramètres. */
+    fun newInstance(className: String, paramTypes: Array<Class<*>>, args: Array<Any?>): Any {
+        val c = classOrNull(className) ?: error("Classe absente: $className")
+        return c.getConstructor(*paramTypes).newInstance(*args)
+    }
+
+    /** Appelle une méthode d'instance. */
+    fun call(target: Any, method: String, paramTypes: Array<Class<*>> = emptyArray(), args: Array<Any?> = emptyArray()): Any? =
+        target.javaClass.getMethod(method, *paramTypes).invoke(target, *args)
+
+    /** Appelle une méthode statique. */
+    fun callStatic(className: String, method: String, paramTypes: Array<Class<*>> = emptyArray(), args: Array<Any?> = emptyArray()): Any? {
+        val c = classOrNull(className) ?: error("Classe absente: $className")
+        return c.getMethod(method, *paramTypes).invoke(null, *args)
+    }
+
+    /** Lit une constante (champ static) — typiquement les `int` du SDK. */
+    fun staticInt(className: String, field: String, fallback: Int = 0): Int = try {
+        classOrNull(className)?.getField(field)?.getInt(null) ?: fallback
+    } catch (e: Throwable) {
+        fallback
+    }
+
+    fun staticField(className: String, field: String): Any? = try {
+        classOrNull(className)?.getField(field)?.get(null)
+    } catch (e: Throwable) {
+        null
+    }
+
+    /** Lit un champ d'instance (public). */
+    fun field(target: Any, name: String): Any? = try {
+        target.javaClass.getField(name).get(target)
+    } catch (e: Throwable) {
+        null
+    }
+
+    fun intField(target: Any, name: String, fallback: Int = 0): Int =
+        (field(target, name) as? Int) ?: fallback
+
+    /** Valeur d'enum par nom. */
+    @Suppress("UNCHECKED_CAST")
+    fun enumValue(enumClass: String, name: String): Any? {
+        val c = classOrNull(enumClass) ?: return null
+        return try {
+            java.lang.Enum.valueOf(c as Class<out Enum<*>>, name)
+        } catch (e: Throwable) {
+            null
+        }
+    }
+
+    /**
+     * Crée un proxy dynamique implémentant une interface listener du SDK.
+     * [handlers] mappe un nom de méthode -> lambda recevant les arguments.
+     */
+    fun proxy(interfaceName: String, handlers: Map<String, (Array<Any?>) -> Any?>): Any {
+        val iface = classOrNull(interfaceName) ?: error("Interface absente: $interfaceName")
+        return Proxy.newProxyInstance(iface.classLoader, arrayOf(iface), object : InvocationHandler {
+            override fun invoke(proxy: Any?, method: Method, args: Array<out Any?>?): Any? {
+                val a = (args ?: emptyArray()).map { it }.toTypedArray()
+                return handlers[method.name]?.invoke(a) ?: defaultFor(method.returnType)
+            }
+        })
+    }
+
+    private fun defaultFor(t: Class<*>): Any? = when (t) {
+        Boolean::class.javaPrimitiveType -> false
+        Int::class.javaPrimitiveType -> 0
+        Long::class.javaPrimitiveType -> 0L
+        Double::class.javaPrimitiveType -> 0.0
+        Float::class.javaPrimitiveType -> 0f
+        Void.TYPE -> null
+        else -> null
+    }
+}