@connexup/react-native-xprinter 0.1.0

package/ios/Printer/Connecter.swift

@@ -0,0 +1,214 @@
+//
+//  BluetoothConnecter.swift
+
+//
+//  Created by chancetio on 2025/1/23.
+//
+
+enum ConnectType {
+  case ETHERNET
+  case BLUETOOTH
+}
+
+extension String {
+  func toConnectType() -> ConnectType? {
+    switch self {
+    case "BLUETOOTH":
+      return ConnectType.BLUETOOTH
+    case "ETHERNET":
+      return ConnectType.ETHERNET
+    default:
+      return nil
+    }
+  }
+}
+
+enum PCL: String, CaseIterable {
+  case ESC
+  case TSPL
+//  case CPCL
+//  case ZPL
+}
+
+extension String {
+  func toPCLType() -> PCL? {
+    return PCL.allCases.first { $0.rawValue == self }
+  }
+}
+
+class Connecter: WIFIConnecter {
+  let type: ConnectType
+  private lazy var bleManage = POSBLEManager()
+
+  weak var bluetoothDelegate: POSBLEManagerDelegate? {
+    didSet {
+      if bluetoothDelegate != nil {
+        bleManage.delegate = self
+      } else {
+        bleManage.delegate = nil
+      }
+    }
+  }
+
+  var pcl: PCL?
+
+//  var charSet:String.Encoding = .utf8
+  var charSet: String.Encoding = .init(rawValue: CFStringConvertEncodingToNSStringEncoding(CFStringEncoding(CFStringEncodings.GB_18030_2000.rawValue)))
+
+  private var pendingConnectInfo: String?
+
+  init(type: ConnectType) {
+    self.type = type
+  }
+
+  deinit {
+    delegate = nil
+    bluetoothDelegate = nil
+  }
+
+  func connectByBluetooth(connectInfo: String) {
+    pendingConnectInfo = connectInfo
+    bleManage.startScan()
+  }
+
+  func startBluetoothScan() {
+    pendingConnectInfo = nil
+    bleManage.startScan()
+  }
+
+  func isConnect() -> Bool {
+    if type == .BLUETOOTH {
+      return bleManage.printerIsConnect()
+    } else {
+      return printerCheckWithMac()
+    }
+  }
+
+  override func disconnect() {
+    if type == .BLUETOOTH {
+      bleManage.disconnectRootPeripheral()
+    } else {
+      super.disconnect()
+    }
+  }
+
+  override func writeCommand(with data: Data) {
+    if type == .BLUETOOTH {
+      bleManage.writeCommand(with: data)
+    } else {
+      super.writeCommand(with: data)
+    }
+  }
+
+  override func writeCommand(with data: Data, writeCallBack writeBlock: @escaping WIFIConnecterWriteBlock) {
+    if type == .BLUETOOTH {
+      bleManage.writeCommand(with: data, writeCallBack: { [weak self] _, error in
+        guard self != nil else { return }
+        writeBlock(error == nil, error)
+      })
+    } else {
+      super.writeCommand(with: data, writeCallBack: writeBlock)
+    }
+  }
+
+  // TODO: improve
+  override func writeCommand(with data: Data!, receiveCallBack receiveBlock: WIFIConnecterReceiveBlock!) {
+    if type == .BLUETOOTH {
+      bleManage.writeCommand(with: data, receiveCallBack: { [weak self] _, _ in
+        guard self != nil else { return }
+        receiveBlock(nil)
+      })
+    } else {
+      super.writeCommand(with: data, receiveCallBack: receiveBlock)
+    }
+  }
+
+  // TODO: improve
+  override func writeCommand(with data: Data!, subpackageLength: Int32, writeCallBack writeBlock: WIFIConnecterWriteBlock!) {
+    if type == .BLUETOOTH {
+      writeBlock(false, NSError(domain: "", code: 0, userInfo: [NSLocalizedDescriptionKey: "unsupported method"]))
+    } else {
+      super.writeCommand(with: data, subpackageLength: subpackageLength, writeCallBack: writeBlock)
+    }
+  }
+
+  func printerCheck(type checkType: Int32, callBack: @escaping (Data?) -> Void) {
+    if type == .BLUETOOTH {
+      bleManage.printerCheck(checkType) { data in
+        callBack(data)
+      }
+    } else {
+      callBack(nil)
+    }
+  }
+
+  override func printerStatus(_ statusBlock: POSWiFiPrinterStatusBlock!) {
+    if type == .BLUETOOTH {
+      bleManage.printerStatus { data in
+        statusBlock(data)
+      }
+    } else {
+      super.printerStatus(statusBlock)
+    }
+  }
+
+  override func labelPrinterStatus(_ statusBlock: POSWiFiPrinterStatusBlock!) {
+    if type == .BLUETOOTH {
+      bleManage.printerStatus { data in
+        statusBlock(data)
+      }
+    } else {
+      super.labelPrinterStatus(statusBlock)
+    }
+  }
+
+  override func printerSN(snBlock: POSWiFiPrinterSNBlock!) {
+    if type == .BLUETOOTH {
+      bleManage.printerSN { data in
+        snBlock(data)
+      }
+    } else {
+      super.printerSN(snBlock: snBlock)
+    }
+  }
+
+  func setBluetooth(name: String, pin: String) {
+    bleManage.setBluetoothNameAndKeyWith(name, btKey: pin)
+  }
+}
+
+extension Connecter: POSBLEManagerDelegate {
+  func poSbleUpdatePeripheralList(_ peripherals: [Any], rssiList: [Any]) {
+    bluetoothDelegate?.poSbleUpdatePeripheralList?(peripherals, rssiList: rssiList)
+    for peripheral in peripherals {
+      if let peripheral = peripheral as? CBPeripheral, peripheral.identifier.uuidString == pendingConnectInfo {
+        pendingConnectInfo = nil
+        bleManage.connectDevice(peripheral)
+      }
+    }
+  }
+
+  func poSbleConnect(_ peripheral: CBPeripheral!) {
+    bluetoothDelegate?.poSbleConnect?(peripheral)
+  }
+
+  func poSbleFail(toConnect peripheral: CBPeripheral, error: any Error) {
+    bluetoothDelegate?.poSbleFail?(toConnect: peripheral, error: error)
+  }
+
+  func poSbleDisconnectPeripheral(_ peripheral: CBPeripheral, error: any Error) {
+    bluetoothDelegate?.poSbleDisconnectPeripheral?(peripheral, error: error)
+  }
+
+  func poSbleWriteValue(for character: CBCharacteristic, error: any Error) {
+    bluetoothDelegate?.poSbleWriteValue?(for: character, error: error)
+  }
+
+  func poSbleReceiveValue(for characteristic: CBCharacteristic, error: any Error) {
+    bluetoothDelegate?.poSbleReceiveValue?(for: characteristic, error: error)
+  }
+
+  func poSbleCentralManagerDidUpdateState(_ state: Int) {
+    bluetoothDelegate?.poSbleCentralManagerDidUpdateState?(state)
+  }
+}

package/ios/Printer/Models/RCTDeviceConnectStatusChangeEvent.swift

@@ -0,0 +1,19 @@
+@objcMembers
+public class RCTDeviceConnectStatusChangeEvent: NSObject {
+  public let code: String
+  public let connectInfo: String
+  public let msg: String?
+  public let debugCode: Double?
+
+  public init(code: String, connectInfo: String, msg: String?, debugCode: Double?) {
+    self.code = code
+    self.connectInfo = connectInfo
+    self.msg = msg
+    self.debugCode = debugCode
+    super.init()
+  }
+
+  override public var description: String {
+    "RCTDeviceConnectStatusChangeEvent(code=\(String(describing: code)), connectInfo=\(String(describing: connectInfo)), msg=\(String(describing: msg)), debugCode=\(String(describing: debugCode)))"
+  }
+}

package/ios/Printer/Models/RCTNetDevice.swift

@@ -0,0 +1,21 @@
+@objcMembers
+public class RCTNetDevice: NSObject {
+  public let macAddress: String
+  public let ipAddress: String
+  public let mask: String
+  public let gateway: String
+  public let dhcp: Bool
+
+  public init(macAddress: String, ipAddress: String, mask: String, gateway: String, dhcp: Bool) {
+    self.macAddress = macAddress
+    self.ipAddress = ipAddress
+    self.mask = mask
+    self.gateway = gateway
+    self.dhcp = dhcp
+    super.init()
+  }
+
+  override public var description: String {
+    "RCTNetDevice(macAddress=\(String(describing: macAddress)), ipAddress=\(String(describing: ipAddress)), mask=\(String(describing: mask)), gateway=\(String(describing: gateway)), dhcp=\(String(describing: dhcp)))"
+  }
+}

package/ios/Printer/Models/RCTUSBDevice.swift

@@ -0,0 +1,17 @@
+@objcMembers
+public class RCTUSBDevice: NSObject {
+  public let deviceId: Double
+  public let deviceName: String
+  public let manufacturerName: String?
+
+  public init(deviceId: Double, deviceName: String, manufacturerName: String?) {
+    self.deviceId = deviceId
+    self.deviceName = deviceName
+    self.manufacturerName = manufacturerName
+    super.init()
+  }
+
+  override public var description: String {
+    "RCTUSBDevice(deviceId=\(String(describing: deviceId)), deviceName=\(String(describing: deviceName)), manufacturerName=\(String(describing: manufacturerName)))"
+  }
+}

package/ios/Printer/Models/RCTUpdateUdpNetConfigRequest.swift

@@ -0,0 +1,21 @@
+@objcMembers
+public class RCTUpdateUdpNetConfigRequest: NSObject {
+  public let macAddress: String
+  public let ipAddress: String
+  public let mask: String
+  public let gateway: String
+  public let dhcp: Bool
+
+  public init(macAddress: String, ipAddress: String, mask: String, gateway: String, dhcp: Bool) {
+    self.macAddress = macAddress
+    self.ipAddress = ipAddress
+    self.mask = mask
+    self.gateway = gateway
+    self.dhcp = dhcp
+    super.init()
+  }
+
+  override public var description: String {
+    "RCTUpdateUdpNetConfigRequest(macAddress=\(String(describing: macAddress)), ipAddress=\(String(describing: ipAddress)), mask=\(String(describing: mask)), gateway=\(String(describing: gateway)), dhcp=\(String(describing: dhcp)))"
+  }
+}

package/ios/Printer/NativeXPrinterPrinter.swift

@@ -0,0 +1,209 @@
+import Foundation
+
+let CONNECT_STATUS_CONNECT_SUCCESS = "CONNECT_SUCCESS"
+let CONNECT_STATUS_CONNECT_FAIL = "CONNECT_FAIL"
+let CONNECT_STATUS_DISCONNECT = "DISCONNECT"
+let CONNECT_STATUS_SEND_FAIL = "SEND_FAIL"
+let CONNECT_STATUS_CONNECT_INTERRUPT = "CONNECT_INTERRUPT"
+let CONNECT_STATUS_USB_ATTACHED = "USB_ATTACHED"
+let CONNECT_STATUS_USB_DETACHED = "USB_DETACHED"
+let CONNECT_STATUS_BLUETOOTH_INTERRUPT = "BLUETOOTH_INTERRUPT"
+let CONNECT_STATUS_UNKNOWN = "UNKNOWN"
+
+@objc public protocol RCTNativeXPrinterPrinterEventEmitter {
+  func onDeviceConnectStatusChange(_ value: [String: Any])
+  func onSearchNetDeviceFound(_ value: [String: Any])
+}
+
+@objcMembers
+public class NativeXPrinterPrinter: NSObject {
+  private lazy var observer = NativeXPrinterPrinterObserver(owner: self)
+  public weak var emitter: RCTNativeXPrinterPrinterEventEmitter?
+
+  deinit {
+    invalidate()
+  }
+
+  public func invalidate() {
+    Printers.shared.clear()
+  }
+
+  public func searchNetDevice(completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      if POSWIFIManager.sharedInstance().createUdpSocket() {
+        POSWIFIManager.sharedInstance().sendFindCmd { [weak self] device in
+          guard let self = self else {
+            return
+          }
+          guard let device = device else {
+            return
+          }
+          self.sendSearchNetDeviceEvent(device)
+        }
+        completion(nil)
+      } else {
+        completion(NativeErrorInfo(code: PrinterErrors.COMMON_ERROR, message: "createUdpSocket", error: nil))
+      }
+    }
+  }
+
+  public func udpNetConfig(params: RCTUpdateUdpNetConfigRequest, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      POSWIFIManager.sharedInstance().setIPConfigWithIP(params.ipAddress, mask: params.mask, gateway: params.gateway, dhcp: params.dhcp)
+      completion(nil)
+    }
+  }
+
+  public func connect(connectInfo: String, deviceType: String, sync: Bool, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let deviceType = deviceType.toConnectType() else {
+        completion(NativeErrorInfo(code: PrinterErrors.PARAMS_ERROR, message: "deviceType unsupported", error: nil))
+        return
+      }
+
+      if deviceType == .ETHERNET {
+        let connecter = Connecter(type: .ETHERNET)
+        connecter.delegate = self.observer
+        Printers.shared.setPendingPrinter(connectInfo: connectInfo, printer: connecter)
+        connecter.connect(withHost: connectInfo, port: 9100)
+        completion(nil)
+      } else if deviceType == .BLUETOOTH {
+        let connecter = Connecter(type: .BLUETOOTH)
+        connecter.bluetoothDelegate = self.observer
+        Printers.shared.setPendingPrinter(connectInfo: connectInfo, printer: connecter)
+        connecter.connectByBluetooth(connectInfo: connectInfo)
+        completion(nil)
+      } else {
+        completion(NativeErrorInfo(code: PrinterErrors.PARAMS_ERROR, message: "deviceType unsupported", error: nil))
+      }
+    }
+  }
+
+  public func disconnect(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 device connectInfo:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+      Printers.shared.removePrinter(connectInfo: connectInfo)
+      self.sendDeviceConnectStatusChangeEvent(code: CONNECT_STATUS_DISCONNECT, connectInfo: connectInfo, msg: nil)
+      printer.disconnect()
+      completion(nil)
+    }
+  }
+
+  public func getPrinterPCL(connectInfo: String, resolve: @escaping (_ value: String?) -> Void, reject: @escaping (_ error: NativeErrorInfo) -> Void)
+  {
+    DispatchQueue.main.async {
+      resolve(Printers.shared.getPrinterPCL(connectInfo: connectInfo)?.rawValue)
+    }
+  }
+
+  public func isConnect(connectInfo: String, resolve: @escaping (_ value: Bool) -> 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
+      }
+      resolve(status)
+    }
+  }
+
+  public func setPrinterPCL(connectInfo: String, pcl: String, completion: @escaping (_ error: NativeErrorInfo?) -> Void) {
+    DispatchQueue.main.async {
+      guard let pcl = pcl.toPCLType() else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PARAMS_ERROR,
+            message: "unsupported pcl type",
+            error: nil
+          )
+        )
+        return
+      }
+      guard let printer = Printers.shared.getPrinter(connectInfo: connectInfo) else {
+        completion(
+          NativeErrorInfo(
+            code: PrinterErrors.PRINTER_NOT_FOUND_ERROR,
+            message: "not found device connectInfo:\(connectInfo)",
+            error: nil
+          )
+        )
+        return
+      }
+
+      printer.pcl = pcl
+      completion(nil)
+    }
+  }
+
+  public func getUsbDevices(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))
+    }
+  }
+
+  internal func sendSearchNetDeviceEvent(_ device: PrinterProfile) {
+    var result: [String: Any] = [:]
+    result["macAddress"] = device.printerName
+    result["ipAddress"] = device.getIPString()
+    result["mask"] = device.getMaskString()
+    result["gateway"] = device.getGatewayString()
+    result["dhcp"] = device.getDHCP() != 0
+    self.emitter?.onSearchNetDeviceFound(result)
+  }
+
+  internal func sendDeviceConnectStatusChangeEvent(code: String, connectInfo: String, msg: String?) {
+    var result: [String: Any] = [:]
+    result["code"] = code
+    result["connectInfo"] = connectInfo
+    result["msg"] = msg
+    self.emitter?.onDeviceConnectStatusChange(result)
+  }
+}
+
+class NativeXPrinterPrinterObserver: NSObject {
+  weak var owner: NativeXPrinterPrinter?
+
+  init(owner: NativeXPrinterPrinter) {
+    self.owner = owner
+  }
+}
+
+extension NativeXPrinterPrinterObserver: WIFIConnecterDelegate {
+  public func wifiPOSConnected(toHost ip: String, port: UInt16, mac: String) {
+    Printers.shared.onPrinterConnected(ip: ip, mac: mac)
+    self.owner?.sendDeviceConnectStatusChangeEvent(code: CONNECT_STATUS_CONNECT_SUCCESS, connectInfo: ip, msg: nil)
+  }
+
+  func wifiPOSDisconnectWithError(_ error: (any Error)?, mac: String, ip: String) {
+    Printers.shared.onPrinterDisconnectWithError(ip: ip, mac: mac)
+    self.owner?.sendDeviceConnectStatusChangeEvent(code: CONNECT_STATUS_CONNECT_FAIL, connectInfo: ip, msg: error?.localizedDescription)
+  }
+}
+
+extension NativeXPrinterPrinterObserver: POSBLEManagerDelegate {
+  func poSbleConnect(_ peripheral: CBPeripheral!) {
+    Printers.shared.onPrinterConnected(peripheral: peripheral)
+    self.owner?.sendDeviceConnectStatusChangeEvent(code: CONNECT_STATUS_CONNECT_SUCCESS, connectInfo: peripheral.identifier.uuidString, msg: nil)
+  }
+
+  func poSbleFail(toConnect peripheral: CBPeripheral, error: (any Error)?) {
+    Printers.shared.onPrinterDisconnectWithError(peripheral: peripheral)
+    self.owner?.sendDeviceConnectStatusChangeEvent(code: CONNECT_STATUS_CONNECT_FAIL, connectInfo: peripheral.identifier.uuidString, msg: error?.localizedDescription)
+  }
+
+  func poSbleDisconnectPeripheral(_ peripheral: CBPeripheral, error: (any Error)?) {
+    Printers.shared.onPrinterDisconnectWithError(peripheral: peripheral)
+    self.owner?.sendDeviceConnectStatusChangeEvent(code: CONNECT_STATUS_DISCONNECT, connectInfo: peripheral.identifier.uuidString, msg: error?.localizedDescription)
+  }
+}

package/ios/Printer/Printers.swift

@@ -0,0 +1,59 @@
+//
+//  Printers.swift
+//
+//  Created by chancetio on 2025/1/23.
+//
+
+class Printers {
+  static let shared = Printers()
+
+  private var printers: [String: Connecter] = [:]
+
+  private var pendingConnecter: [String: Connecter] = [:]
+
+  private init() {}
+
+  func clear(){
+    printers.removeAll()
+    pendingConnecter.removeAll()
+  }
+
+  func setPendingPrinter(connectInfo: String, printer:Connecter){
+    self.pendingConnecter[connectInfo] = printer
+  }
+  
+  func removePrinter(connectInfo: String){
+    self.pendingConnecter.removeValue(forKey: connectInfo)
+    self.printers.removeValue(forKey: connectInfo)
+  }
+
+  func getPrinter(connectInfo: String) -> Connecter? {
+    return self.printers[connectInfo]
+  }
+  
+  func getPrinterPCL(connectInfo: String) -> PCL? {
+    return self.printers[connectInfo]?.pcl
+  }
+
+  func onPrinterConnected(ip: String, mac:String){
+    if let printer =  self.pendingConnecter.removeValue(forKey: ip) {
+      printers[ip] = printer
+    }
+    if let printer = self.pendingConnecter.removeValue(forKey: mac) {
+      printers[ip] = printer
+    }
+  }
+
+  func onPrinterDisconnectWithError(ip: String, mac:String){
+    self.pendingConnecter.removeValue(forKey: ip)
+    self.pendingConnecter.removeValue(forKey: mac)
+  }
+
+  func onPrinterConnected(peripheral: CBPeripheral){
+    self.pendingConnecter.removeValue(forKey: peripheral.identifier.uuidString)
+  }
+
+  func onPrinterDisconnectWithError(peripheral: CBPeripheral){
+    self.pendingConnecter.removeValue(forKey: peripheral.identifier.uuidString)
+  }
+}

package/ios/Printer/RCTNativeXPrinterPrinter.h

@@ -0,0 +1,12 @@
+#import <Foundation/Foundation.h>
+#import <XPrinterSpec/XPrinterSpec.h>
+#import <React/RCTInitializing.h>
+#import <React/RCTInvalidating.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface RCTNativeXPrinterPrinter : NativeXPrinterPrinterSpecBase <NativeXPrinterPrinterSpec, RCTInvalidating>
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/Printer/RCTNativeXPrinterPrinter.mm

@@ -0,0 +1,123 @@
+#import "RCTNativeXPrinterPrinter.h"
+#import "NativeXPrinter-Swift.h"
+
+@interface RCTNativeXPrinterPrinter () <RCTNativeXPrinterPrinterEventEmitter>
+@end
+
+@implementation RCTNativeXPrinterPrinter {
+  NativeXPrinterPrinter* printer;
+}
+
+- (id) init {
+  if (self = [super init]) {
+    printer = [NativeXPrinterPrinter new];
+    printer.emitter = self;
+  }
+  return self;
+}
+
+- (void)dealloc {
+
+}
+
+- (void)invalidate {
+  [printer invalidate];
+}
+
+
+- (void)connect:(nonnull NSString *)connectInfo deviceType:(nonnull NSString *)deviceType sync:(BOOL)sync resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+  [printer connectWithConnectInfo:connectInfo deviceType:deviceType sync:sync completion:^(NativeErrorInfo * _Nullable errorInfo) {
+    if (errorInfo) {
+      reject(errorInfo.code, errorInfo.message, errorInfo.error);
+    }else{
+      resolve(nil);
+    }
+  }];
+}
+
+- (void)disconnect:(nonnull NSString *)connectInfo resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+  [printer disconnectWithConnectInfo:connectInfo completion:^(NativeErrorInfo * _Nullable errorInfo) {
+    if (errorInfo) {
+      reject(errorInfo.code, errorInfo.message, errorInfo.error);
+    }else{
+      resolve(nil);
+    }
+  }];
+}
+
+- (void)getPrinterPCL:(nonnull NSString *)connectInfo resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject {
+  [printer getPrinterPCLWithConnectInfo:connectInfo resolve:^(NSString * _Nullable value) {
+    resolve(value);
+  } reject:^(NativeErrorInfo * _Nonnull errorInfo) {
+    reject(errorInfo.code, errorInfo.message, errorInfo.error);
+  }];
+}
+
+- (void)getUsbDevices:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+  [printer getUsbDevicesWithResolve:^(NSArray<NSDictionary<NSString *,id> *> * _Nonnull value) {
+    resolve(value);
+  } reject:^(NativeErrorInfo * _Nonnull errorInfo) {
+    reject(errorInfo.code, errorInfo.message, errorInfo.error);
+  }];
+}
+
+- (void)isConnect:(nonnull NSString *)connectInfo resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+  [printer isConnectWithConnectInfo:connectInfo resolve:^(BOOL value) {
+    resolve(@(value));
+  } reject:^(NativeErrorInfo * _Nonnull errorInfo) {
+    reject(errorInfo.code, errorInfo.message, errorInfo.error);
+  }];
+}
+
+- (void)searchNetDevice:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+  [printer searchNetDeviceWithCompletion:^(NativeErrorInfo * _Nullable errorInfo) {
+    if (errorInfo) {
+      reject(errorInfo.code, errorInfo.message, errorInfo.error);
+    }else{
+      resolve(nil);
+    }
+  }];
+}
+
+- (void)setPrinterPCL:(nonnull NSString *)connectInfo pcl:(nonnull NSString *)pcl resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+    [printer setPrinterPCLWithConnectInfo:connectInfo pcl:pcl  completion:^(NativeErrorInfo * _Nullable errorInfo) {
+      if (errorInfo) {
+        reject(errorInfo.code, errorInfo.message, errorInfo.error);
+      }else{
+        resolve(nil);
+      }
+    }];
+}
+
+- (void)udpNetConfig:(JS::NativeXPrinterPrinter::UpdateUdpNetConfigRequest &)request resolve:(nonnull RCTPromiseResolveBlock)resolve reject:(nonnull RCTPromiseRejectBlock)reject { 
+//  <#code#>
+}
+
+- (void)onDeviceConnectStatusChange:(NSDictionary<NSString *,id> * _Nonnull)value {
+  try {
+     [self emitOnDeviceConnectStatusChange:value];
+   } catch (const std::bad_function_call &e) {
+     NSLog(@"[XPrinter] std::bad_function_call in emitOnDeviceConnectStatusChange: %s", e.what());
+   }
+}
+
+- (void)onSearchNetDeviceFound:(NSDictionary<NSString *,id> * _Nonnull)value {
+  try {
+    [self emitOnSearchNetDeviceFound:value];
+   } catch (const std::bad_function_call &e) {
+     NSLog(@"[XPrinter] std::bad_function_call in emitOnSearchNetDeviceFound: %s", e.what());
+   }
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<facebook::react::NativeXPrinterPrinterSpecJSI>(params);
+}
+
++ (NSString *)moduleName
+{
+  return @"NativeXPrinterPrinter";
+}
+
+@end