@connexup/react-native-xprinter 0.1.0

package/android/src/main/java/com/connexup/xprinter/tspl/XPrinterTSPLModule.kt

@@ -0,0 +1,1408 @@
+package com.connexup.xprinter.tspl
+
+import android.graphics.Bitmap
+import com.connexup.xprinter.COMMON_ERROR
+import com.connexup.xprinter.NativeXPrinterTSPLSpec
+import com.connexup.xprinter.PARAMS_ERROR
+import com.connexup.xprinter.PRINTER_NOT_FOUND_ERROR
+import com.connexup.xprinter.loadAndScaleBitmap
+import com.connexup.xprinter.printer.Printers
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableNativeMap
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+
+/**
+ * Description:
+ * @author lukechen@chancetop.com
+ * @date 2026/2/9
+ */
+class XPrinterTSPLModule(reactContext: ReactApplicationContext) :
+  NativeXPrinterTSPLSpec(reactContext) {
+
+  private val scope: CoroutineScope by lazy {
+    CoroutineScope(
+      SupervisorJob() + Dispatchers.Main
+    )
+  }
+
+  private val printers = Printers.tsplPrinters
+
+
+  override fun sizeInch(connectInfo: String, width: Double, height: Double, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.sizeInch(width, height)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun sizeMm(connectInfo: String, width: Double, height: Double, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.sizeMm(width, height)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun gapInch(connectInfo: String, m: Double, n: Double, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.gapInch(m, n)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun gapMm(connectInfo: String, m: Double, n: Double, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.gapMm(m, n)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun speed(connectInfo: String, speed: Double, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.speed(speed)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun density(connectInfo: String, density: Double, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.density(density.toInt())
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun direction(
+    connectInfo: String,
+    direction: String,
+    isMirror: Boolean,
+    promise: Promise
+  ) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      val direction = direction.toTSPLDirection()
+      if (direction == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "direction is error"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.direction(direction, isMirror)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun cls(connectInfo: String, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.cls()
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun box(connectInfo: String, payload: ReadableMap, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      try {
+        val x = payload.getInt("x")
+        val y = payload.getInt("y")
+        val width = payload.getInt("width")
+        val height = payload.getInt("height")
+        val thickness = payload.getInt("thickness")
+        withContext(Dispatchers.IO) {
+          printer.box(x, y, width, height, thickness)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun bar(connectInfo: String, payload: ReadableMap, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      try {
+        val x = payload.getInt("x")
+        val y = payload.getInt("y")
+        val width = payload.getInt("width")
+        val height = payload.getInt("height")
+        withContext(Dispatchers.IO) {
+          printer.bar(x, y, width, height)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun barcode(connectInfo: String, payload: ReadableMap, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      try {
+        val x = payload.getInt("x")
+        val y = payload.getInt("y")
+        val codeType = payload.getString("codeType")?.toTSPLBarcodeType()
+        if (codeType == null) {
+          promise.reject(
+            PARAMS_ERROR,
+            "codeType is error"
+          )
+          return@launch
+        }
+        val height = payload.getInt("height")
+        val readable = payload.getString("readable")?.toTSPLReadable()
+        if (readable == null) {
+          promise.reject(
+            PARAMS_ERROR,
+            "readable is error"
+          )
+          return@launch
+        }
+        val rotation = payload.getString("rotation")?.toTSPLRotation()
+        if (rotation == null) {
+          promise.reject(
+            PARAMS_ERROR,
+            "rotation is error"
+          )
+          return@launch
+        }
+        val narrow = payload.getInt("narrow")
+        val wide = payload.getInt("wide")
+        val content = payload.getString("content")
+        if (content == null) {
+          promise.reject(
+            PARAMS_ERROR,
+            "content is error"
+          )
+          return@launch
+        }
+        withContext(Dispatchers.IO) {
+          printer.barcode(
+            x,
+            y,
+            codeType,
+            height,
+            readable,
+            rotation,
+            narrow,
+            wide,
+            content
+          )
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun text(connectInfo: String, payload: ReadableMap, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      try {
+        val x = payload.getInt("x")
+        val y = payload.getInt("y")
+        val font = payload.getString("font")?.toTSPLFont()
+        if (font == null) {
+          promise.reject(
+            PARAMS_ERROR,
+            "font is error"
+          )
+          return@launch
+        }
+        val rotation = payload.getString("rotation")?.toTSPLRotation()
+        if (rotation == null) {
+          promise.reject(
+            PARAMS_ERROR,
+            "rotation is error"
+          )
+          return@launch
+        }
+        val xRatio = payload.getInt("xRatio")
+        val yRatio = payload.getInt("yRatio")
+        val content = payload.getString("content")
+        if (content == null) {
+          promise.reject(
+            PARAMS_ERROR,
+            "content is error"
+          )
+          return@launch
+        }
+        withContext(Dispatchers.IO) {
+          printer.text(x, y, font, rotation, xRatio, yRatio, content)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun offsetInch(connectInfo: String, offset: Double, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.offsetInch(offset)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun offsetMm(connectInfo: String, offset: Double, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.offsetMm(offset)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun reference(connectInfo: String, x: Double, y: Double, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.reference(x.toInt(), y.toInt())
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun qrcode(connectInfo: String, payload: ReadableMap, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      try {
+        val x = payload.getInt("x")
+        val y = payload.getInt("y")
+        val ecLevel = payload.getString("ecLevel")?.toTSPLECLevel()
+        if (ecLevel == null) {
+          promise.reject(
+            PARAMS_ERROR,
+            "ecLevel is error"
+          )
+          return@launch
+        }
+        val cellWidth = payload.getInt("cellWidth")
+        val mode = payload.getString("mode")?.toTSPLQrcodeMode()
+        if (mode == null) {
+          promise.reject(
+            PARAMS_ERROR,
+            "mode is error"
+          )
+          return@launch
+        }
+        val rotation = payload.getString("rotation")?.toTSPLRotation()
+        if (rotation == null) {
+          promise.reject(
+            PARAMS_ERROR,
+            "rotation is error"
+          )
+          return@launch
+        }
+        val model = payload.getString("model")?.toTSPLQrcodeModel()
+        if (model == null) {
+          promise.reject(
+            PARAMS_ERROR,
+            "model is error"
+          )
+          return@launch
+        }
+        val mask = payload.getString("mask")
+        if (mask == null) {
+          promise.reject(
+            PARAMS_ERROR,
+            "mask is error"
+          )
+          return@launch
+        }
+        val data = payload.getString("data")
+        if (data == null) {
+          promise.reject(
+            PARAMS_ERROR,
+            "data is error"
+          )
+          return@launch
+        }
+        withContext(Dispatchers.IO) {
+          printer.qrcode(x, y, ecLevel, cellWidth, mode, rotation, model, mask, data)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun print(connectInfo: String, count: Double, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.print(count.toInt())
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun printWithResponse(
+    connectInfo: String,
+    count: Double,
+    timeout: Double,
+    promise: Promise
+  ) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+      try {
+        withContext(Dispatchers.IO) {
+          printer.printWithResponse(count.toInt(), timeout.toInt()) {
+            scope.launch {
+              val result = WritableNativeMap()
+              result.putInt("status", it)
+              promise.resolve(result)
+            }
+          }
+        }
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun feed(connectInfo: String, length: Double, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.feed(length.toInt())
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun backFeed(connectInfo: String, length: Double, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.backFeed(length.toInt())
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun formFeed(connectInfo: String, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.formFeed()
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun limitFeedMm(connectInfo: String, length: Double, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.limitFeedMm(length.toInt())
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun limitFeedInch(connectInfo: String, length: Double, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.limitFeedInch(length.toInt())
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun home(connectInfo: String, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.home()
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun codePage(connectInfo: String, page: String, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.codePage(page)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun sound(connectInfo: String, level: Double, interval: Double, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.sound(level.toInt(), interval.toInt())
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun bitmap(connectInfo: String, payload: ReadableMap, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      val x = payload.getInt("x")
+      val y = payload.getInt("y")
+      val mode = payload.getString("mode")?.toTSPLBitmapMode()
+      if (mode == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "mode is error"
+        )
+        return@launch
+      }
+
+      val bitmapPath = payload.getString("bitmapPath")
+      val bitmapContent = payload.getString("bitmapContent")
+      if (bitmapPath == null && bitmapContent == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "bitmapPath is null and bitmapContent is null"
+        )
+        return@launch
+      }
+
+      val width = payload.getInt("width")
+
+      val algorithmType = payload.getString("algorithmType")?.toTSPLBitmapAlgorithmType()
+      if (algorithmType == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "algorithmType is error"
+        )
+        return@launch
+      }
+
+
+      var bitmap: Bitmap? = null
+      try {
+        withContext(Dispatchers.IO) {
+          bitmap = loadAndScaleBitmap(
+            bitmapContent = bitmapContent,
+            bitmapPath = bitmapPath,
+            width = width
+          )
+          printer.bitmap(x, y, mode, width, bitmap, algorithmType)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+      scope.launch(Dispatchers.IO) {
+        try {
+          if (bitmap !== null && !bitmap.isRecycled) {
+            bitmap.recycle()
+          }
+        } catch (_: Exception) {
+        }
+      }
+    }
+  }
+
+  override fun bitmapCompression(connectInfo: String, payload: ReadableMap, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      val x = payload.getInt("x")
+      val y = payload.getInt("y")
+      val mode = payload.getString("mode")?.toTSPLBitmapCompressionMode()
+      if (mode == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "mode is error"
+        )
+        return@launch
+      }
+
+      val bitmapPath = payload.getString("bitmapPath")
+      val bitmapContent = payload.getString("bitmapContent")
+      if (bitmapPath == null && bitmapContent == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "bitmapPath is null and bitmapContent is null"
+        )
+        return@launch
+      }
+
+      val width = payload.getInt("width")
+
+      val algorithmType = payload.getString("algorithmType")?.toTSPLBitmapAlgorithmType()
+      if (algorithmType == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "algorithmType is error"
+        )
+        return@launch
+      }
+
+      var bitmap: Bitmap? = null
+      try {
+        withContext(Dispatchers.IO) {
+          bitmap = loadAndScaleBitmap(
+            bitmapContent = bitmapContent,
+            bitmapPath = bitmapPath,
+            width = width
+          )
+          printer.bitmapCompression(x, y, mode, width, bitmap, algorithmType)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+      scope.launch(Dispatchers.IO) {
+        try {
+          if (bitmap !== null && !bitmap.isRecycled) {
+            bitmap.recycle()
+          }
+        } catch (_: Exception) {
+        }
+      }
+    }
+  }
+
+  override fun pdfBase64(connectInfo: String, payload: ReadableMap, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      val x = payload.getInt("x")
+      val y = payload.getInt("y")
+      val pageWidth = payload.getInt("pageWidth")
+      val base64String = payload.getString("base64String")
+      if (base64String == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "base64String is null"
+        )
+        return@launch
+      }
+      val algorithmType = payload.getString("algorithmType")?.toTSPLBitmapAlgorithmType()
+      if (algorithmType == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "algorithmType is error"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.pdfBase64(x, y, pageWidth, base64String, algorithmType)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun erase(connectInfo: String, payload: ReadableMap, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      val x = payload.getInt("x")
+      val y = payload.getInt("y")
+      val width = payload.getInt("width")
+      val height = payload.getInt("height")
+      try {
+        withContext(Dispatchers.IO) {
+          printer.erase(x, y, width, height)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun reverse(connectInfo: String, payload: ReadableMap, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      val x = payload.getInt("x")
+      val y = payload.getInt("y")
+      val width = payload.getInt("width")
+      val height = payload.getInt("height")
+      try {
+        withContext(Dispatchers.IO) {
+          printer.reverse(x, y, width, height)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+
+  override fun cut(connectInfo: String, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.cut()
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun setPeel(connectInfo: String, isOpen: Boolean, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.setPeel(isOpen)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun setTear(connectInfo: String, isOpen: Boolean, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.setTear(isOpen)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun setCutter(connectInfo: String, pieces: Double, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.setCutter(pieces.toInt())
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun putBMP(connectInfo: String, payload: ReadableMap, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      val x = payload.getInt("x")
+      val y = payload.getInt("y")
+      val fileName = payload.getString("fileName")
+      if (fileName == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "fileName is error"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.putBmp(x, y, fileName)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun blineInch(connectInfo: String, m: Double, n: Double, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.blineInch(m, n)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun blineMm(connectInfo: String, m: Double, n: Double, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.blineMm(m, n)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun setPrinterModel(connectInfo: String, model: String, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.setPrinterModel(model)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun getPrinterModel(connectInfo: String, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.getPrinterModel {
+            scope.launch {
+              val result = WritableNativeMap()
+              result.putString("model", it)
+              promise.resolve(result)
+            }
+          }
+        }
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+
+  override fun printerStatus(connectInfo: String, timeout: Double, promise: Promise) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.printerStatus(timeout.toInt()) {
+            scope.launch {
+              val result = WritableNativeMap()
+              result.putInt("status", it)
+              promise.resolve(result)
+            }
+          }
+        }
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  companion object {
+    const val NAME = NativeXPrinterTSPLSpec.NAME
+  }
+}