@connexup/react-native-xprinter 0.1.0

package/android/src/main/java/com/connexup/xprinter/esc/XPrinterESCModule.kt

@@ -0,0 +1,1995 @@
+package com.connexup.xprinter.esc
+
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import com.connexup.xprinter.COMMON_ERROR
+import com.connexup.xprinter.NOT_YET_IMPLEMENTED_ERROR
+import com.connexup.xprinter.NativeXPrinterESCSpec
+import com.connexup.xprinter.PARAMS_ERROR
+import com.connexup.xprinter.PRINTER_NOT_FOUND_ERROR
+import com.connexup.xprinter.loadAndScaleBitmap
+import com.connexup.xprinter.parseAddressData
+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.WritableNativeArray
+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
+import net.posprinter.POSConst.SPACE_DEFAULT
+import net.posprinter.model.PTable
+import net.posprinter.model.TableBarcode
+import java.nio.charset.Charset
+
+private const val DEFAULT_LINE_SPACE = -1
+
+/**
+ * Description:
+ * @author lukechen@chancetop.com
+ * @date 2026/2/9
+ */
+class XPrinterESCModule(reactContext: ReactApplicationContext) :
+  NativeXPrinterESCSpec(reactContext) {
+
+  private val scope: CoroutineScope by lazy {
+    CoroutineScope(
+      SupervisorJob() + Dispatchers.Main
+    )
+  }
+
+  private val printers = Printers.escPrinters
+
+  override fun setCharSet(
+    connectInfo: String,
+    charSet: String,
+    promise: Promise
+  ) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+      val convertCharSet = charSet.toCharSet()
+      if (convertCharSet == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "charSet is error"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.setCharSet(convertCharSet)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun selectInternationCharacterSets(
+    connectInfo: String,
+    n: String,
+    promise: Promise
+  ) {
+    promise.reject(NOT_YET_IMPLEMENTED_ERROR, "Not yet implemented")
+  }
+
+  override fun isConnect(connectInfo: String, promise: Promise) {
+    promise.reject(NOT_YET_IMPLEMENTED_ERROR, "Not yet implemented")
+  }
+
+  override fun initializePrinter(
+    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.initializePrinter()
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun printString(
+    connectInfo: String,
+    data: 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.printString(data)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun printTextSize(
+    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 data = payload.getString("data")
+      if (data == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "data is null"
+        )
+        return@launch
+      }
+
+      val textWidth = payload.getString("textWidth")?.toESCTextWidth()
+      if (textWidth == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "textWidth is error"
+        )
+        return@launch
+      }
+      val textHeight = payload.getString("textHeight")?.toESCTextHeight()
+      if (textHeight == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "textHeight is error"
+        )
+        return@launch
+      }
+
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.printTextSize(data, textWidth or textHeight)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e,
+        )
+      }
+    }
+  }
+
+  override fun printTextAttribute(
+    connectInfo: String,
+    data: String,
+    attribute: String,
+    promise: Promise
+  ) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+      val textAttribute = attribute.toESCTextAttribute()
+      if (textAttribute == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "attribute is error"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.printTextAttribute(data, textAttribute)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun printTextAlignment(
+    connectInfo: String,
+    data: String,
+    alignment: String,
+    promise: Promise
+  ) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+      val textAlign = alignment.toESCAlignment()
+      if (textAlign == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "alignment is error"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.printTextAlignment(data, textAlign)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e,
+        )
+      }
+    }
+  }
+
+  override fun printText(
+    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 data = payload.getString("data")
+      if (data == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "data is null"
+        )
+        return@launch
+      }
+      val alignment = payload.getString("alignment")?.toESCAlignment()
+      if (alignment == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "alignment is error"
+        )
+        return@launch
+      }
+
+      val attribute = payload.getString("attribute")?.toESCTextAttribute()
+      if (attribute == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "attribute is error"
+        )
+        return@launch
+      }
+      val textWidth = payload.getString("textWidth")?.toESCTextWidth()
+      if (textWidth == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "textWidth is error"
+        )
+        return@launch
+      }
+      val textHeight = payload.getString("textHeight")?.toESCTextHeight()
+      if (textHeight == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "textHeight is error"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.printText(data, alignment, attribute, textWidth or textHeight)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun printBitmap(
+    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 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 alignment = payload.getString("alignment")?.toESCAlignment()
+      if (alignment == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "alignment is error"
+        )
+        return@launch
+      }
+      val width = payload.getInt("width")
+      val model = payload.getString("model")?.toESCBmpModel()
+      if (model == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "model is error"
+        )
+        return@launch
+      }
+
+      var bitmap: Bitmap? = null
+      try {
+        withContext(Dispatchers.IO) {
+          bitmap = loadAndScaleBitmap(
+            bitmapContent = bitmapContent,
+            bitmapPath = bitmapPath,
+            width = width
+          )
+          printer.printBitmap(bitmap, alignment, width, model)
+        }
+        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 compressionPrintBitmap(
+    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 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 alignment = payload.getString("alignment")?.toESCAlignment()
+      if (alignment == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "alignment is error"
+        )
+        return@launch
+      }
+      val width = payload.getInt("width")
+      val model = payload.getString("model")?.toESCBmpModel()
+      if (model == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "model is error"
+        )
+        return@launch
+      }
+
+      var bitmap: Bitmap? = null
+      try {
+        withContext(Dispatchers.IO) {
+          bitmap = loadAndScaleBitmap(
+            bitmapContent = bitmapContent,
+            bitmapPath = bitmapPath,
+            width = width
+          )
+          printer.printBitmapCompress(
+            bitmap,
+            alignment,
+            width,
+            model
+          )
+        }
+        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 printBarCode(
+    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 data = payload.getString("data")
+      if (data == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "data is null"
+        )
+        return@launch
+      }
+      val codeType = payload.getString("codeType")?.toESCBarcodeType()
+      if (codeType == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "codeType is error"
+        )
+        return@launch
+      }
+      val width = payload.getInt("width")
+      val height = payload.getInt("height")
+      val alignment = payload.getString("alignment")?.toESCAlignment()
+      if (alignment == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "alignment is error"
+        )
+        return@launch
+      }
+      val textPosition = payload.getString("textPosition")?.toESCTextPosition()
+      if (textPosition == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "textPosition is error"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.printBarCode(data, codeType, width, height, alignment, textPosition)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun lineFeed(
+    connectInfo: String,
+    lineCount: 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.feedLine(lineCount.toInt())
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun feedDot(
+    connectInfo: String,
+    dotCount: 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.feedDot(dotCount.toInt())
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun printerCheck(
+    connectInfo: String,
+    type: 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
+      }
+      val checkType = type.toESCPrinterCheckType()
+      if (checkType == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "type is error"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.printerCheck(checkType, timeout.toInt()) { data ->
+            scope.launch {
+              val result = WritableNativeMap()
+
+              val debugArray = WritableNativeArray()
+              if (data.isNotEmpty()) {
+                data.forEach {
+                  debugArray.pushInt(it.toInt())
+                }
+                result.putString(
+                  "status",
+                  data[0].toInt().toESCPrinterCheckStatus()
+                )
+              } else {
+                result.putString("status", (-4).toESCPrinterCheckStatus())
+              }
+              result.putArray("debugArray", debugArray)
+              promise.resolve(result)
+            }
+          }
+        }
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun printerStatus(
+    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.printerStatus { status ->
+            scope.launch {
+              val result = WritableNativeMap()
+              result.putString("status", status.toESCPrinterStatus())
+              result.putInt("debugCode", status)
+              promise.resolve(result)
+            }
+          }
+        }
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun printerStatusII(
+    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.printerStatusII { status ->
+            scope.launch {
+              val result = WritableNativeMap()
+              result.putString("status", status.toESCPrinterStatusII())
+              result.putInt("debugCode", status)
+              promise.resolve(result)
+            }
+          }
+        }
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e,
+        )
+      }
+    }
+  }
+
+  override fun printQRCode(
+    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 data = payload.getString("data")
+      if (data == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "data is null"
+        )
+        return@launch
+      }
+      val moduleSize = payload.getInt("moduleSize")
+      val ecLevel = payload.getString("ecLevel")?.toESCECLevel()
+      if (ecLevel == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "ecLevel is error"
+        )
+        return@launch
+      }
+      val alignment = payload.getString("alignment")?.toESCAlignment()
+      if (alignment == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "alignment is error"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.printQRCode(data, moduleSize, ecLevel, alignment)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun cutPaper(
+    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
+      }
+      val cutModel = model.toESCCutModel()
+      if (cutModel == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "model is error"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.cutPaper(cutModel)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun cutHalfAndFeed(
+    connectInfo: String,
+    distance: 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.cutHalfAndFeed(distance.toInt())
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun setPrintArea(
+    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.setPrintArea(x, y, width, height)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun setPageModel(
+    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.setPageModel(isOpen)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun printPageModelData(
+    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.printPageModelData()
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e,
+        )
+      }
+    }
+  }
+
+  override fun setPrintDirection(
+    connectInfo: String,
+    direction: String,
+    promise: Promise
+  ) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+      val printDirection = direction.toESCDirection()
+      if (printDirection == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "direction is error"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.setPrintDirection(printDirection)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun setAbsoluteHorizontal(
+    connectInfo: String,
+    position: 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.setAbsoluteHorizontal(position.toInt())
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun setRelativeHorizontal(
+    connectInfo: String,
+    position: 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.setRelativeHorizontal(position.toInt())
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e,
+        )
+      }
+    }
+  }
+
+  override fun setAbsoluteVertical(
+    connectInfo: String,
+    position: 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.setAbsoluteVertical(position.toInt())
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun setRelativeVertical(
+    connectInfo: String,
+    position: 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.setRelativeVertical(position.toInt())
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun setTextStyle(
+    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 attribute = payload.getString("attribute")?.toESCTextAttribute()
+      if (attribute == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "attribute is error"
+        )
+        return@launch
+      }
+      val textWidth = payload.getString("textWidth")?.toESCTextWidth()
+      if (textWidth == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "textWidth is error"
+        )
+        return@launch
+      }
+      val textHeight = payload.getString("textHeight")?.toESCTextHeight()
+      if (textHeight == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "textHeight is error"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.setTextStyle(attribute, textWidth or textHeight)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun setAlignment(
+    connectInfo: String,
+    alignment: String,
+    promise: Promise
+  ) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+      val printAlignment = alignment.toESCAlignment()
+      if (printAlignment == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "alignment is error"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.setAlignment(printAlignment)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e,
+        )
+      }
+    }
+  }
+
+  override fun downloadNVImage(
+    connectInfo: String,
+    imagePaths: String,
+    imageWidth: 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.downloadNVImage(imagePaths, imageWidth.toInt())
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun clearNVImage(
+    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.clearNVImage()
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun printNVImage(
+    connectInfo: String,
+    index: Double,
+    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
+      }
+      val bmpModel = model.toESCBmpModel()
+      if (bmpModel == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "model is error"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.printNVImage(index.toInt(), bmpModel)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun selectBitmapModel(
+    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 width = payload.getInt("width")
+      val bitmapPath = payload.getString("bitmapPath")
+      if (bitmapPath == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "bitmapPath is null"
+        )
+        return@launch
+      }
+      val model = payload.getString("model")?.toESCSelectBitmapModel()
+      if (model == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "model is null"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          val bitmap = BitmapFactory.decodeFile(bitmapPath)
+          printer.selectBitmapModel(model, width, bitmap)
+        }
+        promise.resolve(null)
+//            if (!bitmap.isRecycled){
+//                bitmap.recycle()
+//            }
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e,
+        )
+      }
+    }
+  }
+
+  override fun setLineSpacing(
+    connectInfo: String,
+    space: 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.setLineSpacing(if (space.toInt() == DEFAULT_LINE_SPACE) SPACE_DEFAULT else space.toInt())
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun setTurnUpsideDownMode(
+    connectInfo: String,
+    on: 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.setTurnUpsideDownMode(on)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e
+        )
+      }
+    }
+  }
+
+  override fun selectCodePage(
+    connectInfo: String,
+    page: 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.selectCodePage(page.toInt())
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e,
+        )
+      }
+    }
+  }
+
+  override fun selectCharacterFont(
+    connectInfo: String,
+    font: String,
+    promise: Promise
+  ) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+      val fontType = font.toESCFontType()
+      if (fontType == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "font is error"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.selectCharacterFont(fontType)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e,
+        )
+      }
+    }
+  }
+
+  override fun printPDF417(
+    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 data = payload.getString("data")
+      if (data == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "data is null"
+        )
+        return@launch
+      }
+      val cellWidth = payload.getInt("cellWidth")
+      val cellHeightRatio = payload.getInt("cellHeightRatio")
+      val numberOfColumns = payload.getInt("numberOfColumns")
+      val numberOfRows = payload.getInt("numberOfRows")
+      val eclType = payload.getInt("eclType")
+      val eclValue = payload.getInt("eclValue")
+      val alignment = payload.getString("alignment")?.toESCAlignment()
+      if (alignment == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "alignment is error"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.printPDF417(
+            data,
+            cellWidth,
+            cellHeightRatio,
+            numberOfColumns,
+            numberOfRows,
+            eclType,
+            eclValue,
+            alignment
+          )
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e,
+        )
+      }
+    }
+  }
+
+  override fun printTable(
+    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 titles = payload.getArray("titles")
+      val numberOfSingleBytesPerCol =
+        payload.getArray("numberOfSingleBytesPerCol")
+      val align = payload.getArray("align")
+      val titleList = arrayListOf<String>()
+      val numberOfSingleBytesPerColList = arrayListOf<Int>()
+      val alignList = arrayListOf<Int>()
+      if (titles != null) {
+        for (i in 0 until titles.size()) {
+          titleList.add(titles.getString(i) ?: "")
+        }
+      }
+      if (numberOfSingleBytesPerCol != null) {
+        for (i in 0 until numberOfSingleBytesPerCol.size()) {
+          numberOfSingleBytesPerColList.add(numberOfSingleBytesPerCol.getInt(i))
+        }
+      }
+      if (align != null) {
+        for (i in 0 until align.size()) {
+          alignList.add(align.getInt(i))
+        }
+      }
+      val rows = payload.getArray("rows")
+
+      try {
+        val table = PTable(
+          titleList.toTypedArray(),
+          numberOfSingleBytesPerColList.toTypedArray(),
+          alignList.toTypedArray(),
+        )
+        if (rows != null) {
+          for (i in 0 until rows.size()) {
+            val rowMap = rows.getMap(i)
+            val rowTitle = rowMap?.getString("title")
+            val rowData = rowMap?.getString("data")
+            val rowRemark = rowMap?.getString("remark")
+            val rowDataList = arrayListOf<String>()
+            if (rowData != null) {
+              for (j in 0 until rows.size()) {
+                rowDataList.add(rows.getString(j) ?: "")
+              }
+            }
+            val rowBarcode = rowMap?.getMap("barcode")
+            var rowTableBarcode: TableBarcode? = null
+            if (rowBarcode != null) {
+              val rowCodeType = rowBarcode.getString("codeType")?.toESCBarcodeType()
+              if (rowCodeType == null) {
+                promise.reject(
+                  PARAMS_ERROR,
+                  "codeType is error"
+                )
+                return@launch
+              }
+              val rowAlignment = rowBarcode.getString("alignment")?.toESCAlignment()
+              if (rowAlignment == null) {
+                promise.reject(
+                  PARAMS_ERROR,
+                  "alignment is error"
+                )
+                return@launch
+              }
+              val rowTextPosition =
+                rowBarcode.getString("textPosition")?.toESCTextPosition()
+              if (rowTextPosition == null) {
+                promise.reject(
+                  PARAMS_ERROR,
+                  "textPosition is error"
+                )
+                return@launch
+              }
+
+              rowTableBarcode = TableBarcode(
+                rowBarcode.getString("data"),
+                rowCodeType,
+                rowBarcode.getInt("width"),
+                rowBarcode.getInt("height"),
+                rowAlignment,
+                rowTextPosition,
+              )
+            }
+            table.addRow(
+              rowTitle,
+              rowDataList.toTypedArray(),
+              rowRemark,
+              rowTableBarcode
+            )
+          }
+        }
+        withContext(Dispatchers.IO) {
+          printer.printTable(table)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e,
+        )
+      }
+    }
+  }
+
+  override fun wifiConfig(
+    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 ip = payload.getString("ip")?.let { parseAddressData(it) }
+      if (ip == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "ip is null"
+        )
+        return@launch
+      }
+      val mask = payload.getString("mask")?.let { parseAddressData(it) }
+      if (mask == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "mask is null"
+        )
+        return@launch
+      }
+      val gateway = payload.getString("gateway")?.let { parseAddressData(it) }
+      if (gateway == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "gateway is null"
+        )
+        return@launch
+      }
+      val ssid = payload.getString("ssid")
+      if (ssid == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "ssid is null"
+        )
+        return@launch
+      }
+      val password = payload.getString("password")
+      if (password == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "password is null"
+        )
+        return@launch
+      }
+      val encrypt = payload.getString("encrypt")?.toESCWifiEncrypt()
+      if (encrypt == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "encrypt is error"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.wifiConfig(
+            ip,
+            mask,
+            gateway,
+            ssid,
+            password,
+            encrypt
+          )
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e,
+        )
+      }
+    }
+  }
+
+  override fun setIp(
+    connectInfo: String,
+    ip: String,
+    promise: Promise
+  ) {
+    scope.launch {
+      val printer = printers[connectInfo]
+      if (printer == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found printer:${connectInfo}"
+        )
+        return@launch
+      }
+
+      val ipBytes = parseAddressData(ip)
+      if (ipBytes == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "ip is error"
+        )
+        return@launch
+      }
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.setIp(ipBytes)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e,
+        )
+      }
+    }
+  }
+
+  override fun setMask(
+    connectInfo: String,
+    mask: 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.setMask(mask.toByteArray())
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e,
+        )
+      }
+    }
+  }
+
+  override fun setGateway(
+    connectInfo: String,
+    gateway: 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 {
+        printer.setGateway(gateway.toByteArray())
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e,
+        )
+      }
+    }
+  }
+
+  override fun setNetAll(
+    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 ip = payload.getString("ip")?.let { parseAddressData(it) }
+      if (ip == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "ip is null"
+        )
+        return@launch
+      }
+      val mask = payload.getString("mask")?.let { parseAddressData(it) }
+      if (mask == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "mask is null"
+        )
+        return@launch
+      }
+      val gateway = payload.getString("gateway")?.let { parseAddressData(it) }
+      if (gateway == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "gateway is null"
+        )
+        return@launch
+      }
+      val dhcpIsOpen = payload.getBoolean("dhcpIsOpen")
+
+      try {
+        withContext(Dispatchers.IO) {
+          printer.setNetAll(
+            ip,
+            mask,
+            gateway,
+            dhcpIsOpen
+          )
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e,
+        )
+      }
+    }
+  }
+
+  override fun setBluetooth(
+    connectInfo: String,
+    name: String,
+    pin: 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.setBluetooth(
+            name,
+            pin
+          )
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e,
+        )
+      }
+    }
+  }
+
+  override fun getSerialNumber(
+    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.getSerialNumber {
+            scope.launch {
+              val result = WritableNativeMap()
+              result.putString("data", it.toString(Charset.defaultCharset()))
+              promise.resolve(result)
+            }
+          }
+        }
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR,
+          e.message,
+          e,
+        )
+      }
+    }
+  }
+
+  companion object {
+    const val NAME = NativeXPrinterESCSpec.NAME
+  }
+}