@delicity/capacitor-thermal-printer 7.0.0

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

@@ -0,0 +1,207 @@
+package com.delicity.thermalprinter.adapters
+
+import android.content.Context
+import android.graphics.Bitmap
+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 java.util.concurrent.ConcurrentHashMap
+
+/**
+ * Adapter Zebra basé sur le SDK Link-OS (`com.zebra.sdk`), piloté par RÉFLEXION.
+ *
+ * ⚠️ Zebra N'EST PAS de l'ESC/POS : le langage est ZPL/CPCL. Le SDK convertit le
+ * Bitmap en ZPL et l'imprime via GraphicsUtil.printImage(...). On ne route JAMAIS
+ * une Zebra vers EscPosAdapter (priority.ts attribue un score négatif).
+ *
+ * Le SDK Link-OS n'est pas redistribuable (licence Zebra) : déposer
+ * `ZSDK_ANDROID_API.jar` (portail Zebra) — ou activer le dépôt Maven privé Zebra
+ * (credentials). Voir docs/SDK_INTEGRATION.md (§ Zebra).
+ */
+class ZebraAdapter(private val context: Context) : PrinterAdapter {
+
+    override val id = AdapterId.ZEBRA
+
+    private val cache = ConcurrentHashMap<String, Any>() // printerId -> com.zebra.sdk.comm.Connection
+
+    override fun isAvailable(): Boolean = EpsonAdapter.classExists(CONNECTION)
+
+    // -------------------------------------------------------------------------
+    // Découverte (NetworkDiscoverer / BluetoothDiscoverer + DiscoveryHandler proxy)
+    // -------------------------------------------------------------------------
+
+    override suspend fun discover(timeoutMs: Long, onFound: (DiscoveredPrinter) -> Unit) {
+        if (!isAvailable()) return
+        val handler = SdkReflect.proxy(DISCOVERY_HANDLER, mapOf(
+            "foundPrinter" to { args ->
+                val dp = args.getOrNull(0)
+                if (dp != null) {
+                    val address = SdkReflect.call(dp, "getAddress") as? String
+                        ?: SdkReflect.field(dp, "address") as? String ?: ""
+                    if (address.isNotEmpty()) {
+                        onFound(
+                            DiscoveredPrinter(
+                                id = "zebra:$address",
+                                name = "Zebra $address",
+                                brand = "Zebra",
+                                transport = if (address.matches(Regex("([0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}"))) Transport.BLUETOOTH else Transport.WIFI,
+                                adapter = AdapterId.ZEBRA,
+                                address = address,
+                                discoveredBy = mutableSetOf(AdapterId.ZEBRA),
+                            ),
+                        )
+                    }
+                }
+                null
+            },
+            "discoveryFinished" to { null },
+            "discoveryError" to { null },
+        ))
+        // NetworkDiscoverer.findPrinters(DiscoveryHandler) — bloquant jusqu'à fin.
+        runCatching {
+            SdkReflect.callStatic(
+                NETWORK_DISCOVERER, "findPrinters",
+                arrayOf(SdkReflect.classOrNull(DISCOVERY_HANDLER)!!),
+                arrayOf(handler),
+            )
+        }
+        // BluetoothDiscoverer.findPrinters(Context, DiscoveryHandler)
+        runCatching {
+            SdkReflect.callStatic(
+                BLUETOOTH_DISCOVERER, "findPrinters",
+                arrayOf(Context::class.java, SdkReflect.classOrNull(DISCOVERY_HANDLER)!!),
+                arrayOf(context, handler),
+            )
+        }
+    }
+
+    override fun canHandle(profile: PrinterProfile): Boolean =
+        isAvailable() && profile.adapter == AdapterId.ZEBRA
+
+    // -------------------------------------------------------------------------
+    // Connexion
+    // -------------------------------------------------------------------------
+
+    override suspend fun connect(profile: PrinterProfile, timeoutMs: Long) {
+        ensureSdk()
+        if (isConnected(profile.id)) return
+        val connection = buildConnection(profile)
+        try {
+            SdkReflect.call(connection, "open")
+        } catch (e: Throwable) {
+            throw PrinterException(ErrorCode.CONNECTION_FAILED, "Connexion Zebra échouée: ${profile.address}", e.message, retryable = true)
+        }
+        cache[profile.id] = connection
+    }
+
+    override fun isConnected(printerId: String): Boolean {
+        val c = cache[printerId] ?: return false
+        return (SdkReflect.call(c, "isConnected") as? Boolean) ?: true
+    }
+
+    override suspend fun disconnect(printerId: String) {
+        cache.remove(printerId)?.let { runCatching { SdkReflect.call(it, "close") } }
+    }
+
+    // -------------------------------------------------------------------------
+    // Impression image (-> ZPL via GraphicsUtil)
+    // -------------------------------------------------------------------------
+
+    override suspend fun printBitmap(profile: PrinterProfile, bitmap: Bitmap, options: RenderOptions): Int {
+        val connection = cache[profile.id]
+            ?: throw PrinterException(ErrorCode.CONNECTION_FAILED, "Zebra non connecté: ${profile.id}")
+        try {
+            val printer = SdkReflect.callStatic(
+                PRINTER_FACTORY, "getInstance",
+                arrayOf(SdkReflect.classOrNull(CONNECTION)!!), arrayOf(connection),
+            ) ?: error("ZebraPrinterFactory.getInstance null")
+            val graphics = SdkReflect.call(printer, "getGraphicsUtil") ?: error("getGraphicsUtil null")
+            val zebraImage = SdkReflect.callStatic(
+                IMAGE_FACTORY, "getImage",
+                arrayOf(Bitmap::class.java), arrayOf(bitmap),
+            ) ?: error("ZebraImageFactory.getImage null")
+            val intT = Int::class.javaPrimitiveType!!
+            val boolT = Boolean::class.javaPrimitiveType!!
+            repeat(options.copies.coerceAtLeast(1)) {
+                SdkReflect.call(
+                    graphics, "printImage",
+                    arrayOf(SdkReflect.classOrNull(IMAGE_I)!!, intT, intT, intT, intT, boolT),
+                    arrayOf(zebraImage, 0, 0, bitmap.width, bitmap.height, false),
+                )
+            }
+        } catch (e: Throwable) {
+            throw PrinterException(ErrorCode.PRINT_FAILED, "Impression Zebra échouée", e.message, retryable = true)
+        }
+        return bitmap.width * bitmap.height / 8
+    }
+
+    // -------------------------------------------------------------------------
+    // Statut
+    // -------------------------------------------------------------------------
+
+    override suspend fun getStatus(profile: PrinterProfile): PrinterStatus {
+        val connection = cache[profile.id]
+            ?: return PrinterStatus(profile.id, "disconnected", online = false, paper = "unknown")
+        return try {
+            val printer = SdkReflect.callStatic(
+                PRINTER_FACTORY, "getInstance",
+                arrayOf(SdkReflect.classOrNull(CONNECTION)!!), arrayOf(connection),
+            ) ?: error("getInstance null")
+            val status = SdkReflect.call(printer, "getCurrentStatus") ?: error("getCurrentStatus null")
+            val ready = (SdkReflect.field(status, "isReadyToPrint") as? Boolean) ?: false
+            val paperOut = (SdkReflect.field(status, "isPaperOut") as? Boolean) ?: false
+            val headOpen = (SdkReflect.field(status, "isHeadOpen") as? Boolean) ?: false
+            PrinterStatus(
+                id = profile.id,
+                connection = "connected",
+                online = ready,
+                paper = if (paperOut) "empty" else "ok",
+                coverOpen = headOpen,
+                errorCode = if (paperOut) ErrorCode.PAPER_EMPTY else if (headOpen) ErrorCode.COVER_OPEN else null,
+            )
+        } catch (e: Throwable) {
+            PrinterStatus(profile.id, "error", online = false, paper = "unknown", rawStatus = e.message)
+        }
+    }
+
+    // -------------------------------------------------------------------------
+    // Helpers
+    // -------------------------------------------------------------------------
+
+    private fun buildConnection(profile: PrinterProfile): Any = when (profile.transport) {
+        Transport.WIFI, Transport.ETHERNET -> {
+            val host = profile.address.substringBefore(":")
+            val port = profile.address.substringAfter(":", "9100").toIntOrNull() ?: 9100
+            SdkReflect.newInstance(
+                TCP_CONNECTION,
+                arrayOf(String::class.java, Int::class.javaPrimitiveType!!),
+                arrayOf(host, port),
+            )
+        }
+        Transport.BLUETOOTH -> SdkReflect.newInstance(
+            BT_CONNECTION, arrayOf(String::class.java), arrayOf(profile.address),
+        )
+        else -> throw PrinterException(ErrorCode.UNSUPPORTED_TRANSPORT, "Transport Zebra non supporté: ${profile.transport.value}")
+    }
+
+    private fun ensureSdk() {
+        if (!isAvailable()) throw PrinterException(ErrorCode.SDK_NOT_AVAILABLE, "SDK Zebra Link-OS absent")
+    }
+
+    companion object {
+        private const val CONNECTION = "com.zebra.sdk.comm.Connection"
+        private const val TCP_CONNECTION = "com.zebra.sdk.comm.TcpConnection"
+        private const val BT_CONNECTION = "com.zebra.sdk.comm.BluetoothConnection"
+        private const val PRINTER_FACTORY = "com.zebra.sdk.printer.ZebraPrinterFactory"
+        private const val IMAGE_FACTORY = "com.zebra.sdk.graphics.ZebraImageFactory"
+        private const val IMAGE_I = "com.zebra.sdk.graphics.ZebraImageI"
+        private const val NETWORK_DISCOVERER = "com.zebra.sdk.printer.discovery.NetworkDiscoverer"
+        private const val BLUETOOTH_DISCOVERER = "com.zebra.sdk.printer.discovery.BluetoothDiscoverer"
+        private const val DISCOVERY_HANDLER = "com.zebra.sdk.printer.discovery.DiscoveryHandler"
+    }
+}

package/android/src/main/java/com/delicity/thermalprinter/discovery/AdapterPriority.kt

@@ -0,0 +1,39 @@
+package com.delicity.thermalprinter.discovery
+
+import com.delicity.thermalprinter.model.AdapterId
+import com.delicity.thermalprinter.model.DiscoveredPrinter
+import com.delicity.thermalprinter.model.Transport
+
+/**
+ * Moteur de priorité d'adapter (miroir Kotlin de src/adapters/priority.ts).
+ *
+ * Règles :
+ *   1. SDK officiel reconnaissant l'imprimante -> priorité max.
+ *   2. Zebra -> ZebraAdapter UNIQUEMENT (escpos/rawTcp bannis).
+ *   3. ESC/POS confirmé > BLE > rawTcp.
+ */
+object AdapterPriority {
+
+    fun score(p: DiscoveredPrinter): Int {
+        val brand = p.brand?.lowercase() ?: ""
+        val isZebra = brand.contains("zebra") || p.adapter == AdapterId.ZEBRA
+        if (isZebra) return if (p.adapter == AdapterId.ZEBRA) 1000 else -1000
+
+        val fromVendorSdk = p.adapter in setOf(AdapterId.EPSON, AdapterId.STAR, AdapterId.BROTHER)
+        if (fromVendorSdk) {
+            return when (p.adapter) {
+                AdapterId.EPSON -> 900
+                AdapterId.STAR -> 890
+                AdapterId.BROTHER -> 880
+                else -> 850
+            }
+        }
+
+        if (p.adapter == AdapterId.ESCPOS) {
+            return if (p.transport == Transport.BLUETOOTH) 620 else 600
+        }
+        if (p.transport == Transport.BLE) return 500
+        if (p.adapter == AdapterId.RAW_TCP) return 300
+        return 100
+    }
+}

package/android/src/main/java/com/delicity/thermalprinter/discovery/BleScanner.kt

@@ -0,0 +1,70 @@
+package com.delicity.thermalprinter.discovery
+
+import android.annotation.SuppressLint
+import android.bluetooth.BluetoothAdapter
+import android.bluetooth.le.ScanCallback
+import android.bluetooth.le.ScanFilter
+import android.bluetooth.le.ScanResult
+import android.bluetooth.le.ScanSettings
+import android.content.Context
+import android.os.ParcelUuid
+import com.delicity.thermalprinter.model.AdapterId
+import com.delicity.thermalprinter.model.DiscoveredPrinter
+import com.delicity.thermalprinter.model.Transport
+import com.delicity.thermalprinter.transport.BleGattClient
+import java.util.Collections
+import kotlinx.coroutines.delay
+
+/**
+ * Scanner BLE : repère les imprimantes thermiques exposant un service "UART série"
+ * connu (allowlist [BleGattClient.ADVERTISED_SERVICES]). On filtre sur ces services
+ * pour éviter le bruit (la plupart des appareils BLE ne sont pas des imprimantes).
+ *
+ * Les résultats sont produits avec adapter=ESCPOS / transport=BLE : la connexion +
+ * l'écriture sont ensuite gérées par BleAdapter / BleGattClient.
+ */
+@SuppressLint("MissingPermission")
+class BleScanner(
+    private val context: Context,
+    private val btAdapter: BluetoothAdapter,
+) {
+
+    suspend fun scan(timeoutMs: Long, onFound: (DiscoveredPrinter) -> Unit) {
+        val scanner = btAdapter.bluetoothLeScanner ?: return
+        if (!btAdapter.isEnabled) return
+
+        val seen = Collections.synchronizedSet(mutableSetOf<String>())
+        val callback = object : ScanCallback() {
+            override fun onScanResult(callbackType: Int, result: ScanResult) {
+                val device = result.device ?: return
+                val address = device.address ?: return
+                if (!seen.add(address)) return
+                val name = result.scanRecord?.deviceName ?: runCatching { device.name }.getOrNull() ?: "BLE Printer"
+                onFound(
+                    DiscoveredPrinter(
+                        id = "ble:$address",
+                        name = name,
+                        transport = Transport.BLE,
+                        adapter = AdapterId.ESCPOS,
+                        address = address,
+                        discoveredBy = mutableSetOf(AdapterId.ESCPOS),
+                    ),
+                )
+            }
+        }
+
+        val filters = BleGattClient.ADVERTISED_SERVICES.map {
+            ScanFilter.Builder().setServiceUuid(ParcelUuid(it)).build()
+        }
+        val settings = ScanSettings.Builder()
+            .setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY)
+            .build()
+
+        try {
+            scanner.startScan(filters, settings, callback)
+            delay(timeoutMs)
+        } finally {
+            runCatching { scanner.stopScan(callback) }
+        }
+    }
+}

package/android/src/main/java/com/delicity/thermalprinter/discovery/BluetoothClassicScanner.kt

@@ -0,0 +1,112 @@
+package com.delicity.thermalprinter.discovery
+
+import android.annotation.SuppressLint
+import android.bluetooth.BluetoothAdapter
+import android.bluetooth.BluetoothClass
+import android.bluetooth.BluetoothDevice
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import com.delicity.thermalprinter.model.AdapterId
+import com.delicity.thermalprinter.model.Capabilities
+import com.delicity.thermalprinter.model.DiscoveredPrinter
+import com.delicity.thermalprinter.model.Transport
+import kotlinx.coroutines.delay
+
+/**
+ * Scanner Bluetooth Classic (Android).
+ *
+ * Deux sources :
+ *   1. Appareils DÉJÀ APPAIRÉS (instantané, sans scan) -> idéal en restauration
+ *      car l'imprimante est souvent appairée une fois pour toutes.
+ *   2. Découverte active (startDiscovery) pour les nouveaux appareils.
+ *
+ * Tous les résultats sont taggés adapter=ESCPOS (BT classic = SPP générique).
+ * Les imprimantes Epson/Star BT seront, elles, mieux remontées par leurs SDK
+ * respectifs et prendront la priorité via le dédoublonnage.
+ *
+ * Permissions requises (API 31+) : BLUETOOTH_SCAN + BLUETOOTH_CONNECT.
+ */
+@SuppressLint("MissingPermission")
+class BluetoothClassicScanner(
+    private val context: Context,
+    private val adapter: BluetoothAdapter?,
+) {
+
+    suspend fun scan(
+        timeoutMs: Long,
+        includePaired: Boolean,
+        onFound: (DiscoveredPrinter) -> Unit,
+    ) {
+        val ad = adapter ?: return
+        if (!ad.isEnabled) return
+
+        // 1) Appareils appairés
+        if (includePaired) {
+            ad.bondedDevices?.forEach { device ->
+                if (looksLikePrinter(device)) onFound(toPrinter(device, paired = true))
+            }
+        }
+
+        // 2) Découverte active
+        val discovered = mutableSetOf<String>()
+        val receiver = object : BroadcastReceiver() {
+            override fun onReceive(ctx: Context?, intent: Intent?) {
+                if (intent?.action == BluetoothDevice.ACTION_FOUND) {
+                    val device: BluetoothDevice? =
+                        intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE)
+                    if (device != null && discovered.add(device.address) && looksLikePrinter(device)) {
+                        onFound(toPrinter(device, paired = false))
+                    }
+                }
+            }
+        }
+        context.registerReceiver(receiver, IntentFilter(BluetoothDevice.ACTION_FOUND))
+        try {
+            ad.startDiscovery()
+            delay(timeoutMs)
+        } finally {
+            try { ad.cancelDiscovery() } catch (_: Exception) {}
+            try { context.unregisterReceiver(receiver) } catch (_: Exception) {}
+        }
+    }
+
+    /** Heuristique : classe IMAGING/printer, ou nom contenant des mots-clés imprimante. */
+    private fun looksLikePrinter(device: BluetoothDevice): Boolean {
+        val cls = device.bluetoothClass?.majorDeviceClass
+        if (cls == BluetoothClass.Device.Major.IMAGING) return true
+        val name = (device.name ?: "").lowercase()
+        return PRINTER_HINTS.any { name.contains(it) }
+    }
+
+    private fun toPrinter(device: BluetoothDevice, paired: Boolean): DiscoveredPrinter =
+        DiscoveredPrinter(
+            id = "bluetooth:${device.address}",
+            name = device.name ?: device.address,
+            brand = guessBrand(device.name),
+            transport = Transport.BLUETOOTH,
+            adapter = AdapterId.ESCPOS,
+            address = device.address,
+            capabilities = Capabilities(supportsRasterImage = true, supportsStatus = false),
+            discoveredBy = mutableSetOf(AdapterId.ESCPOS),
+        ).also { it.isConnected = false; if (paired) it.lastSeenAt = System.currentTimeMillis() }
+
+    private fun guessBrand(name: String?): String? {
+        val n = (name ?: "").lowercase()
+        return when {
+            n.contains("epson") -> "Epson"
+            n.contains("star") -> "Star"
+            n.contains("zebra") -> "Zebra"
+            n.contains("brother") -> "Brother"
+            else -> null
+        }
+    }
+
+    companion object {
+        private val PRINTER_HINTS = listOf(
+            "print", "printer", "pos", "escpos", "esc/pos", "thermal", "receipt",
+            "tm-", "mpt", "rpp", "mtp", "bluetooth printer",
+        )
+    }
+}

package/android/src/main/java/com/delicity/thermalprinter/discovery/DiscoveryManager.kt

@@ -0,0 +1,136 @@
+package com.delicity.thermalprinter.discovery
+
+import android.bluetooth.BluetoothAdapter
+import android.content.Context
+import com.delicity.thermalprinter.adapters.PrinterAdapter
+import com.delicity.thermalprinter.model.DiscoveredPrinter
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.withTimeoutOrNull
+import java.util.Collections
+
+/**
+ * Orchestre la découverte AGRÉGÉE multi-sources en parallèle puis fusionne.
+ *
+ * Sources lancées (selon options + disponibilité plateforme) :
+ *   - SDK Epson / Star / Brother / Zebra (via PrinterAdapter.discover)
+ *   - TcpScanner (réseau 9100)
+ *   - BluetoothClassicScanner (Android)
+ *   - BleScanner (optionnel)
+ *   - UsbAdapter.discover (optionnel)
+ *
+ * Chaque source pousse ses résultats dans un buffer thread-safe ; `emitPartial`
+ * est invoqué au fil de l'eau (event printerFound). À la fin : fusion +
+ * dédoublonnage + arbitrage d'adapter via AdapterPriority.
+ */
+class DiscoveryManager(
+    private val context: Context,
+    private val btAdapter: BluetoothAdapter?,
+    private val adapters: List<PrinterAdapter>,
+) {
+
+    data class Options(
+        val sources: Set<String>?, // null = toutes
+        val timeoutMs: Long = 8000,
+        val includePaired: Boolean = true,
+        val networkCidr: String? = null,
+        val tcpPorts: List<Int> = listOf(9100),
+    )
+
+    suspend fun discover(
+        options: Options,
+        emitPartial: (DiscoveredPrinter) -> Unit,
+    ): Pair<List<DiscoveredPrinter>, List<String>> = coroutineScope {
+        val buffer = Collections.synchronizedList(mutableListOf<DiscoveredPrinter>())
+        val failed = Collections.synchronizedList(mutableListOf<String>())
+
+        // Collecte thread-safe + émission partielle (callback synchrone).
+        val collect: (DiscoveredPrinter) -> Unit = { p ->
+            buffer.add(p)
+            runCatching { emitPartial(p) }
+        }
+
+        fun enabled(src: String) = options.sources == null || options.sources.contains(src)
+
+        val jobs = mutableListOf<kotlinx.coroutines.Deferred<Unit>>()
+
+        // --- Sources SDK fabricants (via adapters) ---
+        for (adapter in adapters) {
+            val discoverySource = when (adapter.id.value) {
+                "epson" -> "epson"
+                "star" -> "star"
+                "brother" -> "brother"
+                "zebra" -> "zebra"
+                else -> null
+            } ?: continue
+            if (enabled(discoverySource) && adapter.isAvailable()) {
+                jobs += async {
+                    runCatching {
+                        withTimeoutOrNull(options.timeoutMs + 1000) {
+                            adapter.discover(options.timeoutMs, collect)
+                        }
+                    }.onFailure { failed.add(discoverySource) }
+                    Unit
+                }
+            }
+        }
+
+        // --- Source TCP réseau ---
+        if (enabled("tcp")) {
+            jobs += async {
+                runCatching {
+                    TcpScanner(context).scan(options.timeoutMs, options.tcpPorts, options.networkCidr, collect)
+                }.onFailure { failed.add("tcp") }
+                Unit
+            }
+        }
+
+        // --- Source Bluetooth classique (Android) ---
+        if (enabled("bluetooth") && btAdapter != null) {
+            jobs += async {
+                runCatching {
+                    BluetoothClassicScanner(context, btAdapter)
+                        .scan(options.timeoutMs, options.includePaired, collect)
+                }.onFailure { failed.add("bluetooth") }
+                Unit
+            }
+        }
+
+        // --- Source BLE (allowlist de services "UART série") ---
+        if (enabled("ble") && btAdapter != null) {
+            jobs += async {
+                runCatching {
+                    BleScanner(context, btAdapter).scan(options.timeoutMs, collect)
+                }.onFailure { failed.add("ble") }
+                Unit
+            }
+        }
+
+        jobs.awaitAll()
+
+        Pair(merge(buffer.toList()), failed.distinct())
+    }
+
+    /** Fusion + dédoublonnage par id stable, en conservant le meilleur adapter. */
+    private fun merge(incoming: List<DiscoveredPrinter>): List<DiscoveredPrinter> {
+        val byId = LinkedHashMap<String, DiscoveredPrinter>()
+        for (p in incoming) {
+            val existing = byId[p.id]
+            if (existing == null) {
+                byId[p.id] = p
+                continue
+            }
+            val mergedSources = (existing.discoveredBy + p.discoveredBy).toMutableSet()
+            val winner = if (AdapterPriority.score(p) > AdapterPriority.score(existing)) p else existing
+            winner.discoveredBy.clear()
+            winner.discoveredBy.addAll(mergedSources)
+            winner.lastSeenAt = maxOf(existing.lastSeenAt, p.lastSeenAt)
+            winner.isConnected = existing.isConnected || p.isConnected
+            byId[p.id] = winner
+        }
+        return byId.values.sortedWith(
+            compareByDescending<DiscoveredPrinter> { AdapterPriority.score(it) }.thenBy { it.name },
+        )
+    }
+}

package/android/src/main/java/com/delicity/thermalprinter/discovery/TcpScanner.kt

@@ -0,0 +1,96 @@
+package com.delicity.thermalprinter.discovery
+
+import android.content.Context
+import android.net.ConnectivityManager
+import android.net.LinkProperties
+import com.delicity.thermalprinter.model.AdapterId
+import com.delicity.thermalprinter.model.Capabilities
+import com.delicity.thermalprinter.model.DiscoveredPrinter
+import com.delicity.thermalprinter.model.Transport
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Semaphore
+import kotlinx.coroutines.sync.withPermit
+import kotlinx.coroutines.withContext
+import java.net.InetSocketAddress
+import java.net.Socket
+
+/**
+ * Scanner réseau : sonde le /24 courant sur les ports d'impression (9100 par défaut)
+ * pour détecter des imprimantes RAW.
+ *
+ * Stratégie :
+ *   - déduire le préfixe réseau via ConnectivityManager (ou networkCidr fourni),
+ *   - tester 1..254 en parallèle (semaphore borné) avec un connect TCP court,
+ *   - un port ouvert = candidat ESC/POS (adapter ESCPOS), faute d'identification SDK.
+ *
+ * Limites : ne distingue pas la marque. Les SDK (Epson/Star/...) tournent en
+ * parallèle et, via le dédoublonnage, prennent la priorité sur ce résultat brut.
+ */
+class TcpScanner(private val context: Context) {
+
+    suspend fun scan(
+        timeoutMs: Long,
+        ports: List<Int>,
+        networkCidr: String?,
+        onFound: (DiscoveredPrinter) -> Unit,
+    ) = coroutineScope {
+        val prefix = networkCidr?.let { cidrToPrefix(it) } ?: detectPrefix() ?: return@coroutineScope
+        val portList = if (ports.isEmpty()) listOf(9100) else ports
+        val perHostTimeout = 300 // ms : connect court, le scan global est borné par timeoutMs
+        val gate = Semaphore(64) // limiter le parallélisme pour ne pas saturer le Wi-Fi
+
+        val deadline = System.currentTimeMillis() + timeoutMs
+        for (i in 1..254) {
+            val host = "$prefix$i"
+            for (port in portList) {
+                if (System.currentTimeMillis() > deadline) return@coroutineScope
+                launch(Dispatchers.IO) {
+                    gate.withPermit {
+                        if (isOpen(host, port, perHostTimeout)) {
+                            onFound(
+                                DiscoveredPrinter(
+                                    id = "wifi:$host",
+                                    name = host,
+                                    transport = Transport.WIFI,
+                                    adapter = AdapterId.ESCPOS, // sera arbitré par la priorité
+                                    address = "$host:$port",
+                                    capabilities = Capabilities(supportsRasterImage = true),
+                                    discoveredBy = mutableSetOf(AdapterId.ESCPOS, AdapterId.RAW_TCP),
+                                ),
+                            )
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    private suspend fun isOpen(host: String, port: Int, timeout: Int): Boolean = withContext(Dispatchers.IO) {
+        try {
+            Socket().use { s ->
+                s.connect(InetSocketAddress(host, port), timeout)
+                true
+            }
+        } catch (e: Exception) {
+            false
+        }
+    }
+
+    /** Renvoie le préfixe "192.168.1." du réseau courant, ou null. */
+    private fun detectPrefix(): String? {
+        val cm = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+        val active = cm.activeNetwork ?: return null
+        val lp: LinkProperties = cm.getLinkProperties(active) ?: return null
+        val addr = lp.linkAddresses.firstOrNull { it.address.address.size == 4 } ?: return null
+        val ip = addr.address.hostAddress ?: return null
+        return ip.substringBeforeLast('.') + "."
+    }
+
+    private fun cidrToPrefix(cidr: String): String? {
+        // Support simple /24 : "192.168.1.0/24" -> "192.168.1."
+        val ip = cidr.substringBefore('/')
+        return if (ip.count { it == '.' } == 3) ip.substringBeforeLast('.') + "." else null
+    }
+}