@dimer47/capacitor-plugin-printer 2.0.0

package/android/src/main/kotlin/com/nichedev/capacitor/printer/PrintContent.kt

@@ -0,0 +1,78 @@
+package com.nichedev.capacitor.printer
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import java.io.BufferedInputStream
+import java.io.InputStream
+import java.net.URLConnection
+
+class PrintContent private constructor(ctx: Context) {
+
+    enum class ContentType { PLAIN, HTML, IMAGE, PDF, UNSUPPORTED }
+
+    private val io = PrintIO(ctx)
+
+    companion object {
+        fun getContentType(path: String?, context: Context, forcedMimeType: String? = null): ContentType {
+            return PrintContent(context).getContentType(path, forcedMimeType)
+        }
+
+        fun open(path: String, context: Context): BufferedInputStream? {
+            return PrintContent(context).open(path)
+        }
+
+        fun decode(path: String, context: Context): Bitmap? {
+            return PrintContent(context).decode(path)
+        }
+    }
+
+    private fun getContentType(path: String?, forcedMimeType: String? = null): ContentType {
+        if (path == null || path.isEmpty() || path.startsWith("<")) {
+            return ContentType.HTML
+        }
+
+        if (path.matches(Regex("^[a-z0-9]+://.+"))) {
+            val mime: String? = forcedMimeType ?: if (path.startsWith("base64:")) {
+                try {
+                    URLConnection.guessContentTypeFromStream(io.openBase64(path))
+                } catch (e: Exception) {
+                    return ContentType.UNSUPPORTED
+                }
+            } else {
+                URLConnection.guessContentTypeFromName(path)
+            }
+
+            return when (mime) {
+                "image/bmp", "image/png", "image/jpeg", "image/jpeg2000",
+                "image/jp2", "image/gif", "image/x-icon",
+                "image/vnd.microsoft.icon", "image/heif" -> ContentType.IMAGE
+                "application/pdf" -> ContentType.PDF
+                else -> ContentType.UNSUPPORTED
+            }
+        }
+
+        return ContentType.PLAIN
+    }
+
+    private fun open(path: String): BufferedInputStream? {
+        val stream: InputStream? = when {
+            path.startsWith("res:") -> io.openResource(path)
+            path.startsWith("file:///") -> io.openFile(path)
+            path.startsWith("file://") -> io.openAsset(path)
+            path.startsWith("base64:") -> io.openBase64(path)
+            else -> null
+        }
+        return stream?.let { BufferedInputStream(it) }
+    }
+
+    private fun decode(path: String): Bitmap? {
+        return when {
+            path.startsWith("res:") -> io.decodeResource(path)
+            path.startsWith("file:///") -> io.decodeFile(path)
+            path.startsWith("file://") -> io.decodeAsset(path)
+            path.startsWith("base64:") -> io.decodeBase64(path)
+            else -> BitmapFactory.decodeFile(path)
+        }
+    }
+}

package/android/src/main/kotlin/com/nichedev/capacitor/printer/PrintIO.kt

@@ -0,0 +1,136 @@
+package com.nichedev.capacitor.printer
+
+import android.content.Context
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.util.Base64
+import java.io.ByteArrayInputStream
+import java.io.Closeable
+import java.io.FileInputStream
+import java.io.IOException
+import java.io.InputStream
+import java.io.OutputStream
+
+class PrintIO(private val context: Context) {
+
+    companion object {
+        @Throws(IOException::class)
+        fun copy(input: InputStream, output: OutputStream) {
+            val buf = ByteArray(8192)
+            var bytesRead: Int
+
+            if (input.markSupported()) {
+                input.mark(Int.MAX_VALUE)
+            }
+
+            while (input.read(buf).also { bytesRead = it } > 0) {
+                output.write(buf, 0, bytesRead)
+            }
+
+            if (input.markSupported()) {
+                try { input.reset() } catch (_: IOException) { }
+            }
+            close(output)
+        }
+
+        fun close(stream: Closeable) {
+            try {
+                stream.close()
+            } catch (_: IOException) {
+                // ignore
+            }
+        }
+    }
+
+    fun openFile(path: String): InputStream? {
+        if (path.length <= 7) return null
+        val absPath = path.substring(7)
+        return try {
+            FileInputStream(absPath)
+        } catch (e: Exception) {
+            null
+        }
+    }
+
+    fun decodeFile(path: String): Bitmap? {
+        if (path.length <= 7) return null
+        val absPath = path.substring(7)
+        return BitmapFactory.decodeFile(absPath)
+    }
+
+    fun openAsset(path: String): InputStream? {
+        val resPath = path.replaceFirst("file:/", "public")
+        return try {
+            context.assets.open(resPath)
+        } catch (e: Exception) {
+            null
+        }
+    }
+
+    fun decodeAsset(path: String): Bitmap? {
+        val stream = openAsset(path) ?: return null
+        val bitmap = BitmapFactory.decodeStream(stream)
+        close(stream)
+        return bitmap
+    }
+
+    fun openResource(path: String): InputStream? {
+        if (path.length <= 6) return null
+        val resPath = path.substring(6)
+        val resId = getResId(resPath)
+        if (resId == 0) return null
+        return try { context.resources.openRawResource(resId) } catch (_: Exception) { null }
+    }
+
+    fun decodeResource(path: String): Bitmap? {
+        if (path.length <= 6) return null
+        val resPath = path.substring(6)
+        val resId = getResId(resPath)
+        if (resId == 0) return null
+        return BitmapFactory.decodeResource(context.resources, resId)
+    }
+
+    fun openBase64(path: String): InputStream? {
+        if (path.length <= 9) return null
+        val data = path.substring(9)
+        return try {
+            val bytes = Base64.decode(data, 0)
+            ByteArrayInputStream(bytes)
+        } catch (_: Exception) { null }
+    }
+
+    fun decodeBase64(path: String): Bitmap? {
+        if (path.length <= 9) return null
+        val data = path.substring(9)
+        return try {
+            val bytes = Base64.decode(data, 0)
+            BitmapFactory.decodeByteArray(bytes, 0, bytes.size)
+        } catch (_: Exception) { null }
+    }
+
+    private fun getResId(resPath: String): Int {
+        val res = context.resources
+        val pkgName = context.packageName
+        var dirName = "drawable"
+        var fileName = resPath
+
+        if (resPath.contains("/")) {
+            dirName = resPath.substring(0, resPath.lastIndexOf('/'))
+            fileName = resPath.substring(resPath.lastIndexOf('/') + 1)
+        }
+
+        val dotIndex = fileName.lastIndexOf('.')
+        val resName = if (dotIndex > 0) fileName.substring(0, dotIndex) else fileName
+        var resId = res.getIdentifier(resName, dirName, pkgName)
+
+        if (resId == 0) {
+            resId = res.getIdentifier(resName, "mipmap", pkgName)
+        }
+
+        if (resId == 0) {
+            resId = res.getIdentifier(resName, "drawable", pkgName)
+        }
+
+        return resId
+    }
+}

package/android/src/main/kotlin/com/nichedev/capacitor/printer/PrintManager.kt

@@ -0,0 +1,219 @@
+package com.nichedev.capacitor.printer
+
+import android.app.Activity
+import android.content.Context
+import android.print.PrintAttributes
+import android.print.PrintDocumentAdapter
+import android.print.PrintJob
+import android.print.PrintJobInfo
+import android.webkit.CookieManager
+import android.webkit.WebSettings
+import android.webkit.WebView
+import android.webkit.WebViewClient
+import androidx.print.PrintHelper
+import org.json.JSONArray
+import org.json.JSONObject
+
+class PrintManager(private val context: Context) {
+
+    private var view: WebView? = null
+
+    fun canPrintItem(item: String?): Boolean {
+        var supported = PrintHelper.systemSupportsPrint()
+
+        if (item != null && item.isNotEmpty()) {
+            supported = PrintContent.getContentType(item, context) != PrintContent.ContentType.UNSUPPORTED
+        }
+
+        return supported
+    }
+
+    companion object {
+        fun getPrintableTypes(): JSONArray {
+            return JSONArray().apply {
+                put("com.adobe.pdf")
+                put("com.microsoft.bmp")
+                put("public.jpeg")
+                put("public.jpeg-2000")
+                put("public.png")
+                put("public.heif")
+                put("com.compuserve.gif")
+                put("com.microsoft.ico")
+            }
+        }
+    }
+
+    fun print(
+        content: String?,
+        settings: JSONObject,
+        webView: WebView,
+        callback: (Boolean) -> Unit,
+        forcedMimeType: String? = null
+    ) {
+        when (PrintContent.getContentType(content, context, forcedMimeType)) {
+            PrintContent.ContentType.IMAGE -> {
+                if (content == null) { callback(false); return }
+                printImage(content, settings, callback)
+            }
+            PrintContent.ContentType.PDF -> {
+                if (content == null) { callback(false); return }
+                printPdf(content, settings, callback)
+            }
+            PrintContent.ContentType.HTML -> {
+                if (content.isNullOrEmpty()) {
+                    printWebView(webView, settings, callback)
+                } else {
+                    printHtml(content, settings, callback)
+                }
+            }
+            PrintContent.ContentType.UNSUPPORTED,
+            PrintContent.ContentType.PLAIN -> printText(content, settings, callback)
+        }
+    }
+
+    private fun printHtml(content: String, settings: JSONObject, callback: (Boolean) -> Unit) {
+        printContent(content, "text/html", settings, callback)
+    }
+
+    private fun printText(content: String?, settings: JSONObject, callback: (Boolean) -> Unit) {
+        printContent(content ?: "", "text/plain", settings, callback)
+    }
+
+    private fun printContent(
+        content: String,
+        mimeType: String,
+        settings: JSONObject,
+        callback: (Boolean) -> Unit
+    ) {
+        val activity = context as? Activity ?: run {
+            callback(false)
+            return
+        }
+
+        activity.runOnUiThread {
+            val webView = createWebView(settings)
+            view = webView
+
+            webView.webViewClient = object : WebViewClient() {
+                override fun shouldOverrideUrlLoading(view: WebView, url: String): Boolean = false
+
+                override fun onPageFinished(wv: WebView, url: String) {
+                    val currentView = this@PrintManager.view ?: run {
+                        callback(false)
+                        return
+                    }
+                    printWebView(currentView, settings) { result ->
+                        this@PrintManager.view?.destroy()
+                        this@PrintManager.view = null
+                        callback(result)
+                    }
+                }
+            }
+
+            webView.loadDataWithBaseURL(
+                "file:///android_asset/public/",
+                content,
+                mimeType,
+                "UTF-8",
+                null
+            )
+        }
+    }
+
+    private fun printWebView(view: WebView, settings: JSONObject, callback: (Boolean) -> Unit) {
+        val options = PrintOptions(settings)
+        val jobName = options.getJobName()
+
+        val activity = context as? Activity ?: run {
+            callback(false)
+            return
+        }
+
+        activity.runOnUiThread {
+            val adapter: PrintDocumentAdapter = view.createPrintDocumentAdapter(jobName)
+            val proxy = PrintProxy(adapter) {
+                callback(isPrintJobCompleted(jobName))
+            }
+            printAdapter(proxy, options)
+        }
+    }
+
+    private fun printPdf(path: String, settings: JSONObject, callback: (Boolean) -> Unit) {
+        val stream = PrintContent.open(path, context) ?: run {
+            callback(false)
+            return
+        }
+
+        val options = PrintOptions(settings)
+        val jobName = options.getJobName()
+        val pageCount = options.getPageCount()
+        val adapter = PrintAdapter(jobName, pageCount, stream) {
+            callback(isPrintJobCompleted(jobName))
+        }
+
+        printAdapter(adapter, options)
+    }
+
+    private fun printAdapter(adapter: PrintDocumentAdapter, options: PrintOptions) {
+        val jobName = options.getJobName()
+        val attrs = options.toPrintAttributes()
+        getPrintService().print(jobName, adapter, attrs)
+    }
+
+    private fun printImage(path: String, settings: JSONObject, callback: (Boolean) -> Unit) {
+        val bitmap = PrintContent.decode(path, context) ?: run {
+            callback(false)
+            return
+        }
+
+        val options = PrintOptions(settings)
+        val printer = PrintHelper(context)
+        val jobName = options.getJobName()
+
+        options.decoratePrintHelper(printer)
+
+        printer.printBitmap(jobName, bitmap) {
+            callback(isPrintJobCompleted(jobName))
+        }
+    }
+
+    private fun createWebView(settings: JSONObject): WebView {
+        val jsEnabled = settings.optBoolean("javascript", false)
+        val webView = WebView(context)
+        val spec = webView.settings
+        val font = settings.optJSONObject("font")
+
+        spec.setSupportZoom(true)
+        spec.useWideViewPort = true
+        spec.javaScriptEnabled = jsEnabled
+
+        if (font != null && font.has("size")) {
+            spec.defaultFixedFontSize = font.optInt("size", 16)
+        }
+
+        spec.mixedContentMode = WebSettings.MIXED_CONTENT_ALWAYS_ALLOW
+        CookieManager.getInstance().setAcceptThirdPartyCookies(webView, true)
+
+        return webView
+    }
+
+    private fun findPrintJobByName(jobName: String): PrintJob? {
+        for (job in getPrintService().printJobs) {
+            if (job.info.label == jobName) {
+                return job
+            }
+        }
+        return null
+    }
+
+    private fun isPrintJobCompleted(jobName: String): Boolean {
+        val job = findPrintJobByName(jobName) ?: return true
+        return job.info.state != PrintJobInfo.STATE_FAILED &&
+               job.info.state != PrintJobInfo.STATE_CANCELED
+    }
+
+    private fun getPrintService(): android.print.PrintManager {
+        return context.getSystemService(Context.PRINT_SERVICE) as? android.print.PrintManager
+            ?: throw IllegalStateException("Print service not available")
+    }
+}

package/android/src/main/kotlin/com/nichedev/capacitor/printer/PrintOptions.kt

@@ -0,0 +1,260 @@
+package com.nichedev.capacitor.printer
+
+import android.print.PrintAttributes
+import android.print.PrintDocumentInfo
+import androidx.print.PrintHelper
+import org.json.JSONObject
+import kotlin.math.roundToInt
+
+class PrintOptions(private val spec: JSONObject) {
+
+    companion object {
+        /** Named paper sizes mapped to PrintAttributes.MediaSize constants. */
+        private val NAMED_SIZES: Map<String, PrintAttributes.MediaSize> = mapOf(
+            // ISO A series
+            "A0" to PrintAttributes.MediaSize.ISO_A0,
+            "A1" to PrintAttributes.MediaSize.ISO_A1,
+            "A2" to PrintAttributes.MediaSize.ISO_A2,
+            "A3" to PrintAttributes.MediaSize.ISO_A3,
+            "A4" to PrintAttributes.MediaSize.ISO_A4,
+            "A5" to PrintAttributes.MediaSize.ISO_A5,
+            "A6" to PrintAttributes.MediaSize.ISO_A6,
+            "A7" to PrintAttributes.MediaSize.ISO_A7,
+            "A8" to PrintAttributes.MediaSize.ISO_A8,
+            "A9" to PrintAttributes.MediaSize.ISO_A9,
+            "A10" to PrintAttributes.MediaSize.ISO_A10,
+            // ISO B series
+            "B0" to PrintAttributes.MediaSize.ISO_B0,
+            "B1" to PrintAttributes.MediaSize.ISO_B1,
+            "B2" to PrintAttributes.MediaSize.ISO_B2,
+            "B3" to PrintAttributes.MediaSize.ISO_B3,
+            "B4" to PrintAttributes.MediaSize.ISO_B4,
+            "B5" to PrintAttributes.MediaSize.ISO_B5,
+            "B6" to PrintAttributes.MediaSize.ISO_B6,
+            "B7" to PrintAttributes.MediaSize.ISO_B7,
+            "B8" to PrintAttributes.MediaSize.ISO_B8,
+            "B9" to PrintAttributes.MediaSize.ISO_B9,
+            "B10" to PrintAttributes.MediaSize.ISO_B10,
+            // ISO C series
+            "C0" to PrintAttributes.MediaSize.ISO_C0,
+            "C1" to PrintAttributes.MediaSize.ISO_C1,
+            "C2" to PrintAttributes.MediaSize.ISO_C2,
+            "C3" to PrintAttributes.MediaSize.ISO_C3,
+            "C4" to PrintAttributes.MediaSize.ISO_C4,
+            "C5" to PrintAttributes.MediaSize.ISO_C5,
+            "C6" to PrintAttributes.MediaSize.ISO_C6,
+            "C7" to PrintAttributes.MediaSize.ISO_C7,
+            "C8" to PrintAttributes.MediaSize.ISO_C8,
+            "C9" to PrintAttributes.MediaSize.ISO_C9,
+            "C10" to PrintAttributes.MediaSize.ISO_C10,
+            // North America
+            "LETTER" to PrintAttributes.MediaSize.NA_LETTER,
+            "LEGAL" to PrintAttributes.MediaSize.NA_LEGAL,
+            "TABLOID" to PrintAttributes.MediaSize.NA_TABLOID,
+            "LEDGER" to PrintAttributes.MediaSize.NA_LEDGER,
+            "JUNIOR_LEGAL" to PrintAttributes.MediaSize.NA_JUNIOR_LEGAL,
+            "GOVT_LETTER" to PrintAttributes.MediaSize.NA_GOVT_LETTER,
+            "INDEX_3X5" to PrintAttributes.MediaSize.NA_INDEX_3X5,
+            "INDEX_4X6" to PrintAttributes.MediaSize.NA_INDEX_4X6,
+            "4X6" to PrintAttributes.MediaSize.NA_INDEX_4X6,
+            "INDEX_5X8" to PrintAttributes.MediaSize.NA_INDEX_5X8,
+            "MONARCH" to PrintAttributes.MediaSize.NA_MONARCH,
+            "QUARTO" to PrintAttributes.MediaSize.NA_QUARTO,
+            "FOOLSCAP" to PrintAttributes.MediaSize.NA_FOOLSCAP,
+            // JIS
+            "JIS_B0" to PrintAttributes.MediaSize.JIS_B0,
+            "JIS_B1" to PrintAttributes.MediaSize.JIS_B1,
+            "JIS_B2" to PrintAttributes.MediaSize.JIS_B2,
+            "JIS_B3" to PrintAttributes.MediaSize.JIS_B3,
+            "JIS_B4" to PrintAttributes.MediaSize.JIS_B4,
+            "JIS_B5" to PrintAttributes.MediaSize.JIS_B5,
+            "JIS_B6" to PrintAttributes.MediaSize.JIS_B6,
+            "JIS_B7" to PrintAttributes.MediaSize.JIS_B7,
+            "JIS_B8" to PrintAttributes.MediaSize.JIS_B8,
+            "JIS_B9" to PrintAttributes.MediaSize.JIS_B9,
+            "JIS_B10" to PrintAttributes.MediaSize.JIS_B10,
+            "JIS_EXEC" to PrintAttributes.MediaSize.JIS_EXEC,
+            // Japanese
+            "JPN_CHOU2" to PrintAttributes.MediaSize.JPN_CHOU2,
+            "JPN_CHOU3" to PrintAttributes.MediaSize.JPN_CHOU3,
+            "JPN_CHOU4" to PrintAttributes.MediaSize.JPN_CHOU4,
+            "JPN_HAGAKI" to PrintAttributes.MediaSize.JPN_HAGAKI,
+            "JPN_OUFUKU" to PrintAttributes.MediaSize.JPN_OUFUKU,
+            "JPN_KAHU" to PrintAttributes.MediaSize.JPN_KAHU,
+            "JPN_KAKU2" to PrintAttributes.MediaSize.JPN_KAKU2,
+            "JPN_YOU4" to PrintAttributes.MediaSize.JPN_YOU4,
+            // Chinese
+            "ROC_8K" to PrintAttributes.MediaSize.ROC_8K,
+            "ROC_16K" to PrintAttributes.MediaSize.ROC_16K,
+            "PRC_1" to PrintAttributes.MediaSize.PRC_1,
+            "PRC_2" to PrintAttributes.MediaSize.PRC_2,
+            "PRC_3" to PrintAttributes.MediaSize.PRC_3,
+            "PRC_4" to PrintAttributes.MediaSize.PRC_4,
+            "PRC_5" to PrintAttributes.MediaSize.PRC_5,
+            "PRC_6" to PrintAttributes.MediaSize.PRC_6,
+            "PRC_7" to PrintAttributes.MediaSize.PRC_7,
+            "PRC_8" to PrintAttributes.MediaSize.PRC_8,
+            "PRC_9" to PrintAttributes.MediaSize.PRC_9,
+            "PRC_10" to PrintAttributes.MediaSize.PRC_10,
+            "PRC_16K" to PrintAttributes.MediaSize.PRC_16K,
+            "OM_PA_KAI" to PrintAttributes.MediaSize.OM_PA_KAI,
+            "OM_DAI_PA_KAI" to PrintAttributes.MediaSize.OM_DAI_PA_KAI,
+            "OM_JUURO_KU_KAI" to PrintAttributes.MediaSize.OM_JUURO_KU_KAI,
+        )
+
+        /** Convert a unit string (e.g., '10mm', '1in', '2cm') to mils (thousandths of inch). */
+        fun toMils(value: Any?): Int {
+            if (value == null) return 0
+            if (value is Number) return (value.toDouble() * 1000.0 / 72.0).roundToInt()
+
+            val str = value.toString()
+            if (str.isEmpty()) return 0
+
+            return when {
+                str.endsWith("mm") -> {
+                    val v = str.dropLast(2).toDoubleOrNull() ?: 0.0
+                    (v * 39.3701).roundToInt()
+                }
+                str.endsWith("cm") -> {
+                    val v = str.dropLast(2).toDoubleOrNull() ?: 0.0
+                    (v * 393.701).roundToInt()
+                }
+                str.endsWith("in") -> {
+                    val v = str.dropLast(2).toDoubleOrNull() ?: 0.0
+                    (v * 1000.0).roundToInt()
+                }
+                str.endsWith("pt") -> {
+                    val v = str.dropLast(2).toDoubleOrNull() ?: 0.0
+                    (v * 1000.0 / 72.0).roundToInt()
+                }
+                else -> {
+                    val v = str.toDoubleOrNull() ?: 0.0
+                    (v * 1000.0 / 72.0).roundToInt()
+                }
+            }
+        }
+    }
+
+    fun getJobName(): String {
+        val jobName = spec.optString("name", "")
+        return if (jobName.isEmpty()) {
+            "Printer Plugin Job #${System.currentTimeMillis()}"
+        } else {
+            jobName
+        }
+    }
+
+    fun getPageCount(): Int {
+        val count = spec.optInt("pageCount", PrintDocumentInfo.PAGE_COUNT_UNKNOWN)
+        return if (count <= 0) PrintDocumentInfo.PAGE_COUNT_UNKNOWN else count
+    }
+
+    fun toPrintAttributes(): PrintAttributes {
+        val builder = PrintAttributes.Builder()
+        val margin = spec.opt("margin")
+        val paper = spec.optJSONObject("paper")
+        val orientation = spec.optString("orientation", "")
+
+        // Resolve media size from paper option or orientation
+        val mediaSize = resolveMediaSize(paper, orientation)
+        if (mediaSize != null) {
+            builder.setMediaSize(mediaSize)
+        }
+
+        // Color mode
+        if (spec.has("monochrome")) {
+            if (spec.optBoolean("monochrome")) {
+                builder.setColorMode(PrintAttributes.COLOR_MODE_MONOCHROME)
+            } else {
+                builder.setColorMode(PrintAttributes.COLOR_MODE_COLOR)
+            }
+        }
+
+        // Margins: false → NO_MARGINS, object → custom margins
+        if (margin is Boolean && !margin) {
+            builder.setMinMargins(PrintAttributes.Margins.NO_MARGINS)
+        } else if (margin is JSONObject) {
+            val left = toMils(margin.opt("left"))
+            val top = toMils(margin.opt("top"))
+            val right = toMils(margin.opt("right"))
+            val bottom = toMils(margin.opt("bottom"))
+            builder.setMinMargins(PrintAttributes.Margins(left, top, right, bottom))
+        }
+
+        // Duplex
+        when (spec.optString("duplex")) {
+            "long" -> builder.setDuplexMode(PrintAttributes.DUPLEX_MODE_LONG_EDGE)
+            "short" -> builder.setDuplexMode(PrintAttributes.DUPLEX_MODE_SHORT_EDGE)
+            "none" -> builder.setDuplexMode(PrintAttributes.DUPLEX_MODE_NONE)
+        }
+
+        return builder.build()
+    }
+
+    fun decoratePrintHelper(printer: PrintHelper) {
+        when (spec.optString("orientation")) {
+            "landscape" -> printer.orientation = PrintHelper.ORIENTATION_LANDSCAPE
+            "portrait" -> printer.orientation = PrintHelper.ORIENTATION_PORTRAIT
+        }
+
+        if (spec.has("monochrome")) {
+            if (spec.optBoolean("monochrome")) {
+                printer.colorMode = PrintHelper.COLOR_MODE_MONOCHROME
+            } else {
+                printer.colorMode = PrintHelper.COLOR_MODE_COLOR
+            }
+        }
+
+        if (spec.optBoolean("autoFit", true)) {
+            printer.scaleMode = PrintHelper.SCALE_MODE_FIT
+        } else {
+            printer.scaleMode = PrintHelper.SCALE_MODE_FILL
+        }
+    }
+
+    private fun resolveMediaSize(
+        paper: JSONObject?,
+        orientation: String
+    ): PrintAttributes.MediaSize? {
+        var mediaSize: PrintAttributes.MediaSize? = null
+
+        if (paper != null) {
+            val name = paper.optString("name", "").uppercase()
+
+            if (name.isNotEmpty()) {
+                mediaSize = NAMED_SIZES[name]
+            }
+
+            // Custom width/height in paper option (values with units → mils)
+            if (mediaSize == null) {
+                val widthMils = toMils(paper.opt("width"))
+                val heightMils = toMils(paper.opt("height"))
+                if (widthMils > 0 && heightMils > 0) {
+                    mediaSize = PrintAttributes.MediaSize(
+                        "custom_${widthMils}x${heightMils}",
+                        "Custom ${widthMils}x${heightMils}",
+                        widthMils,
+                        heightMils
+                    )
+                }
+            }
+        }
+
+        // Apply orientation: if landscape, swap to landscape variant
+        if (mediaSize != null) {
+            mediaSize = when (orientation) {
+                "landscape" -> if (mediaSize.isPortrait) mediaSize.asLandscape() else mediaSize
+                "portrait" -> if (!mediaSize.isPortrait) mediaSize.asPortrait() else mediaSize
+                else -> mediaSize
+            }
+            return mediaSize
+        }
+
+        // Fallback: orientation only (no paper specified)
+        return when (orientation) {
+            "landscape" -> PrintAttributes.MediaSize.UNKNOWN_LANDSCAPE
+            "portrait" -> PrintAttributes.MediaSize.UNKNOWN_PORTRAIT
+            else -> null
+        }
+    }
+}