@connexup/react-native-xprinter 0.1.0

package/android/src/main/java/com/connexup/xprinter/printer/Convert.kt

@@ -0,0 +1,46 @@
+package com.connexup.xprinter.printer
+
+import android.hardware.usb.UsbDevice
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableNativeMap
+import net.posprinter.POSConnect
+
+/**
+ * Description:
+ * @author lukechen@chancetop.com
+ * @date 2025/1/26
+ */
+
+const val CONNECT_STATUS_DISCONNECT = -999
+
+fun String.toDeviceType(): Int? {
+  return when (this) {
+    "USB" -> POSConnect.DEVICE_TYPE_USB
+    "BLUETOOTH" -> POSConnect.DEVICE_TYPE_SERIAL
+    "ETHERNET" -> POSConnect.DEVICE_TYPE_ETHERNET
+    "SERIAL" -> POSConnect.DEVICE_TYPE_BLUETOOTH
+    else -> null
+  }
+}
+
+fun Int.toConnectionConnectStatus(): String {
+  return when (this) {
+    POSConnect.CONNECT_SUCCESS -> "CONNECT_SUCCESS"
+    POSConnect.CONNECT_FAIL -> "CONNECT_FAIL"
+    POSConnect.SEND_FAIL -> "SEND_FAIL"
+    POSConnect.CONNECT_INTERRUPT -> "CONNECT_INTERRUPT"
+    POSConnect.USB_ATTACHED -> "USB_ATTACHED"
+    POSConnect.USB_DETACHED -> "USB_DETACHED"
+    POSConnect.BLUETOOTH_INTERRUPT -> "BLUETOOTH_INTERRUPT"
+    else -> "UNKNOWN"
+  }
+}
+
+val UsbDevice.readableMap: ReadableMap
+  get() {
+    val result = WritableNativeMap()
+    result.putInt("deviceId", this.deviceId)
+    result.putString("deviceName", this.deviceName)
+    result.putString("manufacturerName", this.manufacturerName)
+    return result
+  }

package/android/src/main/java/com/connexup/xprinter/printer/DeviceConnection.kt

@@ -0,0 +1,14 @@
+package com.connexup.xprinter.printer
+
+import net.posprinter.IDeviceConnection
+
+/**
+ * Description:
+ * @author lukechen@chancetop.com
+ * @date 2026/2/6
+ */
+
+data class DeviceConnection(
+  val connection: IDeviceConnection,
+  val sync: Boolean
+)

package/android/src/main/java/com/connexup/xprinter/printer/Printers.kt

@@ -0,0 +1,153 @@
+package com.connexup.xprinter.printer
+
+import net.posprinter.POSPrinter
+import net.posprinter.TSPLPrinter
+
+/**
+ * Description:
+ * @author lukechen@chancetop.com
+ * @date 2025/1/21
+ */
+
+
+enum class PCL {
+  ESC,
+  TSPL,
+//    CPCL,
+//    ZPL
+}
+
+fun String.toPCLType(): PCL? {
+  return when (this) {
+    "ESC" -> PCL.ESC
+    "TSPL" -> PCL.TSPL
+//        "CPCL" -> PCL.CPCL
+//        "ZPL" -> PCL.ZPL
+    else -> null
+  }
+}
+
+object Printers {
+
+  private val _connections: MutableMap<String, DeviceConnection> by lazy { hashMapOf() }
+  val connections: Map<String, DeviceConnection> get() = _connections
+
+  private val _escPrinters: MutableMap<String, POSPrinter> by lazy {
+    hashMapOf()
+  }
+  val escPrinters: Map<String, POSPrinter> get() = _escPrinters
+
+  private val _tsplPrinters: MutableMap<String, TSPLPrinter> by lazy {
+    hashMapOf()
+  }
+  val tsplPrinters: Map<String, TSPLPrinter> get() = _tsplPrinters
+
+//    private val _cpclPrinters: MutableMap<String, CPCLPrinter> by lazy {
+//        hashMapOf()
+//    }
+//    val cpclPrinters: Map<String, CPCLPrinter> get() = _cpclPrinters
+//
+//    private val _zplPrinters: MutableMap<String, ZPLPrinter> by lazy {
+//        hashMapOf()
+//    }
+//    val zplPrinters: Map<String, ZPLPrinter> get() = _zplPrinters
+
+  private val allPrinters by lazy {
+//        arrayOf(_escPrinters, _tsplPrinters, _cpclPrinters, _zplPrinters)
+    arrayOf(_escPrinters, _tsplPrinters)
+  }
+
+  fun cleanup() {
+    val allConnections = connections.entries
+    allPrinters.forEach {
+      it.clear()
+    }
+    _connections.clear()
+    allConnections.forEach {
+      try {
+        it.value.connection.close()
+      } catch (_: Exception) {
+      }
+    }
+  }
+
+  fun setConnection(connectInfo: String, connection: DeviceConnection) {
+    _connections[connectInfo] = connection
+  }
+
+  fun removeConnection(connectInfo: String) {
+    removePrinter(connectInfo)
+    _connections.remove(connectInfo)
+  }
+
+  fun setupPrinter(connectInfo: String, pcl: PCL) {
+    removePrinter(connectInfo, pcl)
+    addPrinter(connectInfo, pcl)
+  }
+
+  fun getPrinterPCL(connectInfo: String): PCL? {
+    if (!escPrinters.containsKey(connectInfo)) {
+      return PCL.ESC
+    }
+    if (!tsplPrinters.containsKey(connectInfo)) {
+      return PCL.TSPL
+    }
+    return null
+  }
+
+  private fun addPrinter(
+    connectInfo: String,
+    pcl: PCL,
+  ) {
+
+    val connection = connections[connectInfo] ?: return
+    when (pcl) {
+      PCL.ESC -> {
+        if (!escPrinters.containsKey(connectInfo)) {
+          _escPrinters[connectInfo] = POSPrinter(connection.connection)
+        }
+      }
+
+      PCL.TSPL -> {
+        if (!tsplPrinters.containsKey(connectInfo)) {
+          _tsplPrinters[connectInfo] = TSPLPrinter(connection.connection)
+        }
+      }
+
+//            PCL.CPCL -> {
+//                if (!cpclPrinters.containsKey(connectInfo)) {
+//                    _cpclPrinters[connectInfo] = CPCLPrinter(connection)
+//                }
+//            }
+//
+//            PCL.ZPL -> {
+//                if (!zplPrinters.containsKey(connectInfo)) {
+//                    _zplPrinters[connectInfo] = ZPLPrinter(connection)
+//                }
+//            }
+    }
+  }
+
+  private fun removePrinter(
+    connectInfo: String,
+    skipPCL: PCL? = null,
+  ) {
+    val printers = if (skipPCL == null) {
+      null
+    } else {
+      getPrintersByPCL(skipPCL)
+    }
+    allPrinters.forEach {
+      if (it != printers) {
+        it.remove(connectInfo)
+      }
+    }
+  }
+
+  private fun getPrintersByPCL(pcl: PCL) = when (pcl) {
+    PCL.ESC -> escPrinters
+    PCL.TSPL -> tsplPrinters
+//        PCL.CPCL -> cpclPrinters
+//        PCL.ZPL -> zplPrinters
+  }
+}

package/android/src/main/java/com/connexup/xprinter/printer/XPrinterPrinterModule.kt

@@ -0,0 +1,295 @@
+package com.connexup.xprinter.printer
+
+import com.connexup.xprinter.COMMON_ERROR
+import com.connexup.xprinter.NativeXPrinterPrinterSpec
+import com.connexup.xprinter.PARAMS_ERROR
+import com.connexup.xprinter.PRINTER_NOT_FOUND_ERROR
+import com.connexup.xprinter.parseAddressData
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+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.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import net.posprinter.POSConnect
+import net.posprinter.POSPrinter
+import net.posprinter.model.UdpDevice
+
+/**
+ * Description:
+ * @author lukechen@chancetop.com
+ * @date 2026/2/6
+ */
+class XPrinterPrinterModule(reactContext: ReactApplicationContext) :
+  NativeXPrinterPrinterSpec(reactContext) {
+
+  private val scope: CoroutineScope by lazy {
+    CoroutineScope(
+      SupervisorJob() + Dispatchers.Main
+    )
+  }
+
+  override fun initialize() {
+    super.initialize()
+    POSConnect.init(reactApplicationContext)
+  }
+
+  override fun invalidate() {
+    super.invalidate()
+    Printers.cleanup()
+  }
+
+
+  override fun getUsbDevices(promise: Promise) {
+    scope.launch {
+      val context = reactApplicationContextIfActiveOrWarn
+      if (context == null) {
+        promise.reject(
+          COMMON_ERROR, "context is null"
+        )
+        return@launch
+      }
+      val result = WritableNativeMap()
+      val data = WritableNativeArray()
+      try {
+        val devices = withContext(Dispatchers.IO) {
+          POSConnect.getUsbDevice(context)
+        }
+        if (devices !== null) {
+          devices.forEach {
+            data.pushMap(it.readableMap)
+          }
+        }
+        result.putArray("data", data)
+        promise.resolve(result)
+      } catch (e: Exception) {
+        promise.reject(
+          COMMON_ERROR, e.message, e
+        )
+      }
+    }
+  }
+
+  override fun searchNetDevice(promise: Promise) {
+    scope.launch {
+      try {
+        withContext(Dispatchers.IO) {
+          POSPrinter.searchNetDevice { device ->
+            scope.launch {
+              sendSearchNetDeviceEvent(device)
+            }
+          }
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(COMMON_ERROR, e.message, e)
+      }
+    }
+  }
+
+  override fun udpNetConfig(
+    request: ReadableMap,
+    promise: Promise
+  ) {
+    scope.launch {
+      try {
+        val macAddress = request.getString("macAddress")?.let { parseAddressData(it) }
+        if (macAddress == null) {
+          promise.reject(PARAMS_ERROR, "macAddress is error")
+          return@launch
+        }
+        val ipAddress = request.getString("ipAddress")?.let { parseAddressData(it) }
+        if (ipAddress == null) {
+          promise.reject(PARAMS_ERROR, "ipAddress is error")
+          return@launch
+        }
+        val mask = request.getString("mask")?.let { parseAddressData(it) }
+        if (mask == null) {
+          promise.reject(PARAMS_ERROR, "mask is error")
+          return@launch
+        }
+        val gateway = request.getString("gateway")?.let { parseAddressData(it) }
+        if (gateway == null) {
+          promise.reject(PARAMS_ERROR, "gateway is error")
+          return@launch
+        }
+        val dhcp = request.getBoolean("dhcp")
+        withContext(Dispatchers.IO) {
+          POSPrinter.udpNetConfig(macAddress, ipAddress, mask, gateway, dhcp)
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(COMMON_ERROR, e.message, e)
+      }
+    }
+  }
+
+  override fun connect(
+    connectInfo: String,
+    deviceType: String,
+    sync: Boolean,
+    promise: Promise
+  ) {
+    scope.launch {
+      val convertDeviceType = deviceType.toDeviceType()
+      if (convertDeviceType == null) {
+        promise.reject(PARAMS_ERROR, "deviceType error")
+        return@launch
+      }
+      try {
+        val device = POSConnect.createDevice(convertDeviceType)
+        val connection = DeviceConnection(device, sync)
+        if (sync) {
+          val isConnect = withContext(Dispatchers.IO) {
+            device.connectSync(connectInfo) { code, connectInfo, msg ->
+              scope.launch {
+                if (code == POSConnect.CONNECT_SUCCESS) {
+                  Printers.setConnection(connectInfo, connection)
+                }
+                sendDeviceConnectStatusChangeEvent(code, connectInfo, msg)
+              }
+            }
+          }
+          if (!isConnect) {
+            promise.reject(COMMON_ERROR, "connect fail")
+            return@launch
+          }
+        } else {
+          device.connect(connectInfo) { code, connectInfo, msg ->
+            if (code == POSConnect.CONNECT_SUCCESS) {
+              Printers.setConnection(connectInfo, connection)
+            }
+            sendDeviceConnectStatusChangeEvent(code, connectInfo, msg)
+          }
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(COMMON_ERROR, e.message, e)
+      }
+    }
+  }
+
+  override fun disconnect(
+    connectInfo: String, promise: Promise
+  ) {
+    scope.launch {
+      try {
+        val device = Printers.connections[connectInfo]
+        if (device == null) {
+          promise.resolve(null)
+          return@launch
+        }
+        var error: Exception? = null
+        withContext(Dispatchers.IO) {
+          if (device.sync) {
+            try {
+              device.connection.closeSync()
+              delay(12)
+            } catch (e: Exception) {
+              error = e
+            }
+          } else {
+            device.connection.close()
+          }
+        }
+        Printers.removeConnection(connectInfo)
+        sendDeviceConnectStatusChangeEvent(
+          CONNECT_STATUS_DISCONNECT,
+          connectInfo,
+          null
+        )
+        if (error != null) {
+          throw error
+        }
+        promise.resolve(null)
+      } catch (e: Exception) {
+        promise.reject(COMMON_ERROR, e.message, e)
+      }
+    }
+  }
+
+  override fun isConnect(connectInfo: String, promise: Promise) {
+    scope.launch {
+      val device = Printers.connections[connectInfo]
+      if (device == null) {
+        promise.resolve(false)
+        return@launch
+      }
+      val isConnect = withContext(Dispatchers.IO) {
+        device.connection.isConnect
+      }
+      promise.resolve(isConnect)
+    }
+  }
+
+  override fun getPrinterPCL(
+    connectInfo: String,
+    promise: Promise
+  ) {
+    scope.launch {
+      promise.resolve(Printers.getPrinterPCL(connectInfo)?.name)
+    }
+  }
+
+  override fun setPrinterPCL(
+    connectInfo: String,
+    pcl: String,
+    promise: Promise
+  ) {
+    scope.launch {
+      val device = Printers.connections[connectInfo]
+      if (device == null) {
+        promise.reject(
+          PRINTER_NOT_FOUND_ERROR,
+          "not found device connectInfo:${connectInfo}"
+        )
+        return@launch
+      }
+      val pclType = pcl.toPCLType()
+      if (pclType == null) {
+        promise.reject(
+          PARAMS_ERROR,
+          "pclType is error"
+        )
+        return@launch
+      }
+      Printers.setupPrinter(connectInfo, pclType)
+      promise.resolve(null)
+    }
+  }
+
+  private fun sendDeviceConnectStatusChangeEvent(
+    code: Int,
+    connectInfo: String,
+    msg: String?
+  ) {
+    val result: WritableMap = WritableNativeMap()
+    result.putString("code", code.toConnectionConnectStatus())
+    result.putInt("debugCode", code)
+    result.putString("connectInfo", connectInfo)
+    result.putString("msg", msg)
+    emitOnDeviceConnectStatusChange(result)
+  }
+
+  private fun sendSearchNetDeviceEvent(
+    device: UdpDevice
+  ) {
+    val result: WritableMap = WritableNativeMap()
+    result.putString("macAddress", device.macStr)
+    result.putString("ipAddress", device.ipStr)
+    result.putString("mask", device.maskStr)
+    result.putString("gateway", device.gatewayStr)
+    result.putBoolean("dhcp", device.isDhcp)
+    emitOnSearchNetDeviceFound(result)
+  }
+
+  companion object {
+    const val NAME = NativeXPrinterPrinterSpec.NAME
+  }
+}

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

@@ -0,0 +1,151 @@
+package com.connexup.xprinter.tspl
+
+import net.posprinter.TSPLConst
+import net.posprinter.model.AlgorithmType
+
+/**
+ * Description:
+ * @author lukechen@chancetop.com
+ * @date 2025/7/10
+ */
+
+fun String.toTSPLDirection(): Int? {
+    return when (this) {
+        "DIRECTION_FORWARD" -> TSPLConst.DIRECTION_FORWARD
+        "DIRECTION_REVERSE" -> TSPLConst.DIRECTION_REVERSE
+        else -> null
+    }
+}
+
+fun String.toTSPLBarcodeType(): String? {
+    return when (this) {
+        "CODE_TYPE_128" -> TSPLConst.CODE_TYPE_128
+        "CODE_TYPE_128M" -> TSPLConst.CODE_TYPE_128M
+        "CODE_TYPE_EAN128" -> TSPLConst.CODE_TYPE_EAN128
+        "CODE_TYPE_25" -> TSPLConst.CODE_TYPE_25
+        "CODE_TYPE_25C" -> TSPLConst.CODE_TYPE_25C
+        "CODE_TYPE_39" -> TSPLConst.CODE_TYPE_39
+        "CODE_TYPE_39C" -> TSPLConst.CODE_TYPE_39C
+        "CODE_TYPE_93" -> TSPLConst.CODE_TYPE_93
+        "CODE_TYPE_EAN13" -> TSPLConst.CODE_TYPE_EAN13
+        "CODE_TYPE_EAN13_2" -> TSPLConst.CODE_TYPE_EAN13_2
+        "CODE_TYPE_EAN13_5" -> TSPLConst.CODE_TYPE_EAN13_5
+        "CODE_TYPE_EAN8" -> TSPLConst.CODE_TYPE_EAN8
+        "CODE_TYPE_EAN8_2" -> TSPLConst.CODE_TYPE_EAN8_2
+        "CODE_TYPE_EAN8_5" -> TSPLConst.CODE_TYPE_EAN8_5
+        "CODE_TYPE_CODA" -> TSPLConst.CODE_TYPE_CODA
+        "CODE_TYPE_POST" -> TSPLConst.CODE_TYPE_POST
+        "CODE_TYPE_UPCA" -> TSPLConst.CODE_TYPE_UPCA
+        "CODE_TYPE_UPCA_2" -> TSPLConst.CODE_TYPE_UPCA_2
+        "CODE_TYPE_UPCA_5" -> TSPLConst.CODE_TYPE_UPCA_5
+        "CODE_TYPE_UPCE" -> TSPLConst.CODE_TYPE_UPCE
+        "CODE_TYPE_UPCE_2" -> TSPLConst.CODE_TYPE_UPCE_2
+        "CODE_TYPE_UPCE_5" -> TSPLConst.CODE_TYPE_UPCE_5
+        "CODE_TYPE_CPOST" -> TSPLConst.CODE_TYPE_CPOST
+        "CODE_TYPE_MSI" -> TSPLConst.CODE_TYPE_MSI
+        "CODE_TYPE_MSIC" -> TSPLConst.CODE_TYPE_MSIC
+        "CODE_TYPE_PLESSEY" -> TSPLConst.CODE_TYPE_PLESSEY
+        "CODE_TYPE_ITF14" -> TSPLConst.CODE_TYPE_ITF14
+        "CODE_TYPE_EAN14" -> TSPLConst.CODE_TYPE_EAN14
+        "CODE_TYPE_11" -> TSPLConst.CODE_TYPE_11
+        "CODE_TYPE_TELEPEN" -> TSPLConst.CODE_TYPE_TELEPEN
+        "CODE_TYPE_TELEPENN" -> TSPLConst.CODE_TYPE_TELEPENN
+        "CODE_TYPE_PLANET" -> TSPLConst.CODE_TYPE_PLANET
+        "CODE_TYPE_CODE49" -> TSPLConst.CODE_TYPE_CODE49
+        "CODE_TYPE_DPI" -> TSPLConst.CODE_TYPE_DPI
+        "CODE_TYPE_DPL" -> TSPLConst.CODE_TYPE_DPL
+        else -> null
+    }
+}
+
+fun String.toTSPLReadable(): Int? {
+    return when (this) {
+        "READABLE_NONE" -> TSPLConst.READABLE_NONE
+        "READABLE_LEFT" -> TSPLConst.READABLE_LEFT
+        "READABLE_CENTER" -> TSPLConst.READABLE_CENTER
+        "READABLE_RIGHT" -> TSPLConst.READABLE_RIGHT
+        else -> null
+    }
+}
+
+fun String.toTSPLRotation(): Int? {
+    return when (this) {
+        "ROTATION_0" -> TSPLConst.ROTATION_0
+        "ROTATION_90" -> TSPLConst.ROTATION_90
+        "ROTATION_180" -> TSPLConst.ROTATION_180
+        "ROTATION_270" -> TSPLConst.ROTATION_270
+        else -> null
+    }
+}
+
+fun String.toTSPLFont(): String? {
+    return when (this) {
+        "FNT_8_12" -> TSPLConst.FNT_8_12
+        "FNT_12_20" -> TSPLConst.FNT_12_20
+        "FNT_16_24" -> TSPLConst.FNT_16_24
+        "FNT_24_32" -> TSPLConst.FNT_24_32
+        "FNT_32_48" -> TSPLConst.FNT_32_48
+        "FNT_14_19" -> TSPLConst.FNT_14_19
+        "FNT_14_25" -> TSPLConst.FNT_14_25
+        "FNT_21_27" -> TSPLConst.FNT_21_27
+        "FNT_SIMPLIFIED_CHINESE" -> TSPLConst.FNT_SIMPLIFIED_CHINESE
+        "FNT_TRADITIONAL_CHINESE" -> TSPLConst.FNT_TRADITIONAL_CHINESE
+        "FNT_KOREAN" -> TSPLConst.FNT_KOREAN
+        else -> null
+    }
+}
+
+fun String.toTSPLECLevel(): String? {
+    return when (this) {
+        "EC_LEVEL_L" -> TSPLConst.EC_LEVEL_L
+        "EC_LEVEL_M" -> TSPLConst.EC_LEVEL_M
+        "EC_LEVEL_Q" -> TSPLConst.EC_LEVEL_Q
+        "EC_LEVEL_H" -> TSPLConst.EC_LEVEL_H
+        else -> null
+    }
+}
+
+fun String.toTSPLQrcodeMode(): String? {
+    return when (this) {
+        "QRCODE_MODE_AUTO" -> TSPLConst.QRCODE_MODE_AUTO
+        "QRCODE_MODE_MANUAL" -> TSPLConst.QRCODE_MODE_MANUAL
+        else -> null
+    }
+}
+
+fun String.toTSPLQrcodeModel(): String? {
+    return when (this) {
+        "QRCODE_MODEL_M1" -> TSPLConst.QRCODE_MODEL_M1
+        "QRCODE_MODEL_M2" -> TSPLConst.QRCODE_MODEL_M2
+        else -> null
+    }
+}
+
+fun String.toTSPLBitmapMode(): Int? {
+    return when (this) {
+        "BMP_MODE_OVERWRITE" -> TSPLConst.BMP_MODE_OVERWRITE
+        "BMP_MODE_OR" -> TSPLConst.BMP_MODE_OR
+        "BMP_MODE_XOR" -> TSPLConst.BMP_MODE_XOR
+        else -> null
+    }
+}
+
+fun String.toTSPLBitmapCompressionMode(): Int? {
+    return when (this) {
+        "BMP_MODE_OVERWRITE_C" -> TSPLConst.BMP_MODE_OVERWRITE_C
+        "BMP_MODE_OR_C" -> TSPLConst.BMP_MODE_OR_C
+        "BMP_MODE_XOR_C" -> TSPLConst.BMP_MODE_XOR_C
+        else -> null
+    }
+}
+
+fun String.toTSPLBitmapAlgorithmType(): AlgorithmType? {
+    return when (this) {
+        "THRESHOLD" -> AlgorithmType.Threshold
+        "DITHERING" -> AlgorithmType.Dithering
+        "NONE" -> AlgorithmType.None
+        "DIFFUSION" -> AlgorithmType.Diffusion
+        "HALFTONE" -> AlgorithmType.Halftone
+        else -> null
+    }
+}