@delicity/capacitor-thermal-printer 7.0.0

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

@@ -0,0 +1,100 @@
+package com.delicity.thermalprinter.model
+
+import org.json.JSONArray
+import org.json.JSONObject
+
+/**
+ * Modèle d'items texte (miroir Kotlin de src/core/text.ts).
+ * Parsé depuis le tableau JSON envoyé par printText([...]).
+ */
+data class TextStyle(
+    val align: String? = null,
+    val bold: Boolean = false,
+    val underline: String = "none",
+    val font: String = "A",
+    val widthMultiplier: Int = 1,
+    val heightMultiplier: Int = 1,
+    val doubleStrike: Boolean = false,
+    val invert: Boolean = false,
+    val upsideDown: Boolean = false,
+    val rotate90: Boolean = false,
+    val letterSpacing: Int? = null,
+    val lineSpacing: Int? = null,
+    val codePage: String? = null,
+    val codePageId: Int? = null,
+    val newline: Boolean = true,
+) {
+    companion object {
+        fun fromJson(o: JSONObject?): TextStyle {
+            if (o == null) return TextStyle()
+            return TextStyle(
+                align = o.optString("align").ifEmpty { null },
+                bold = o.optBoolean("bold", false),
+                underline = o.optString("underline", "none"),
+                font = o.optString("font", "A"),
+                widthMultiplier = o.optInt("widthMultiplier", 1),
+                heightMultiplier = o.optInt("heightMultiplier", 1),
+                doubleStrike = o.optBoolean("doubleStrike", false),
+                invert = o.optBoolean("invert", false),
+                upsideDown = o.optBoolean("upsideDown", false),
+                rotate90 = o.optBoolean("rotate90", false),
+                letterSpacing = if (o.has("letterSpacing")) o.optInt("letterSpacing") else null,
+                lineSpacing = if (o.has("lineSpacing")) o.optInt("lineSpacing") else null,
+                codePage = o.optString("codePage").ifEmpty { null },
+                codePageId = if (o.has("codePageId")) o.optInt("codePageId") else null,
+                newline = o.optBoolean("newline", true),
+            )
+        }
+    }
+}
+
+sealed class PrintItem {
+    data class Text(val value: String, val style: TextStyle) : PrintItem()
+    data class Feed(val lines: Int) : PrintItem()
+    data class Cut(val mode: String, val feedBefore: Int) : PrintItem()
+    data class Divider(val char: String, val columns: Int?, val align: String?, val bold: Boolean) : PrintItem()
+    data class QrCode(val value: String, val size: Int, val ec: String, val align: String) : PrintItem()
+    data class Barcode(
+        val value: String, val symbology: String, val height: Int, val width: Int, val hri: String, val align: String,
+    ) : PrintItem()
+    data class CashDrawer(val pin: Int) : PrintItem()
+    data class Image(val filePath: String?, val url: String?, val base64: String?, val render: JSONObject?) : PrintItem()
+    data class Raw(val bytesBase64: String) : PrintItem()
+
+    companion object {
+        fun parseList(arr: JSONArray): List<PrintItem> =
+            (0 until arr.length()).mapNotNull { parse(arr.optJSONObject(it)) }
+
+        private fun parse(o: JSONObject?): PrintItem? {
+            if (o == null) return null
+            return when (o.optString("type")) {
+                "text" -> Text(o.optString("value"), TextStyle.fromJson(o.optJSONObject("style")))
+                "feed" -> Feed(o.optInt("lines", 1))
+                "cut" -> Cut(o.optString("mode", "partial"), o.optInt("feedBefore", 0))
+                "divider" -> Divider(
+                    o.optString("char", "-"),
+                    if (o.has("columns")) o.optInt("columns") else null,
+                    o.optJSONObject("style")?.optString("align")?.ifEmpty { null },
+                    o.optJSONObject("style")?.optBoolean("bold", false) ?: false,
+                )
+                "qrcode" -> QrCode(o.optString("value"), o.optInt("size", 6), o.optString("errorCorrection", "M"), o.optString("align", "center"))
+                "barcode" -> Barcode(
+                    o.optString("value"), o.optString("symbology", "CODE128"),
+                    o.optInt("height", 80), o.optInt("width", 3),
+                    o.optString("hri", "below"), o.optString("align", "center"),
+                )
+                "cashDrawer" -> CashDrawer(o.optInt("pin", 2))
+                "image" -> o.optJSONObject("image").let { img ->
+                    Image(
+                        img?.optString("filePath")?.ifEmpty { null },
+                        img?.optString("url")?.ifEmpty { null },
+                        img?.optString("base64")?.ifEmpty { null },
+                        o.optJSONObject("render"),
+                    )
+                }
+                "raw" -> Raw(o.optString("bytesBase64"))
+                else -> null
+            }
+        }
+    }
+}

package/android/src/main/java/com/delicity/thermalprinter/store/PrinterStore.kt

@@ -0,0 +1,71 @@
+package com.delicity.thermalprinter.store
+
+import android.content.Context
+import android.content.SharedPreferences
+import com.delicity.thermalprinter.model.PrinterProfile
+import org.json.JSONArray
+import org.json.JSONObject
+
+/**
+ * Persistance des profils d'imprimantes (SharedPreferences + JSON).
+ *
+ * Conçu pour la reconnexion automatique : tout le nécessaire pour rejoindre une
+ * imprimante sans re-découverte est stocké dans le PrinterProfile.
+ *
+ * NB : les profils ne contiennent pas de secret. Si un jour des credentials
+ * réseau sont stockés, migrer vers EncryptedSharedPreferences.
+ */
+class PrinterStore(context: Context) {
+
+    private val prefs: SharedPreferences =
+        context.getSharedPreferences("delicity.thermalprinter", Context.MODE_PRIVATE)
+
+    @Synchronized
+    fun all(): List<PrinterProfile> {
+        val raw = prefs.getString(KEY_PROFILES, "[]") ?: "[]"
+        val arr = JSONArray(raw)
+        return (0 until arr.length()).map { PrinterProfile.fromJson(arr.getJSONObject(it)) }
+    }
+
+    fun get(id: String): PrinterProfile? = all().firstOrNull { it.id == id }
+
+    fun getDefault(): PrinterProfile? = all().firstOrNull { it.isDefault }
+
+    @Synchronized
+    fun upsert(profile: PrinterProfile) {
+        val list = all().toMutableList()
+        val idx = list.indexOfFirst { it.id == profile.id }
+        profile.updatedAt = System.currentTimeMillis()
+        if (idx >= 0) list[idx] = profile else list.add(profile)
+        persist(list)
+    }
+
+    @Synchronized
+    fun setDefault(id: String): PrinterProfile? {
+        val list = all().toMutableList()
+        var target: PrinterProfile? = null
+        list.forEach {
+            it.isDefault = it.id == id
+            if (it.isDefault) target = it
+        }
+        persist(list)
+        return target
+    }
+
+    @Synchronized
+    fun remove(id: String) {
+        persist(all().filterNot { it.id == id })
+    }
+
+    private fun persist(list: List<PrinterProfile>) {
+        val arr = JSONArray()
+        list.forEach { arr.put(it.toJson()) }
+        prefs.edit().putString(KEY_PROFILES, arr.toString()).apply()
+    }
+
+    companion object {
+        private const val KEY_PROFILES = "profiles_v1"
+
+        fun emptyJson(): JSONObject = JSONObject()
+    }
+}

package/android/src/main/java/com/delicity/thermalprinter/transport/BleGattClient.kt

@@ -0,0 +1,201 @@
+package com.delicity.thermalprinter.transport
+
+import android.annotation.SuppressLint
+import android.bluetooth.BluetoothDevice
+import android.bluetooth.BluetoothGatt
+import android.bluetooth.BluetoothGattCallback
+import android.bluetooth.BluetoothGattCharacteristic
+import android.bluetooth.BluetoothProfile
+import android.content.Context
+import android.os.Build
+import com.delicity.thermalprinter.model.ErrorCode
+import com.delicity.thermalprinter.model.PrinterException
+import java.util.UUID
+import java.util.concurrent.atomic.AtomicReference
+import kotlin.coroutines.Continuation
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.withTimeout
+
+/**
+ * Client GATT BLE suspend pour imprimantes ESC/POS exposant une "UART série" BLE.
+ *
+ * Flux : connectGatt -> (MTU) -> discoverServices -> localiser la characteristic
+ * d'écriture (allowlist d'UUID connus, sinon 1re characteristic WRITE/WRITE_NO_RESPONSE)
+ * -> écriture du raster ESC/POS par paquets <= (MTU-3).
+ *
+ * ⚠️ Il n'existe pas de profil BLE standard d'impression : on s'appuie sur une
+ * allowlist de services/characteristics validés (cf. [WRITE_TARGETS]). Pour un
+ * modèle non listé, on tente la 1re characteristic inscriptible trouvée.
+ */
+@SuppressLint("MissingPermission")
+class BleGattClient(
+    private val context: Context,
+    private val device: BluetoothDevice,
+) {
+    private var gatt: BluetoothGatt? = null
+    private var writeChar: BluetoothGattCharacteristic? = null
+    @Volatile private var mtu: Int = 23
+    @Volatile var isOpen: Boolean = false
+        private set
+
+    // Continuations one-shot par opération (le GATT sérialise les callbacks).
+    private val connectCont = AtomicReference<Continuation<Unit>?>()
+    private val mtuCont = AtomicReference<Continuation<Unit>?>()
+    private val servicesCont = AtomicReference<Continuation<Unit>?>()
+    private val writeCont = AtomicReference<Continuation<Unit>?>()
+
+    private val callback = object : BluetoothGattCallback() {
+        override fun onConnectionStateChange(g: BluetoothGatt, status: Int, newState: Int) {
+            if (newState == BluetoothProfile.STATE_CONNECTED && status == BluetoothGatt.GATT_SUCCESS) {
+                connectCont.getAndSet(null)?.resume(Unit)
+            } else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
+                isOpen = false
+                val e = PrinterException(ErrorCode.CONNECTION_FAILED, "BLE déconnecté (status=$status)", retryable = true)
+                connectCont.getAndSet(null)?.resumeWithException(e)
+                writeCont.getAndSet(null)?.resumeWithException(e)
+            }
+        }
+
+        override fun onMtuChanged(g: BluetoothGatt, newMtu: Int, status: Int) {
+            mtu = if (status == BluetoothGatt.GATT_SUCCESS) newMtu else mtu
+            mtuCont.getAndSet(null)?.resume(Unit)
+        }
+
+        override fun onServicesDiscovered(g: BluetoothGatt, status: Int) {
+            servicesCont.getAndSet(null)?.let { cont ->
+                if (status == BluetoothGatt.GATT_SUCCESS) cont.resume(Unit)
+                else cont.resumeWithException(PrinterException(ErrorCode.CONNECTION_FAILED, "discoverServices BLE échoué"))
+            }
+        }
+
+        @Deprecated("Deprecated in Java")
+        override fun onCharacteristicWrite(g: BluetoothGatt, c: BluetoothGattCharacteristic, status: Int) {
+            writeCont.getAndSet(null)?.let { cont ->
+                if (status == BluetoothGatt.GATT_SUCCESS) cont.resume(Unit)
+                else cont.resumeWithException(PrinterException(ErrorCode.PRINT_FAILED, "Écriture BLE échouée (status=$status)", retryable = true))
+            }
+        }
+    }
+
+    suspend fun open(timeoutMs: Long) {
+        withTimeout(timeoutMs.coerceAtLeast(3000)) {
+            suspendCancellableCoroutine<Unit> { cont ->
+                connectCont.set(cont)
+                cont.invokeOnCancellation { runCatching { gatt?.close() } }
+                gatt = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                    device.connectGatt(context, false, callback, BluetoothDevice.TRANSPORT_LE)
+                } else {
+                    device.connectGatt(context, false, callback)
+                }
+            }
+            // MTU max (512) pour réduire le nombre de paquets ; best effort.
+            runCatching {
+                suspendCancellableCoroutine<Unit> { cont ->
+                    mtuCont.set(cont)
+                    if (gatt?.requestMtu(512) != true) mtuCont.getAndSet(null)?.resume(Unit)
+                }
+            }
+            suspendCancellableCoroutine<Unit> { cont ->
+                servicesCont.set(cont)
+                if (gatt?.discoverServices() != true) {
+                    servicesCont.getAndSet(null)?.resumeWithException(
+                        PrinterException(ErrorCode.CONNECTION_FAILED, "discoverServices BLE non démarré"),
+                    )
+                }
+            }
+            writeChar = locateWriteCharacteristic()
+                ?: throw PrinterException(ErrorCode.UNSUPPORTED_PRINTER, "Aucune characteristic BLE inscriptible (allowlist UUID requise)")
+            isOpen = true
+        }
+    }
+
+    /** Écrit [data] par paquets <= (MTU-3), en attendant l'ACK entre chaque paquet. */
+    suspend fun write(data: ByteArray) {
+        val g = gatt ?: throw PrinterException(ErrorCode.CONNECTION_FAILED, "GATT non ouvert")
+        val ch = writeChar ?: throw PrinterException(ErrorCode.CONNECTION_FAILED, "Characteristic d'écriture absente")
+        val packet = (mtu - 3).coerceIn(20, 512)
+        val noResponse = (ch.properties and BluetoothGattCharacteristic.PROPERTY_WRITE) == 0
+        val writeType = if (noResponse) {
+            BluetoothGattCharacteristic.WRITE_TYPE_NO_RESPONSE
+        } else {
+            BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT
+        }
+        var offset = 0
+        while (offset < data.size) {
+            val len = minOf(packet, data.size - offset)
+            val slice = data.copyOfRange(offset, offset + len)
+            suspendCancellableCoroutine<Unit> { cont ->
+                writeCont.set(cont)
+                val ok = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                    g.writeCharacteristic(ch, slice, writeType) == BluetoothGatt.GATT_SUCCESS
+                } else {
+                    @Suppress("DEPRECATION")
+                    run {
+                        ch.writeType = writeType
+                        ch.value = slice
+                        g.writeCharacteristic(ch)
+                    }
+                }
+                if (!ok) writeCont.getAndSet(null)?.resumeWithException(
+                    PrinterException(ErrorCode.PRINT_FAILED, "writeCharacteristic BLE refusé", retryable = true),
+                )
+            }
+            offset += len
+        }
+    }
+
+    fun close() {
+        isOpen = false
+        runCatching { gatt?.disconnect() }
+        runCatching { gatt?.close() }
+        gatt = null
+        writeChar = null
+    }
+
+    private fun locateWriteCharacteristic(): BluetoothGattCharacteristic? {
+        val g = gatt ?: return null
+        // 1) Allowlist : services/characteristics connus.
+        for ((svc, chr) in WRITE_TARGETS) {
+            g.getService(svc)?.getCharacteristic(chr)?.let { return it }
+        }
+        // 2) Fallback : 1re characteristic inscriptible trouvée.
+        for (service in g.services) {
+            for (c in service.characteristics) {
+                val p = c.properties
+                if ((p and BluetoothGattCharacteristic.PROPERTY_WRITE) != 0 ||
+                    (p and BluetoothGattCharacteristic.PROPERTY_WRITE_NO_RESPONSE) != 0
+                ) {
+                    return c
+                }
+            }
+        }
+        return null
+    }
+
+    companion object {
+        private fun u(s: String) = UUID.fromString(s)
+
+        /**
+         * Allowlist (service -> characteristic d'écriture) des "UART série" BLE
+         * couramment exposées par les imprimantes thermiques. À enrichir au fil des
+         * modèles validés.
+         */
+        val WRITE_TARGETS: List<Pair<UUID, UUID>> = listOf(
+            // Nordic UART Service (NUS)
+            u("6e400001-b5a3-f393-e0a9-e50e24dcca9e") to u("6e400002-b5a3-f393-e0a9-e50e24dcca9e"),
+            // Microchip / ISSC Transparent UART
+            u("49535343-fe7d-4ae5-8fa9-9fafd205e455") to u("49535343-8841-43f4-a8d4-ecbe34729bb3"),
+            // Générique "FFE0/FFE1" (modules HM-10 et clones)
+            u("0000ffe0-0000-1000-8000-00805f9b34fb") to u("0000ffe1-0000-1000-8000-00805f9b34fb"),
+            // Générique "FF00/FF02"
+            u("0000ff00-0000-1000-8000-00805f9b34fb") to u("0000ff02-0000-1000-8000-00805f9b34fb"),
+            // Imprimantes type "18F0/2AF1"
+            u("000018f0-0000-1000-8000-00805f9b34fb") to u("00002af1-0000-1000-8000-00805f9b34fb"),
+        )
+
+        /** Services BLE à mettre en avant lors du scan (filtre de découverte). */
+        val ADVERTISED_SERVICES: List<UUID> = WRITE_TARGETS.map { it.first }
+    }
+}

package/android/src/main/java/com/delicity/thermalprinter/transport/BluetoothSppTransport.kt

@@ -0,0 +1,110 @@
+package com.delicity.thermalprinter.transport
+
+import android.annotation.SuppressLint
+import android.bluetooth.BluetoothAdapter
+import android.bluetooth.BluetoothDevice
+import android.bluetooth.BluetoothSocket
+import com.delicity.thermalprinter.model.ErrorCode
+import com.delicity.thermalprinter.model.PrinterException
+import java.io.InputStream
+import java.io.OutputStream
+import java.util.UUID
+
+/**
+ * Transport Bluetooth Classic / SPP (Serial Port Profile).
+ *
+ * ⚠️ ANDROID UNIQUEMENT. iOS n'expose pas le SPP générique (voir limites README).
+ *
+ * Le SPP est le canal des imprimantes ESC/POS Bluetooth "génériques" très répandues
+ * en restauration (modèles chinois à bas coût). UUID SPP standard :
+ *   00001101-0000-1000-8000-00805F9B34FB
+ *
+ * Requiert BLUETOOTH_CONNECT (API 31+) accordée AVANT l'appel.
+ */
+@SuppressLint("MissingPermission")
+class BluetoothSppTransport(
+    private val adapter: BluetoothAdapter?,
+    private val macAddress: String,
+) : ByteTransport {
+
+    private var socket: BluetoothSocket? = null
+    private var out: OutputStream? = null
+    private var input: InputStream? = null
+
+    override val isOpen: Boolean
+        get() = socket?.isConnected == true
+
+    override fun open(timeoutMs: Long) {
+        if (isOpen) return
+        val ad = adapter ?: throw PrinterException(ErrorCode.BLUETOOTH_DISABLED, "Bluetooth indisponible")
+        if (!ad.isEnabled) throw PrinterException(ErrorCode.BLUETOOTH_DISABLED, "Bluetooth désactivé")
+
+        val device: BluetoothDevice = try {
+            ad.getRemoteDevice(macAddress)
+        } catch (e: IllegalArgumentException) {
+            throw PrinterException(ErrorCode.PRINTER_NOT_FOUND, "MAC invalide: $macAddress", e.message)
+        }
+
+        // Si non appairé, l'app doit déclencher l'appairage en amont.
+        if (device.bondState != BluetoothDevice.BOND_BONDED) {
+            throw PrinterException(ErrorCode.PAIRING_REQUIRED, "Appareil non appairé: $macAddress", retryable = false)
+        }
+
+        try {
+            ad.cancelDiscovery() // la découverte ralentit/échoue la connexion
+            val sock = device.createRfcommSocketToServiceRecord(SPP_UUID)
+            sock.connect() // bloquant ; pas de vrai timeout natif -> orchestré par coroutine
+            socket = sock
+            out = sock.outputStream
+            input = sock.inputStream
+        } catch (e: SecurityException) {
+            throw PrinterException(ErrorCode.PERMISSION_DENIED, "Permission BLUETOOTH_CONNECT manquante", e.message)
+        } catch (e: Exception) {
+            // Fallback "insecure" pour certaines imprimantes capricieuses.
+            try {
+                val sock = device.createInsecureRfcommSocketToServiceRecord(SPP_UUID)
+                sock.connect()
+                socket = sock
+                out = sock.outputStream
+                input = sock.inputStream
+            } catch (e2: Exception) {
+                throw PrinterException(ErrorCode.CONNECTION_FAILED, "Connexion SPP échouée $macAddress", e2.message, retryable = true)
+            }
+        }
+    }
+
+    override fun write(bytes: ByteArray) {
+        val o = out ?: throw PrinterException(ErrorCode.CONNECTION_FAILED, "Socket SPP non ouvert")
+        try {
+            var offset = 0
+            val chunk = 2048 // les buffers SPP sont petits
+            while (offset < bytes.size) {
+                val len = minOf(chunk, bytes.size - offset)
+                o.write(bytes, offset, len)
+                o.flush()
+                offset += len
+                // micro-pause anti-overflow sur imprimantes lentes
+                if (bytes.size > 16_384) Thread.sleep(8)
+            }
+        } catch (e: Exception) {
+            throw PrinterException(ErrorCode.PRINT_FAILED, "Écriture SPP échouée", e.message, retryable = true)
+        }
+    }
+
+    override fun read(buffer: ByteArray, timeoutMs: Long): Int {
+        val i = input ?: return -1
+        return try { i.read(buffer) } catch (e: Exception) { -1 }
+    }
+
+    override fun close() {
+        try { out?.flush() } catch (_: Exception) {}
+        try { input?.close() } catch (_: Exception) {}
+        try { out?.close() } catch (_: Exception) {}
+        try { socket?.close() } catch (_: Exception) {}
+        socket = null; out = null; input = null
+    }
+
+    companion object {
+        val SPP_UUID: UUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB")
+    }
+}

package/android/src/main/java/com/delicity/thermalprinter/transport/ByteTransport.kt

@@ -0,0 +1,18 @@
+package com.delicity.thermalprinter.transport
+
+/**
+ * Canal d'octets bas niveau vers une imprimante (TCP, SPP, BLE).
+ * Les adapters ESC/POS écrivent des commandes brutes via ce contrat.
+ */
+interface ByteTransport {
+    val isOpen: Boolean
+    fun open(timeoutMs: Long)
+    fun write(bytes: ByteArray)
+
+    /**
+     * Lecture optionnelle (statut temps réel ESC/POS DLE EOT).
+     * Retourne le nombre d'octets lus, ou -1 si non supporté/aucune donnée.
+     */
+    fun read(buffer: ByteArray, timeoutMs: Long): Int = -1
+    fun close()
+}

package/android/src/main/java/com/delicity/thermalprinter/transport/TcpTransport.kt

@@ -0,0 +1,83 @@
+package com.delicity.thermalprinter.transport
+
+import com.delicity.thermalprinter.model.ErrorCode
+import com.delicity.thermalprinter.model.PrinterException
+import java.io.InputStream
+import java.io.OutputStream
+import java.net.InetSocketAddress
+import java.net.Socket
+import java.net.SocketTimeoutException
+
+/**
+ * Transport TCP brut (RAW / port 9100). Utilisé par EscPosAdapter et RawTcpAdapter
+ * en Wi-Fi/Ethernet.
+ *
+ * @param host adresse IP/hostname
+ * @param port port (défaut 9100)
+ */
+class TcpTransport(
+    private val host: String,
+    private val port: Int = 9100,
+) : ByteTransport {
+
+    private var socket: Socket? = null
+    private var out: OutputStream? = null
+    private var input: InputStream? = null
+
+    override val isOpen: Boolean
+        get() = socket?.isConnected == true && socket?.isClosed == false
+
+    override fun open(timeoutMs: Long) {
+        if (isOpen) return
+        try {
+            val s = Socket()
+            s.tcpNoDelay = true
+            s.connect(InetSocketAddress(host, port), timeoutMs.toInt())
+            s.soTimeout = timeoutMs.toInt()
+            socket = s
+            out = s.getOutputStream()
+            input = s.getInputStream()
+        } catch (e: SocketTimeoutException) {
+            throw PrinterException(ErrorCode.TIMEOUT, "Timeout connexion TCP $host:$port", e.message, retryable = true)
+        } catch (e: Exception) {
+            throw PrinterException(ErrorCode.CONNECTION_FAILED, "Connexion TCP échouée $host:$port", e.message, retryable = true)
+        }
+    }
+
+    override fun write(bytes: ByteArray) {
+        val o = out ?: throw PrinterException(ErrorCode.CONNECTION_FAILED, "Socket TCP non ouvert")
+        try {
+            // Envoi par chunks pour ménager les petits buffers d'imprimante.
+            var offset = 0
+            val chunk = 4096
+            while (offset < bytes.size) {
+                val len = minOf(chunk, bytes.size - offset)
+                o.write(bytes, offset, len)
+                o.flush()
+                offset += len
+            }
+        } catch (e: Exception) {
+            throw PrinterException(ErrorCode.PRINT_FAILED, "Écriture TCP échouée", e.message, retryable = true)
+        }
+    }
+
+    override fun read(buffer: ByteArray, timeoutMs: Long): Int {
+        val i = input ?: return -1
+        return try {
+            socket?.soTimeout = timeoutMs.toInt()
+            i.read(buffer)
+        } catch (e: SocketTimeoutException) {
+            -1
+        } catch (e: Exception) {
+            -1
+        }
+    }
+
+    override fun close() {
+        try { out?.flush() } catch (_: Exception) {}
+        try { input?.close() } catch (_: Exception) {}
+        try { out?.close() } catch (_: Exception) {}
+        try { socket?.close() } catch (_: Exception) {}
+        socket = null; out = null; input = null
+    }
+}

package/dist/esm/adapters/dedup.d.ts

@@ -0,0 +1,26 @@
+import type { PrinterTransport } from '../core/enums';
+import type { DiscoveredPrinter } from '../core/models';
+/**
+ * Construit un identifiant interne stable pour une imprimante.
+ *
+ * On veut le MÊME id quelle que soit la source de découverte afin de fusionner
+ * les doublons (ex: une TM-m30 vue à la fois par le SDK Epson et par le scan TCP).
+ *
+ * Clé de stabilité par transport :
+ *  - réseau (wifi/ethernet) : adresse IP normalisée (sans port) — l'imprimante a
+ *    une seule IP même si plusieurs ports répondent.
+ *  - bluetooth/ble          : adresse MAC (Android) ou UUID périphérique (iOS).
+ *  - usb                    : vendorId:productId.
+ *
+ * Le préfixe transport évite les collisions improbables entre familles.
+ */
+export declare function buildStableId(transport: PrinterTransport, rawAddress: string): string;
+/**
+ * Fusionne une liste de découvertes brutes en une liste dédoublonnée.
+ * En cas de doublon (même id), on conserve l'entrée au meilleur adapter
+ * (déjà résolu par `resolveBestAdapter`) et on fusionne `discoveredBy`.
+ *
+ * @param incoming découvertes brutes (chaque source peut produire des doublons)
+ * @param adapterRank fonction de classement (score) déjà appliquée au champ adapter
+ */
+export declare function mergeDiscoveries(incoming: DiscoveredPrinter[], adapterRank: (p: DiscoveredPrinter) => number): DiscoveredPrinter[];

package/dist/esm/adapters/dedup.js

@@ -0,0 +1,66 @@
+/**
+ * Construit un identifiant interne stable pour une imprimante.
+ *
+ * On veut le MÊME id quelle que soit la source de découverte afin de fusionner
+ * les doublons (ex: une TM-m30 vue à la fois par le SDK Epson et par le scan TCP).
+ *
+ * Clé de stabilité par transport :
+ *  - réseau (wifi/ethernet) : adresse IP normalisée (sans port) — l'imprimante a
+ *    une seule IP même si plusieurs ports répondent.
+ *  - bluetooth/ble          : adresse MAC (Android) ou UUID périphérique (iOS).
+ *  - usb                    : vendorId:productId.
+ *
+ * Le préfixe transport évite les collisions improbables entre familles.
+ */
+export function buildStableId(transport, rawAddress) {
+    const norm = normalizeAddress(transport, rawAddress);
+    return `${transport}:${norm}`;
+}
+function normalizeAddress(transport, address) {
+    switch (transport) {
+        case 'wifi':
+        case 'ethernet':
+            // retire un éventuel :port
+            return address.replace(/:\d+$/, '').trim().toLowerCase();
+        case 'bluetooth':
+        case 'ble':
+            return address.trim().toUpperCase();
+        case 'usb':
+            return address.trim().toLowerCase();
+        default:
+            return address.trim().toLowerCase();
+    }
+}
+/**
+ * Fusionne une liste de découvertes brutes en une liste dédoublonnée.
+ * En cas de doublon (même id), on conserve l'entrée au meilleur adapter
+ * (déjà résolu par `resolveBestAdapter`) et on fusionne `discoveredBy`.
+ *
+ * @param incoming découvertes brutes (chaque source peut produire des doublons)
+ * @param adapterRank fonction de classement (score) déjà appliquée au champ adapter
+ */
+export function mergeDiscoveries(incoming, adapterRank) {
+    var _a, _b;
+    const byId = new Map();
+    for (const printer of incoming) {
+        const existing = byId.get(printer.id);
+        if (!existing) {
+            byId.set(printer.id, Object.assign(Object.assign({}, printer), { discoveredBy: dedupeSources(printer) }));
+            continue;
+        }
+        // Fusionner les sources de découverte.
+        const mergedSources = Array.from(new Set([...((_a = existing.discoveredBy) !== null && _a !== void 0 ? _a : []), ...((_b = printer.discoveredBy) !== null && _b !== void 0 ? _b : []), printer.adapter, existing.adapter]));
+        // Garder l'entrée au meilleur adapter.
+        const winner = adapterRank(printer) > adapterRank(existing) ? printer : existing;
+        byId.set(printer.id, Object.assign(Object.assign({}, winner), { 
+            // capacités: union (on garde le plus d'infos possible)
+            capabilities: Object.assign(Object.assign(Object.assign({}, existing.capabilities), printer.capabilities), winner.capabilities), lastSeenAt: Math.max(existing.lastSeenAt, printer.lastSeenAt), discoveredBy: mergedSources, isDefault: existing.isDefault || printer.isDefault, isConnected: existing.isConnected || printer.isConnected }));
+    }
+    return Array.from(byId.values());
+}
+function dedupeSources(p) {
+    var _a;
+    const base = (_a = p.discoveredBy) !== null && _a !== void 0 ? _a : [];
+    return Array.from(new Set([...base, p.adapter]));
+}
+//# sourceMappingURL=dedup.js.map