@connexup/react-native-xprinter 0.1.0

package/ios/ESC/NativeXPrinterESC.swift

@@ -0,0 +1,1339 @@
+//
+//  RTNEscPrintModule.swift
+//  Created by chancetio on 2025/1/24.
+//
+
+import Foundation
+
+@objcMembers
+public class NativeXPrinterESC: NSObject {
+  
+  public func clearNVImage(connectInfo: String, completion: @escaping (_ error: NativeErrorInfo?) -> Void){
+    DispatchQueue.main.async {
+      completion(NativeErrorInfo(code: PrinterErrors.NOT_YET_IMPLEMENTED_ERROR, message: "Not yet implemented", error: nil))
+    }
+  }
+  
+  public func selectInternationCharacterSets(connectInfo: String, n: String, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+                          message: "not found printer:\(connectInfo)", error: nil)
+        )
+        return
+      }
+      guard let convertN = n.toESCInternationCharacterSet() else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "n is error",
+            error: nil
+          )
+        )
+        return
+      }
+
+      printer.writeCommand(with: POSCommand.selectInternationCharacterSets(convertN))
+      completion(nil)
+    }
+  }
+
+  public func isConnect(connectInfo: String, resolve: @escaping (_ value: [String: Any]) -> Void, reject: @escaping (_ error: NativeErrorInfo) -> Void) {
+    DispatchQueue.main.async {
+      var status = false
+      if let printer = Printers.shared.getPrinter(connectInfo: connectInfo) {
+        status = printer.isConnect()
+      } else {
+        status = false
+      }
+      var result: [String: Any] = [:]
+      result["status"] = status
+      resolve(result)
+    }
+  }
+
+  public func initializePrinter(connectInfo: String, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+      printer.writeCommand(with: POSCommand.initializePrinter())
+      completion(nil)
+    }
+  }
+
+  public func setCharSet(connectInfo: String, charSet: String, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+      guard let charSet = charSet.toCharSet() else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "charSet is error",
+            error: nil
+          )
+        )
+        return
+      }
+
+      printer.charSet = charSet
+      completion(nil)
+    }
+  }
+
+  public func printString(connectInfo: String, data: String, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+      guard let data = data.data(using: printer.charSet) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "data is error",
+            error: nil
+          )
+        )
+        return
+      }
+      printer.writeCommand(with: data)
+      completion(nil)
+    }
+  }
+
+  public func printTextSize(connectInfo: String, payload: RCTESCPrintTextSizeRequest, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+      guard let textWidth = payload.textWidth.toESCTextWidth() else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "textWidth is error",
+            error: nil
+          )
+        )
+        return
+      }
+      guard let textHeight = payload.textHeight.toESCTextHeight() else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "textHeight is error",
+            error: nil
+          )
+        )
+        return
+      }
+
+      printer.writeCommand(with: POSCommand.printTextSize(payload.data, textWid: textWidth, textHei: textHeight))
+      completion(nil)
+    }
+  }
+
+  public func printTextAttribute(connectInfo: String, data: String, attribute: String, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+      guard let attribute = attribute.toESCTextAttribute() else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "attribute is error",
+            error: nil
+          )
+        )
+        return
+      }
+
+      printer.writeCommand(with: POSCommand.printTextAttribute(data, attribute: attribute))
+      completion(nil)
+    }
+  }
+
+  public func printTextAlignment(connectInfo: String, data: String, alignment: String, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+      guard let alignment = alignment.toESCAlignment() else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "alignment is error",
+            error: nil
+          )
+        )
+        return
+      }
+
+      printer.writeCommand(with: POSCommand.printTextAlignment(data, alignment: alignment))
+      completion(nil)
+    }
+  }
+
+  public func printText(connectInfo: String, payload: RCTESCPrintTextRequest, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+      guard let alignment = payload.alignment.toESCAlignment() else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "alignment is error",
+            error: nil
+          )
+        )
+        return
+      }
+      guard let attribute = payload.attribute.toESCTextAttribute() else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "attribute is error",
+            error: nil
+          )
+        )
+        return
+      }
+      guard let textWidth = payload.textWidth.toESCTextWidth() else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "textWidth is error",
+            error: nil
+          )
+        )
+        return
+      }
+      guard let textHeight = payload.textHeight.toESCTextHeight() else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "textHeight is error",
+            error: nil
+          )
+        )
+        return
+      }
+
+      printer.writeCommand(with: POSCommand.printText(payload.data, alignment: alignment, attribute: attribute, textWid: textWidth, textHei: textHeight))
+      completion(nil)
+    }
+  }
+
+  public func printBitmap(connectInfo: String, payload: RCTESCPrintBitmapRequest, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+
+      guard let image = Utils.loadAndScaleBitmap(bitmapContent: payload.bitmapContent, bitmapPath: payload.bitmapPath, width: Int(payload.width)) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "bitmap is error",
+            error: nil
+          )
+        )
+        return
+      }
+
+      guard let alignment = payload.alignment.toESCAlignment() else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "alignment is error",
+            error: nil
+          )
+        )
+        return
+      }
+
+      guard let model = payload.model.toESCBmpModel() else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "model is error",
+            error: nil
+          )
+        )
+        return
+      }
+
+      guard let bmpType = payload.type?.toESCBmpType() else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "type is error",
+            error: nil
+          )
+        )
+        return
+      }
+
+      var comand = Data()
+      comand.append(POSCommand.selectAlignment(alignment))
+      comand.append(POSCommand.printRasteBmp(withM: model, andImage: image, andType: bmpType))
+      printer.writeCommand(with: comand)
+      completion(nil)
+    }
+  }
+
+  public func compressionPrintBitmap(connectInfo: String, payload: RCTESCPrintBitmapRequest, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+
+      guard let image = Utils.loadAndScaleBitmap(bitmapContent: payload.bitmapContent, bitmapPath: payload.bitmapPath, width: Int(payload.width)) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "bitmap is error",
+            error: nil
+          )
+        )
+        return
+      }
+
+      guard let alignment = payload.alignment.toESCAlignment() else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "alignment is error",
+            error: nil
+          )
+        )
+        return
+      }
+
+      guard let model = payload.model.toESCBmpModel() else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "model is error",
+            error: nil
+          )
+        )
+        return
+      }
+      guard let bmpType = payload.type?.toESCBmpType() else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "type is error",
+            error: nil
+          )
+        )
+        return
+      }
+
+      var data = Data()
+      data.append(POSCommand.selectAlignment(alignment))
+      data.append(POSCommand.compressionPrintBmp(withM: model, andImage: image, andType: bmpType))
+      printer.writeCommand(with: data)
+      completion(nil)
+    }
+  }
+
+  public func printBarCode(connectInfo: String, payload: RCTESCPrintBarCodeRequest, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+      guard let codeType = payload.codeType.toESCBarCodeType() else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "codeType is error",
+            error: nil
+          )
+        )
+        return
+      }
+      guard let alignment = payload.alignment.toESCAlignment() else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "alignment is error",
+            error: nil
+          )
+        )
+        return
+      }
+      guard let textPosition = payload.textPosition.toESCTextPosition() else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "textPosition is error",
+            error: nil
+          )
+        )
+        return
+      }
+
+      var command = Data()
+      command.append(POSCommand.setBarcodeWidth(Int32(payload.width)))
+      command.append(POSCommand.setBarcodeHeight(Int32(payload.height)))
+      command.append(POSCommand.selectAlignment(alignment))
+      command.append(POSCommand.selectHRICharactersPrintPosition(textPosition))
+      command.append(POSCommand.printBarcode(withM: codeType, andContent: payload.data, useEnCodeing: printer.charSet.rawValue))
+      printer.writeCommand(with: command)
+      completion(nil)
+    }
+  }
+
+  public func lineFeed(connectInfo: String, lineCount: Double, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+
+      printer.writeCommand(with: POSCommand.printAndFeed(Int32(lineCount)))
+      completion(nil)
+    }
+  }
+
+  public func feedDot(connectInfo: String, dotCount: Double, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+
+      printer.writeCommand(with: POSCommand.printAndFeedForwardWhitN(Int32(dotCount)))
+      completion(nil)
+    }
+  }
+
+  public func printerCheck(connectInfo: String, type: String, timeout: Double, resolve: @escaping (_ value: [String: Any]) -> Void, reject: @escaping (_ error: NativeErrorInfo) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        reject(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+      guard let type = type.toESCPrinterCheckType() else {
+        reject(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "type is error",
+            error: nil
+          )
+        )
+        return
+      }
+
+      printer.printerCheck(type: type) { data in
+        var status = "UNKNOWN"
+        if let data = data {
+          if let firstByte = data.first {
+            switch Int(firstByte) {
+            case -2:
+              status = "START_READ_LOOP_RETURN"
+            case -3:
+              status = "DISCONNECT"
+            case -4:
+              status = "TIMEOUT"
+            default:
+              break
+            }
+          } else {
+            status = "TIMEOUT"
+          }
+        }
+        var result: [String: Any] = [:]
+        result["status"] = status
+        resolve(result)
+      }
+    }
+  }
+
+  public func printerStatus(connectInfo: String, resolve: @escaping (_ value: [String: Any]) -> Void, reject: @escaping (_ error: NativeErrorInfo) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        reject(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+
+      printer.printerStatus { data in
+        var status = "UNKNOWN"
+        var debugCode: Int?
+        if let data = data {
+          if let firstByte = data.first {
+            debugCode = Int(firstByte)
+            switch debugCode {
+            case 0x12:
+              status = "NORMAL"
+            case 0x16:
+              status = "COVER_OPEN"
+            case 0x32:
+              status = "PAPER_EMPTY"
+            case 0x36:
+              status = "COVER_OPEN_AND_PAPER_EMPTY"
+            case 0x1a:
+              status = "PRESS_FEED"
+            default:
+              status = "OTHER_ERROR"
+            }
+          }
+        }
+        var result: [String: Any] = [:]
+        result["status"] = status
+        result["debugCode"] = status
+        resolve(result)
+      }
+    }
+  }
+  
+  public func printerStatusII(connectInfo: String, resolve: @escaping (_ value: [String: Any]) -> Void, reject: @escaping (_ error: NativeErrorInfo) -> Void) {
+    DispatchQueue.main.async {
+      reject(NativeErrorInfo(code: PrinterErrors.NOT_YET_IMPLEMENTED_ERROR, message: "Not yet implemented", error: nil))
+    }
+  }
+
+  public func printQRCode(connectInfo: String, payload: RCTESCPrintQRCodeRequest, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+
+      guard let ecLevel = payload.ecLevel.toESCECLevel() else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "ecLevel is error",
+            error: nil
+          )
+        )
+        return
+      }
+
+      guard let alignment = payload.alignment.toESCAlignment() else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "alignment is error",
+            error: nil
+          )
+        )
+        return
+      }
+
+      printer.writeCommand(with: POSCommand.printQRCode(Int32(payload.moduleSize), level: ecLevel, code: payload.data, useEnCodeing: printer.charSet.rawValue))
+      completion(nil)
+    }
+  }
+
+  public func cutPaper(connectInfo: String, model: String, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+      guard let model = model.toESCCutModel() else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "alignment is error",
+            error: nil
+          )
+        )
+        return
+      }
+
+      printer.writeCommand(with: POSCommand.selectCutPageModelAndCutpage(model))
+      completion(nil)
+    }
+  }
+
+  public func cutHalfAndFeed(connectInfo: String, distance: Double, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+
+      printer.writeCommand(with: POSCommand.selectCutPageModelAndCutpage(withM: 66, andN: Int32(distance)))
+      completion(nil)
+    }
+  }
+
+  public func setPrintArea(connectInfo: String, payload: RCTESCSetPrintAreaRequest, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+
+      let x = Int32(payload.x)
+      let y = Int32(payload.y)
+      let width = Int32(payload.width)
+      let height = Int32(payload.height)
+
+      let xL = x % 256
+      var xH = x / 256
+      if xH > 255 {
+        xH = 255
+      }
+
+      let yL = y % 256
+      var yH = y / 256
+      if yH > 255 {
+        yH = 255
+      }
+
+      var dxH = width / 256
+      if dxH > 255 {
+        dxH = 255
+      }
+
+      var dyH = height / 256
+      if dyH > 255 {
+        dyH = 255
+      }
+
+      printer.writeCommand(with: POSCommand.setPrintAreaUnderPageModelWithxL(xL, andxH: xH, andyL: yL, andyH: yH, anddxL: width % 256, anddxH: dxH, anddyL: height % 256, anddyH: dyH))
+      completion(nil)
+    }
+  }
+
+  public func setPageModel(connectInfo: String, isOpen: Bool, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+
+      if isOpen {
+        printer.writeCommand(with: POSCommand.selectPagemode())
+      } else {
+        printer.writeCommand(with: POSCommand.selectStabdardMode())
+      }
+      completion(nil)
+    }
+  }
+
+  public func printPageModelData(connectInfo: String, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+
+      printer.writeCommand(with: POSCommand.printUnderPageModel())
+      completion(nil)
+    }
+  }
+
+  public func setPrintDirection(connectInfo: String, direction: String, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+
+      guard let direction = direction.toESCDirection() else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "direction is error",
+            error: nil
+          )
+        )
+        return
+      }
+
+      printer.writeCommand(with: POSCommand.selectPrintDirectionUnderPageMode(direction))
+      completion(nil)
+    }
+  }
+
+  public func setAbsoluteHorizontal(connectInfo: String, position: Double, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+      var nH = Int32(position) / 256
+      if nH > 255 {
+        nH = 255
+      }
+
+      printer.writeCommand(with: POSCommand.setAbsolutePrintPositionWithNL(Int32(position) % 256, andNH: nH))
+      completion(nil)
+    }
+  }
+
+  public func setRelativeHorizontal(connectInfo: String, position: Double, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+      var nH = Int32(position) / 256
+      if nH > 255 {
+        nH = 255
+      }
+
+      printer.writeCommand(with: POSCommand.setRelativeHorizontalPrintPositionWithnL(Int32(position) % 256, andnH: nH))
+      completion(nil)
+    }
+  }
+
+  public func setAbsoluteVertical(connectInfo: String, position: Double, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+      var nH = Int32(position) / 256
+      if nH > 255 {
+        nH = 255
+      }
+
+      printer.writeCommand(with: POSCommand.setAbsolutePositionUnderPageModelWithnL(Int32(position) % 256, andnH: nH))
+      completion(nil)
+    }
+  }
+
+  public func setRelativeVertical(connectInfo: String, position: Double, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+      var nH = Int32(position) / 256
+      if nH > 255 {
+        nH = 255
+      }
+
+      printer.writeCommand(with: POSCommand.setVertivalRelativePositionUnderPageModelWithNL(Int32(position) % 256, andNH: nH))
+      completion(nil)
+    }
+  }
+
+  public func setTextStyle(connectInfo: String, payload: RCTESCSetTextStyleRequest, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+      guard let attribute = payload.attribute.toESCTextAttribute() else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "attribute is error",
+            error: nil
+          )
+        )
+        return
+      }
+      guard let textWidth = payload.textWidth.toESCTextWidth() else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "textWidth is error",
+            error: nil
+          )
+        )
+        return
+      }
+      guard let textHeight = payload.textHeight.toESCTextHeight() else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "textHeight is error",
+            error: nil
+          )
+        )
+        return
+      }
+
+      var command = Data()
+      command.append(POSCommand.setTextSize(textWidth, height: textHeight))
+//      command.append(POSCommand.printTextAttribute(<#T##data: String!##String!#>, attribute: <#T##Int32#>)(textWidth, height: textHeight))
+      printer.writeCommand(with: command)
+      completion(nil)
+    }
+  }
+
+  public func setAlignment(connectInfo: String, alignment: String, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+      guard let alignment = alignment.toESCAlignment() else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "alignment is error",
+            error: nil
+          )
+        )
+        return
+      }
+
+      printer.writeCommand(with: POSCommand.selectAlignment(alignment))
+      completion(nil)
+    }
+  }
+
+  public func downloadNVImage(connectInfo: String, imagePaths: String, imageWidth: Double, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+
+      let imagePathList = imagePaths.components(separatedBy: ",")
+      var command = Data()
+      for (index, imagePath) in imagePathList.enumerated() {
+        guard let image = UIImage(contentsOfFile: imagePath) else {
+          completion(
+            NativeErrorInfo(
+              code: PrinterErrors.PARAMS_ERROR,
+              message: "imagePath error: \(imagePath)",
+              error: nil
+            )
+          )
+          return
+        }
+        command.append(POSCommand.definedFlashBmp(withN: Int32(index), andBmp: image, andBmpType: Dithering, andPrint: RasterNolmorWH, andPaperHeight: Int32(imageWidth)))
+      }
+      printer.writeCommand(with: command)
+      completion(nil)
+    }
+  }
+
+  public func printNVImage(connectInfo: String, index: Double, model: String, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+      guard let model = model.toESCBmpModel() else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "model is error",
+            error: nil
+          )
+        )
+        return
+      }
+
+      printer.writeCommand(with: POSCommand.printBmpInFLASH(withN: Int32(index), andM: Int32(model.rawValue)))
+      completion(nil)
+    }
+  }
+
+  public func selectBitmapModel(connectInfo: String, payload: RCTESCSelectBitmapModelRequest, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+
+      guard let url = URL(string: payload.bitmapPath), let bitmap = try? Data(contentsOf: url) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "bitmapPath is error",
+            error: nil
+          )
+        )
+        return
+      }
+      guard let model = payload.model.toESCSelectBitmapModel() else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "model is error",
+            error: nil
+          )
+        )
+        return
+      }
+      let width = Int32(payload.width)
+      printer.writeCommand(with: POSCommand.selectBmpModel(withM: model, andnL: width % 256, andnH: width / 256, andNSData: bitmap))
+      completion(nil)
+    }
+  }
+
+  public func setLineSpacing(connectInfo: String, space: Double, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+
+      printer.writeCommand(with: POSCommand.setDefultLineSpace(Int32(space)))
+      completion(nil)
+    }
+  }
+
+  public func setTurnUpsideDownMode(connectInfo: String, on: Bool, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+
+      printer.writeCommand(with: POSCommand.selectOrCancleInvertPrintModel(on ? 1 : 0))
+      completion(nil)
+    }
+  }
+
+  public func selectCodePage(connectInfo: String, page: Double, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+
+      printer.writeCommand(with: POSCommand.setCodePage(Int32(page)))
+      completion(nil)
+    }
+  }
+
+  public func selectCharacterFont(connectInfo: String, font: String, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+      guard let font = font.toESCFontType() else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "font is error",
+            error: nil
+          )
+        )
+        return
+      }
+
+      printer.writeCommand(with: POSCommand.selectHRIFont(font))
+      completion(nil)
+    }
+  }
+
+  public func printPDF417(connectInfo: String, payload: RCTESCPrintPDF417Request, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+
+      let cellWidth = Int32(payload.cellWidth)
+      let cellHeightRatio = Int32(payload.cellHeightRatio)
+      let numberOfColumns = Int32(payload.numberOfColumns)
+      let numberOfRows = Int32(payload.numberOfRows)
+      let eclType = Int32(payload.eclType)
+      let eclValue = Int32(payload.eclValue)
+      guard let alignment = payload.alignment.toESCAlignment() else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "alignment is error",
+            error: nil
+          )
+        )
+        return
+      }
+
+      var command = Data()
+      command.append(POSCommand.setPdf417Columns(numberOfColumns))
+      command.append(POSCommand.setpdf417Width(ofModule: cellWidth))
+      command.append(POSCommand.setpdf417RowHeight(cellHeightRatio))
+      command.append(POSCommand.selectAlignment(alignment))
+      command.append(POSCommand.storethepdf417WithpL(Int32(payload.data.count) % 256, andpH: Int32(payload.data.count) / 256, andContent: payload.data, usEnCoding: printer.charSet.rawValue))
+      command.append(POSCommand.printPdf417InStore())
+      printer.writeCommand(with: command)
+      completion(nil)
+    }
+  }
+
+  public func printTable(connectInfo: String, payload: RCTESCPrintTableRequest, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+
+      let titles = payload.titles
+      let numberOfSingleBytesPerCol: [NSNumber] =
+        payload.numberOfSingleBytesPerCol.map { NSNumber(value: $0) }
+      let align = payload.align
+
+      var tableAlign = TableAlignType.FIRST_LEFT_ALIGN
+      if align.count > 0 {
+        tableAlign = align[0] == 1 ? TableAlignType.ALL_RIGHT_ALIGN : TableAlignType.FIRST_LEFT_ALIGN
+      }
+      var command = Data()
+      command.append(PTable.addAutoTableH(titles, titleLength: numberOfSingleBytesPerCol, align: tableAlign))
+      let rows = payload.rows
+      rows?.forEach { row in
+        if let tableRowTitle = row.title?.data(using: printer.charSet) {
+          command.append(tableRowTitle)
+        }
+        let tableRowData = row.data
+        command.append(PTable.addAutoTableH(tableRowData, titleLength: numberOfSingleBytesPerCol, align: tableAlign))
+        if let tableRowRemark = row.remark?.data(using: printer.charSet) {
+          command.append(tableRowRemark)
+        }
+        if let tableRowBarcode = row.barcode, let codeType = tableRowBarcode.codeType.toESCTableBarCodeType(), let textPosition = tableRowBarcode.textPosition.toESCTableTextPosition() {
+          command.append(PTable.addBarcodeRow(tableRowBarcode.data, type: codeType, hri: textPosition))
+        }
+      }
+      printer.writeCommand(with: command)
+      completion(nil)
+    }
+  }
+  
+  public func setGateway(connectInfo: String, gateway: String, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      completion(NativeErrorInfo(code: PrinterErrors.NOT_YET_IMPLEMENTED_ERROR, message: "Not yet implemented", error: nil))
+    }
+  }
+  
+  public func setIp(connectInfo: String, ip: String, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      completion(NativeErrorInfo(code: PrinterErrors.NOT_YET_IMPLEMENTED_ERROR, message: "Not yet implemented", error: nil))
+    }
+  }
+  
+  public func setMask(connectInfo: String, mask: String, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      completion(NativeErrorInfo(code: PrinterErrors.NOT_YET_IMPLEMENTED_ERROR, message: "Not yet implemented", error: nil))
+    }
+  }
+
+  public func wifiConfig(connectInfo: String, payload: RCTESCWifiConfigRequest, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+
+      guard let encrypt = payload.encrypt.toESCWifiEncrypt() else {
+        completion(NativeErrorInfo(code: PrinterErrors.PARAMS_ERROR, message: "encrypt is error", error: nil))
+        return
+      }
+
+      // TODO: need test
+      POSWIFIManager.sharedInstance().setWiFiConfigWithIP(printer.deviceIP, mask: payload.mask, gateway: payload.gateway, ssid: payload.ssid, password: payload.password, encrypt: encrypt)
+      completion(nil)
+    }
+  }
+
+  public func setNetAll(connectInfo: String, payload: RCTESCSetNetAllRequest, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+
+      // TODO: need test
+      POSWIFIManager.sharedInstance().setIPConfigWithIP(payload.ip, mask: payload.mask, gateway: payload.gateway, dhcp: payload.dhcpIsOpen)
+      completion(nil)
+    }
+  }
+
+  public func setBluetooth(connectInfo: String, name: String, pin: String, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+
+      printer.setBluetooth(name: name, pin: pin)
+      completion(nil)
+    }
+  }
+
+  public func getSerialNumber(connectInfo: String, resolve: @escaping (_ value: [String: Any]) -> Void, reject: @escaping (_ error: NativeErrorInfo) -> Void) {
+    DispatchQueue.main.async {
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        reject(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found printer:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+
+      printer.printerSN { data in
+        if data != nil {
+          var result: [String: Any] = [:]
+          result["data"] = data
+          resolve(result)
+        } else {
+          reject(
+            NativeErrorInfo(
+              code: PrinterErrors.COMMON_ERROR,
+              message: "get sn failed",
+              error: nil
+            )
+          )
+        }
+      }
+    }
+  }
+}