@delicity/capacitor-thermal-printer 7.0.0

package/android/src/main/java/com/delicity/thermalprinter/ThermalPrinterPlugin.kt

@@ -0,0 +1,334 @@
+package com.delicity.thermalprinter
+
+import android.Manifest
+import android.os.Build
+import com.getcapacitor.JSArray
+import com.getcapacitor.JSObject
+import com.getcapacitor.Plugin
+import com.getcapacitor.PluginCall
+import com.getcapacitor.PluginMethod
+import com.getcapacitor.annotation.CapacitorPlugin
+import com.getcapacitor.annotation.Permission
+import com.getcapacitor.annotation.PermissionCallback
+import com.delicity.thermalprinter.discovery.DiscoveryManager
+import com.delicity.thermalprinter.model.PrinterException
+import com.delicity.thermalprinter.model.RenderOptions
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+
+/**
+ * Pont Capacitor (bridge JS <-> natif). Mappe l'API publique ThermalPrinterPlugin
+ * (definitions.ts) vers le ThermalPrinterEngine.
+ *
+ * Toutes les opérations longues s'exécutent sur Dispatchers.IO ; les erreurs
+ * PrinterException sont converties en rejets Capacitor avec le code normalisé.
+ */
+@CapacitorPlugin(
+    name = "ThermalPrinter",
+    permissions = [
+        Permission(alias = "bluetoothScan", strings = [Manifest.permission.BLUETOOTH_SCAN]),
+        Permission(alias = "bluetoothConnect", strings = [Manifest.permission.BLUETOOTH_CONNECT]),
+        Permission(alias = "location", strings = [Manifest.permission.ACCESS_FINE_LOCATION]),
+    ],
+)
+class ThermalPrinterPlugin : Plugin() {
+
+    private lateinit var engine: ThermalPrinterEngine
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+
+    override fun load() {
+        engine = ThermalPrinterEngine(context)
+        // Relaye les états de job vers le JS (event printJobStatus).
+        engine.onJobUpdate = { u ->
+            val job = JSObject()
+                .put("jobId", u.jobId)
+                .put("printerId", u.printerId)
+                .put("state", u.state)
+                .put("updatedAt", System.currentTimeMillis())
+            u.holdReason?.let { job.put("holdReason", it) }
+            u.progress?.let { job.put("progress", it) }
+            u.errorCode?.let { job.put("errorCode", it.name) }
+            u.message?.let { job.put("message", it) }
+            notifyListeners("printJobStatus", JSObject().put("job", job))
+        }
+        // Relaye les changements de statut vers le JS (event statusChange).
+        engine.onStatusChange = { status ->
+            notifyListeners("statusChange", JSObject().put("status", status.toJson()))
+        }
+        Logger.log("plugin", "loaded")
+    }
+
+    // ---------------------------------------------------------------------
+    // Permissions
+    // ---------------------------------------------------------------------
+
+    @PluginMethod
+    override fun checkPermissions(call: PluginCall) {
+        call.resolve(buildPermissionStatus())
+    }
+
+    @PluginMethod
+    override fun requestPermissions(call: PluginCall) {
+        // Sur API < 31, les permissions BT runtime n'existent pas -> rien à demander.
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
+            call.resolve(buildPermissionStatus())
+            return
+        }
+        requestPermissionForAliases(arrayOf("bluetoothScan", "bluetoothConnect"), call, "permsCallback")
+    }
+
+    @PermissionCallback
+    private fun permsCallback(call: PluginCall) {
+        call.resolve(buildPermissionStatus())
+    }
+
+    private fun buildPermissionStatus(): JSObject {
+        fun state(alias: String): String =
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S && alias.startsWith("bluetooth")) "granted"
+            else getPermissionState(alias)?.toString() ?: "prompt"
+        return JSObject().apply {
+            put("bluetooth", state("bluetoothConnect"))
+            put("bluetoothScan", state("bluetoothScan"))
+            put("bluetoothConnect", state("bluetoothConnect"))
+            put("location", state("location"))
+            put("localNetwork", "granted") // pas de permission runtime réseau sur Android
+        }
+    }
+
+    // ---------------------------------------------------------------------
+    // Découverte
+    // ---------------------------------------------------------------------
+
+    @PluginMethod
+    fun discoverPrinters(call: PluginCall) = exec(call) {
+        val sources = call.getArray("sources", null)?.let { arr ->
+            (0 until arr.length()).map { arr.getString(it) }.toSet()
+        }
+        val options = DiscoveryManager.Options(
+            sources = sources,
+            timeoutMs = (call.getInt("timeoutMs")?.toLong()) ?: 8000L,
+            includePaired = call.getBoolean("includePaired", true) ?: true,
+            networkCidr = call.getString("networkCidr"),
+            tcpPorts = call.getArray("tcpPorts", null)?.let { arr ->
+                (0 until arr.length()).mapNotNull { arr.optInt(it) }
+            } ?: listOf(9100),
+        )
+        val emitPartial = call.getBoolean("emitPartialResults", true) ?: true
+
+        val (printers, failed) = engine.discover(options) { p ->
+            if (emitPartial) notifyListeners("printerFound", JSObject().put("printer", p.toJson()))
+        }
+
+        val arr = JSArray()
+        printers.forEach { arr.put(it.toJson()) }
+        val failedArr = JSArray()
+        failed.forEach { failedArr.put(it) }
+        val result = JSObject().put("printers", arr)
+
+        // Event de fin de découverte.
+        notifyListeners(
+            "discoveryComplete",
+            JSObject().put("printers", arr).put("failedSources", failedArr),
+        )
+        result
+    }
+
+    // ---------------------------------------------------------------------
+    // Connexion
+    // ---------------------------------------------------------------------
+
+    @PluginMethod
+    fun connectPrinter(call: PluginCall) = exec(call) {
+        val printerId = call.getString("printerId")
+            ?: throw PrinterException(com.delicity.thermalprinter.model.ErrorCode.PRINTER_NOT_FOUND, "printerId requis")
+        val timeout = (call.getInt("timeoutMs")?.toLong()) ?: 10000L
+        val force = call.getString("forceAdapter")?.let { com.delicity.thermalprinter.model.AdapterId.from(it) }
+        val setAsDefault = call.getBoolean("setAsDefault", false) ?: false
+        val connected = engine.connect(printerId, timeout, force, setAsDefault)
+        JSObject().put("connected", connected)
+    }
+
+    @PluginMethod
+    fun disconnectPrinter(call: PluginCall) = exec(call) {
+        engine.disconnect(call.getString("printerId") ?: "")
+        JSObject()
+    }
+
+    // ---------------------------------------------------------------------
+    // Profils / défaut
+    // ---------------------------------------------------------------------
+
+    @PluginMethod
+    fun setDefaultPrinter(call: PluginCall) = exec(call) {
+        val id = call.getString("printerId")
+            ?: throw PrinterException(com.delicity.thermalprinter.model.ErrorCode.PRINTER_NOT_FOUND, "printerId requis")
+        val profile = engine.setDefault(id)
+        JSObject().put("profile", profile.toJson())
+    }
+
+    @PluginMethod
+    fun getDefaultPrinter(call: PluginCall) = exec(call) {
+        val profile = engine.defaultProfile()
+        JSObject().put("profile", profile?.toJson() ?: JSObject.NULL)
+    }
+
+    @PluginMethod
+    fun getSavedPrinters(call: PluginCall) = exec(call) {
+        val arr = JSArray()
+        engine.savedProfiles().forEach { arr.put(it.toJson()) }
+        JSObject().put("profiles", arr)
+    }
+
+    @PluginMethod
+    fun removePrinter(call: PluginCall) = exec(call) {
+        engine.removeProfile(call.getString("printerId") ?: "")
+        JSObject()
+    }
+
+    // ---------------------------------------------------------------------
+    // Impression / statut
+    // ---------------------------------------------------------------------
+
+    @PluginMethod
+    fun printImage(call: PluginCall) = exec(call) {
+        val image = call.getObject("image")
+            ?: throw PrinterException(com.delicity.thermalprinter.model.ErrorCode.IMAGE_INVALID, "image requise")
+        val render = call.getObject("render")?.let { r ->
+            RenderOptions(
+                widthDots = r.optInt("widthDots", 0),
+                resize = r.optBoolean("resize", true),
+                grayscale = r.optBoolean("grayscale", true),
+                threshold = r.optInt("threshold", 128),
+                dithering = r.optString("dithering", "floyd_steinberg"),
+                align = r.optString("align", "center"),
+                invert = r.optBoolean("invert", false),
+                cut = r.optBoolean("cut", true),
+                feedLines = r.optInt("feedLines", 3),
+                openCashDrawer = r.optBoolean("openCashDrawer", false),
+                copies = r.optInt("copies", 1),
+            )
+        }
+        val req = ThermalPrinterEngine.PrintRequest(
+            printerId = call.getString("printerId"),
+            filePath = image.optString("filePath", null),
+            url = image.optString("url", null),
+            base64 = image.optString("base64", null),
+            render = render,
+            timeoutMs = (call.getInt("timeoutMs")?.toLong()) ?: 15000L,
+            autoReconnect = call.getBoolean("autoReconnect", true) ?: true,
+        )
+        val out = engine.printImage(req)
+        printResultJson(out)
+    }
+
+    @PluginMethod
+    fun printText(call: PluginCall) = exec(call) {
+        val itemsArr = call.getArray("items")
+            ?: throw PrinterException(com.delicity.thermalprinter.model.ErrorCode.IMAGE_INVALID, "items requis")
+        val items = com.delicity.thermalprinter.model.PrintItem.parseList(itemsArr)
+        val req = ThermalPrinterEngine.PrintTextRequest(
+            printerId = call.getString("printerId"),
+            items = items,
+            defaultCodePage = call.getString("defaultCodePage") ?: "WPC1252",
+            cut = call.getBoolean("cut", false) ?: false,
+            feedLines = call.getInt("feedLines") ?: 3,
+            timeoutMs = (call.getInt("timeoutMs")?.toLong()) ?: 15000L,
+            autoReconnect = call.getBoolean("autoReconnect", true) ?: true,
+        )
+        val out = engine.printText(req)
+        printResultJson(out)
+    }
+
+    private fun printResultJson(out: ThermalPrinterEngine.PrintOutcome): JSObject = JSObject().apply {
+        put("success", out.state == "completed")
+        put("printerId", out.printerId)
+        put("adapter", out.adapter.value)
+        put("jobId", out.jobId)
+        put("state", out.state)
+        put("bytesSent", out.bytesSent)
+        put("durationMs", out.durationMs)
+        out.status?.let { put("status", it.toJson()) }
+    }
+
+    @PluginMethod
+    fun getPrinterStatus(call: PluginCall) = exec(call) {
+        engine.getStatus(call.getString("printerId")).toJson()
+    }
+
+    // ---------------------------------------------------------------------
+    // Monitoring (Phase 6) — stubs branchés à compléter
+    // ---------------------------------------------------------------------
+
+    @PluginMethod
+    fun startStatusMonitor(call: PluginCall) = exec(call) {
+        val printerId = call.getString("printerId")
+            ?: throw PrinterException(com.delicity.thermalprinter.model.ErrorCode.PRINTER_NOT_FOUND, "printerId requis")
+        val interval = (call.getInt("intervalMs")?.toLong()) ?: 5000L
+        engine.startStatusMonitor(printerId, interval)
+        JSObject()
+    }
+
+    @PluginMethod
+    fun stopStatusMonitor(call: PluginCall) = exec(call) {
+        val printerId = call.getString("printerId")
+            ?: throw PrinterException(com.delicity.thermalprinter.model.ErrorCode.PRINTER_NOT_FOUND, "printerId requis")
+        engine.stopStatusMonitor(printerId)
+        JSObject()
+    }
+
+    @PluginMethod
+    fun getActiveSdks(call: PluginCall) = exec(call) {
+        val arr = JSArray()
+        engine.activeSdks().forEach { s ->
+            val transports = JSArray()
+            s.transports.forEach { transports.put(it) }
+            arr.put(
+                JSObject()
+                    .put("adapter", s.adapter)
+                    .put("label", s.label)
+                    .put("available", s.available)
+                    .put("requiresSdk", s.requiresSdk)
+                    .put("transports", transports),
+            )
+        }
+        JSObject().put("sdks", arr)
+    }
+
+    @PluginMethod
+    fun getDebugLog(call: PluginCall) {
+        call.resolve(JSObject().put("log", engine.debugLog()))
+    }
+
+    // ---------------------------------------------------------------------
+    // Plomberie : exécution async + normalisation d'erreurs
+    // ---------------------------------------------------------------------
+
+    private fun exec(call: PluginCall, block: suspend () -> JSObject) {
+        scope.launch {
+            try {
+                val result = block()
+                withContext(Dispatchers.Main) { call.resolve(result) }
+            } catch (e: PrinterException) {
+                Logger.error("plugin", "${e.code}: ${e.message}", e)
+                withContext(Dispatchers.Main) {
+                    val data = JSObject().put("code", e.code.name).put("detail", e.detail).put("retryable", e.retryable)
+                    call.reject(e.message, e.code.name, e, data)
+                }
+            } catch (e: Exception) {
+                Logger.error("plugin", "UNKNOWN: ${e.message}", e)
+                withContext(Dispatchers.Main) {
+                    call.reject(e.message ?: "Erreur inconnue", "UNKNOWN", e)
+                }
+            }
+        }
+    }
+
+    override fun handleOnDestroy() {
+        super.handleOnDestroy()
+        engine.stopAllMonitors()
+        scope.coroutineContext[kotlinx.coroutines.Job]?.cancel()
+    }
+}

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

@@ -0,0 +1,125 @@
+package com.delicity.thermalprinter.adapters
+
+import android.bluetooth.BluetoothManager
+import android.content.Context
+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.BleGattClient
+import java.util.concurrent.ConcurrentHashMap
+
+/**
+ * Adapter BLE (Bluetooth Low Energy) générique pour imprimantes ESC/POS exposant
+ * un service GATT d'écriture "série".
+ *
+ * La connexion GATT + l'écriture par paquets sont déléguées à [BleGattClient]
+ * (négociation MTU, allowlist d'UUID, fallback characteristic inscriptible). Le
+ * scan BLE concret est fait par BleScanner (DiscoveryManager).
+ *
+ * Recommandation : valider chaque modèle (allowlist d'UUID dans BleGattClient).
+ * Pour le BT classique ESC/POS générique sur Android, préférer SPP (EscPosAdapter).
+ */
+class BleAdapter(private val context: Context) : PrinterAdapter {
+
+    override val id = AdapterId.ESCPOS // BLE transporte de l'ESC/POS dans la majorité des cas
+
+    private val connections = ConcurrentHashMap<String, BleGattClient>()
+
+    private val btAdapter by lazy {
+        (context.getSystemService(Context.BLUETOOTH_SERVICE) as? BluetoothManager)?.adapter
+    }
+
+    override fun isAvailable(): Boolean =
+        context.packageManager.hasSystemFeature(android.content.pm.PackageManager.FEATURE_BLUETOOTH_LE)
+
+    override fun supportsTextItems(): Boolean = true
+
+    override suspend fun discover(timeoutMs: Long, onFound: (DiscoveredPrinter) -> Unit) {
+        // Délégué à BleScanner (DiscoveryManager).
+    }
+
+    override fun canHandle(profile: PrinterProfile): Boolean = profile.transport == Transport.BLE
+
+    override suspend fun connect(profile: PrinterProfile, timeoutMs: Long) {
+        ensureBle()
+        if (isConnected(profile.id)) return
+        val adapter = btAdapter ?: throw PrinterException(ErrorCode.BLUETOOTH_DISABLED, "Bluetooth indisponible")
+        val device = try {
+            adapter.getRemoteDevice(profile.address)
+        } catch (e: IllegalArgumentException) {
+            throw PrinterException(ErrorCode.PRINTER_NOT_FOUND, "Adresse BLE invalide: ${profile.address}")
+        }
+        val client = BleGattClient(context, device)
+        client.open(timeoutMs)
+        connections[profile.id] = client
+    }
+
+    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 client = requireClient(profile)
+        val mono = ImageProcessor.toMono(bitmap, options)
+        val raster = ImageProcessor.encodeEscPosRaster(mono)
+        val job = EscPosCommands.buildJob(
+            rasterData = raster,
+            align = options.align,
+            feedLines = options.feedLines,
+            cut = options.cut && profile.capabilities.supportsCut,
+            openDrawer = options.openCashDrawer && profile.capabilities.supportsCashDrawer,
+        )
+        var sent = 0
+        repeat(options.copies.coerceAtLeast(1)) {
+            client.write(job)
+            sent += job.size
+        }
+        return sent
+    }
+
+    override suspend fun printItems(
+        profile: PrinterProfile,
+        items: List<com.delicity.thermalprinter.model.PrintItem>,
+        defaultCodePage: String,
+        cut: Boolean,
+        feedLines: Int,
+    ): Int {
+        val client = requireClient(profile)
+        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 && profile.capabilities.supportsCut) out.write(EscPosCommands.CUT_PARTIAL)
+        val job = out.toByteArray()
+        client.write(job)
+        return job.size
+    }
+
+    override suspend fun getStatus(profile: PrinterProfile): PrinterStatus {
+        val open = isConnected(profile.id)
+        return PrinterStatus(
+            id = profile.id,
+            connection = if (open) "connected" else "disconnected",
+            online = open,
+            paper = "unknown",
+            rawStatus = "BLE: statut temps réel non lu (notify spécifique au modèle)",
+        )
+    }
+
+    private fun requireClient(profile: PrinterProfile): BleGattClient =
+        connections[profile.id] ?: throw PrinterException(ErrorCode.CONNECTION_FAILED, "BLE non connecté: ${profile.id}")
+
+    private fun ensureBle() {
+        if (!isAvailable()) throw PrinterException(ErrorCode.UNSUPPORTED_TRANSPORT, "BLE indisponible sur cet appareil")
+    }
+}

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

@@ -0,0 +1,206 @@
+package com.delicity.thermalprinter.adapters
+
+import android.bluetooth.BluetoothManager
+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 Brother basé sur le Brother Print SDK v4 (`com.brother.sdk.lmprinter`),
+ * piloté par RÉFLEXION.
+ *
+ * Brother est orienté étiquettes (QL / TD / RJ / PJ / PT) : les réglages d'impression
+ * (`*PrintSettings`) dépendent du MODÈLE. L'adapter dérive un `PrinterModel` depuis
+ * `profile.model` (ex "RJ-3150" -> PrinterModel.RJ_3150). Si le modèle est inconnu,
+ * une erreur explicite invite à le préciser.
+ *
+ * Le SDK n'est pas redistribuable (licence Brother) : déposer
+ * `BrotherPrintLibrary.aar` (portail Brother). Voir docs/SDK_INTEGRATION.md (§ Brother).
+ *
+ * ⚠️ API model-dépendante : à vérifier sur device avec le binaire réel.
+ */
+class BrotherAdapter(private val context: Context) : PrinterAdapter {
+
+    override val id = AdapterId.BROTHER
+
+    private val cache = ConcurrentHashMap<String, Any>() // printerId -> PrinterDriver
+
+    private val btAdapter by lazy {
+        (context.getSystemService(Context.BLUETOOTH_SERVICE) as? BluetoothManager)?.adapter
+    }
+
+    override fun isAvailable(): Boolean = EpsonAdapter.classExists(DRIVER_GENERATOR)
+
+    // -------------------------------------------------------------------------
+    // Découverte (BRLMPrinterSearcher — réseau)
+    // -------------------------------------------------------------------------
+
+    override suspend fun discover(timeoutMs: Long, onFound: (DiscoveredPrinter) -> Unit) {
+        if (!isAvailable()) return
+        // L'API de recherche Brother varie selon la version ; on tente la recherche
+        // réseau si disponible, sinon on s'appuie sur le scan TCP générique.
+        runCatching {
+            val option = SdkReflect.newInstance(NET_SEARCH_OPTION, emptyArray(), emptyArray())
+            runCatching {
+                SdkReflect.call(option, "setSearchDuration", arrayOf(Int::class.javaPrimitiveType!!), arrayOf((timeoutMs / 1000).toInt()))
+            }
+            val callback = SdkReflect.proxy(SEARCH_RESULT_CALLBACK, mapOf(
+                "onChannelInfo" to { args -> handleChannel(args.getOrNull(0), onFound); null },
+                "onSearchResult" to { null },
+            ))
+            SdkReflect.callStatic(
+                SEARCHER, "startNetworkSearch",
+                arrayOf(Context::class.java, SdkReflect.classOrNull(NET_SEARCH_OPTION)!!, SdkReflect.classOrNull(SEARCH_RESULT_CALLBACK)!!),
+                arrayOf(context, option, callback),
+            )
+        }
+    }
+
+    private fun handleChannel(channel: Any?, onFound: (DiscoveredPrinter) -> Unit) {
+        if (channel == null) return
+        val address = (SdkReflect.call(channel, "getChannelInfo") as? String)
+            ?: (SdkReflect.field(channel, "channelInfo") as? String) ?: return
+        val name = (SdkReflect.call(channel, "getExtraInfo") as? String) ?: "Brother"
+        onFound(
+            DiscoveredPrinter(
+                id = "brother:$address",
+                name = name,
+                brand = "Brother",
+                transport = Transport.WIFI,
+                adapter = AdapterId.BROTHER,
+                address = address,
+                discoveredBy = mutableSetOf(AdapterId.BROTHER),
+            ),
+        )
+    }
+
+    override fun canHandle(profile: PrinterProfile): Boolean =
+        isAvailable() && profile.adapter == AdapterId.BROTHER
+
+    // -------------------------------------------------------------------------
+    // Connexion (openChannel -> PrinterDriver)
+    // -------------------------------------------------------------------------
+
+    override suspend fun connect(profile: PrinterProfile, timeoutMs: Long) {
+        ensureSdk()
+        if (isConnected(profile.id)) return
+        val channel = buildChannel(profile)
+        val result = SdkReflect.callStatic(
+            DRIVER_GENERATOR, "openChannel",
+            arrayOf(SdkReflect.classOrNull(CHANNEL)!!), arrayOf(channel),
+        ) ?: throw PrinterException(ErrorCode.CONNECTION_FAILED, "openChannel Brother null")
+
+        val driver = SdkReflect.call(result, "getDriver")
+        if (driver == null) {
+            val err = runCatching { SdkReflect.call(result, "getError")?.let { SdkReflect.call(it, "getCode") } }.getOrNull()
+            throw PrinterException(ErrorCode.CONNECTION_FAILED, "Connexion Brother échouée (${err ?: "openChannel"})", retryable = true)
+        }
+        cache[profile.id] = driver
+    }
+
+    override fun isConnected(printerId: String): Boolean = cache.containsKey(printerId)
+
+    override suspend fun disconnect(printerId: String) {
+        cache.remove(printerId)?.let { runCatching { SdkReflect.call(it, "closeChannel") } }
+    }
+
+    // -------------------------------------------------------------------------
+    // Impression image
+    // -------------------------------------------------------------------------
+
+    override suspend fun printBitmap(profile: PrinterProfile, bitmap: Bitmap, options: RenderOptions): Int {
+        val driver = cache[profile.id]
+            ?: throw PrinterException(ErrorCode.CONNECTION_FAILED, "Brother non connecté: ${profile.id}")
+        val settings = buildPrintSettings(profile)
+        try {
+            repeat(options.copies.coerceAtLeast(1)) {
+                SdkReflect.call(
+                    driver, "printImage",
+                    arrayOf(Bitmap::class.java, SdkReflect.classOrNull(PRINT_IMAGE_SETTINGS)!!),
+                    arrayOf(bitmap, settings),
+                )
+            }
+        } catch (e: Throwable) {
+            throw PrinterException(ErrorCode.PRINT_FAILED, "Impression Brother échouée", e.message, retryable = true)
+        }
+        return bitmap.width * bitmap.height / 8
+    }
+
+    // -------------------------------------------------------------------------
+    // Statut
+    // -------------------------------------------------------------------------
+
+    override suspend fun getStatus(profile: PrinterProfile): PrinterStatus {
+        val driver = cache[profile.id]
+            ?: return PrinterStatus(profile.id, "disconnected", online = false, paper = "unknown")
+        return try {
+            val result = SdkReflect.call(driver, "getPrinterStatus")
+            val online = result != null
+            PrinterStatus(profile.id, if (online) "connected" else "disconnected", online = online, paper = "unknown", rawStatus = result?.toString())
+        } catch (e: Throwable) {
+            PrinterStatus(profile.id, "connected", online = true, paper = "unknown", rawStatus = e.message)
+        }
+    }
+
+    // -------------------------------------------------------------------------
+    // Helpers
+    // -------------------------------------------------------------------------
+
+    private fun buildChannel(profile: PrinterProfile): Any = when (profile.transport) {
+        Transport.WIFI, Transport.ETHERNET -> SdkReflect.callStatic(
+            CHANNEL, "newWifiChannel", arrayOf(String::class.java), arrayOf(profile.address.substringBefore(":")),
+        ) ?: error("newWifiChannel null")
+        Transport.BLUETOOTH -> SdkReflect.callStatic(
+            CHANNEL, "newBluetoothChannel",
+            arrayOf(String::class.java, android.bluetooth.BluetoothAdapter::class.java),
+            arrayOf(profile.address, btAdapter),
+        ) ?: error("newBluetoothChannel null")
+        Transport.BLE -> SdkReflect.callStatic(
+            CHANNEL, "newBluetoothLowEnergyChannel",
+            arrayOf(String::class.java, Context::class.java, android.bluetooth.BluetoothAdapter::class.java),
+            arrayOf(profile.address, context, btAdapter),
+        ) ?: error("newBluetoothLowEnergyChannel null")
+        else -> throw PrinterException(ErrorCode.UNSUPPORTED_TRANSPORT, "Transport Brother non supporté: ${profile.transport.value}")
+    }
+
+    /**
+     * Construit les *PrintSettings selon la famille du modèle (QL/PJ/RJ/TD/PT).
+     * `PrinterModel` est dérivé du nom (ex "RJ-3150" -> RJ_3150).
+     */
+    private fun buildPrintSettings(profile: PrinterProfile): Any {
+        val model = profile.model
+            ?: throw PrinterException(ErrorCode.UNSUPPORTED_PRINTER, "Modèle Brother requis (ex 'RJ-3150') pour les réglages d'impression")
+        val enumName = model.uppercase().replace("-", "_").replace(" ", "_")
+        val family = Regex("^(QL|PJ|RJ|TD|PT)").find(enumName)?.value
+            ?: throw PrinterException(ErrorCode.UNSUPPORTED_PRINTER, "Famille Brother inconnue pour '$model'")
+        val printerModel = SdkReflect.enumValue(PRINTER_MODEL, enumName)
+            ?: throw PrinterException(ErrorCode.UNSUPPORTED_PRINTER, "PrinterModel Brother inconnu: $enumName")
+        val settingsClass = "$SETTING_PKG.${family}PrintSettings"
+        return SdkReflect.newInstance(
+            settingsClass, arrayOf(SdkReflect.classOrNull(PRINTER_MODEL)!!), arrayOf(printerModel),
+        )
+    }
+
+    private fun ensureSdk() {
+        if (!isAvailable()) throw PrinterException(ErrorCode.SDK_NOT_AVAILABLE, "SDK Brother absent")
+    }
+
+    companion object {
+        private const val DRIVER_GENERATOR = "com.brother.sdk.lmprinter.PrinterDriverGenerator"
+        private const val CHANNEL = "com.brother.sdk.lmprinter.Channel"
+        private const val SEARCHER = "com.brother.sdk.lmprinter.PrinterSearcher"
+        private const val NET_SEARCH_OPTION = "com.brother.sdk.lmprinter.NetworkSearchOption"
+        private const val SEARCH_RESULT_CALLBACK = "com.brother.sdk.lmprinter.PrinterSearcher\$SearchResultCallback"
+        private const val SETTING_PKG = "com.brother.sdk.lmprinter.setting"
+        private const val PRINT_IMAGE_SETTINGS = "com.brother.sdk.lmprinter.setting.PrintImageSettings"
+        private const val PRINTER_MODEL = "com.brother.sdk.lmprinter.setting.PrinterModel"
+    }
+}