@munchi_oy/react-native-epson-printer 1.0.6 → 1.0.8

package/ios/Vendors/Epson/MunchiEpsonModule.swift

@@ -24,6 +24,7 @@ class MunchiEpsonModule: RCTEventEmitter, Epos2ConnectionDelegate, Epos2PtrStatu
   private var discoveryResolve: RCTPromiseResolveBlock?
   private var discoveryReject: RCTPromiseRejectBlock?
   private var foundPrinters: [NSDictionary] = []
+  private let printerQueue = DispatchQueue(label: "com.munchiepsonprinter.epson")
 
   override func supportedEvents() -> [String]! {
     return ["onPrinterStatusChange", "onPrinterConnectionChange", "onPrinterReceive"]
@@ -95,319 +96,354 @@ class MunchiEpsonModule: RCTEventEmitter, Epos2ConnectionDelegate, Epos2PtrStatu
 
   @objc(initSession:rejecter:)
   func initSession(_ resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
-      let sessionId = UUID().uuidString
-      sessions[sessionId] = EpsonSession(sessionId: sessionId)
-      resolve(sessionId)
+      printerQueue.async { [weak self] in
+          guard let self = self else { return }
+
+          let sessionId = UUID().uuidString
+          self.sessions[sessionId] = EpsonSession(sessionId: sessionId)
+          resolve(sessionId)
+      }
   }
 
   @objc(disposeSession:resolver:rejecter:)
   func disposeSession(_ sessionId: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
-      guard let session = sessions.removeValue(forKey: sessionId) else {
+      printerQueue.async { [weak self] in
+          guard let self = self else { return }
+
+          guard let session = self.sessions.removeValue(forKey: sessionId) else {
+              resolve(true)
+              return
+          }
+
+          self.teardownPrinter(session, disconnect: true)
           resolve(true)
-          return
       }
-
-      teardownPrinter(session, disconnect: true)
-      resolve(true)
   }
 
   @objc(connect:target:timeout:model:lang:resolver:rejecter:)
   func connect(_ sessionId: String, target: String, timeout: Double, model: Int, lang: Int, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
-    guard let session = sessions[sessionId] else {
-        reject("SESSION_ERROR", "Session not found", nil)
-        return
-    }
+    printerQueue.async { [weak self] in
+        guard let self = self else { return }
 
-    var connectionDelay = 0.0
+        guard let session = self.sessions[sessionId] else {
+            reject("SESSION_ERROR", "Session not found", nil)
+            return
+        }
 
-    if session.printer != nil {
-        teardownPrinter(session, disconnect: true)
-        connectionDelay = 0.5
-    }
+        var connectionDelay = 0.0
 
-    DispatchQueue.main.asyncAfter(deadline: .now() + connectionDelay) { [weak self] in
-        guard let self = self else { return }
-        guard let latestSession = self.sessions[sessionId] else {
-            reject("SESSION_ERROR", "Session disposed while connecting", nil)
-            return
+        if session.printer != nil {
+            self.teardownPrinter(session, disconnect: true)
+            connectionDelay = 0.5
         }
 
-        if let ownerSessionId = self.targetToSessionId[target], ownerSessionId != sessionId {
-            if let ownerSession = self.sessions[ownerSessionId] {
-                if ownerSession.printResolve != nil {
-                    reject("TARGET_IN_USE", "Target is busy with an active print job: \(target)", nil)
-                    return
+        self.printerQueue.asyncAfter(deadline: .now() + connectionDelay) { [weak self] in
+            guard let self = self else { return }
+            guard let latestSession = self.sessions[sessionId] else {
+                reject("SESSION_ERROR", "Session disposed while connecting", nil)
+                return
+            }
+
+            if let ownerSessionId = self.targetToSessionId[target], ownerSessionId != sessionId {
+                if let ownerSession = self.sessions[ownerSessionId] {
+                    if ownerSession.printResolve != nil {
+                        reject("TARGET_IN_USE", "Target is busy with an active print job: \(target)", nil)
+                        return
+                    }
+                    _ = self.teardownPrinter(ownerSession, disconnect: true)
+                } else {
+                    self.targetToSessionId.removeValue(forKey: target)
                 }
-                _ = self.teardownPrinter(ownerSession, disconnect: true)
-            } else {
-                self.targetToSessionId.removeValue(forKey: target)
             }
-        }
 
-        let safeLang = self.normalizedLanguage(lang)
-        let safeModel = self.normalizedModel(model)
+            let safeLang = self.normalizedLanguage(lang)
+            let safeModel = self.normalizedModel(model)
 
-        latestSession.printer = Epos2Printer(printerSeries: safeModel, lang: safeLang)
+            latestSession.printer = Epos2Printer(printerSeries: safeModel, lang: safeLang)
 
-        guard let p = latestSession.printer else {
-            reject("INIT_ERROR", "Failed to initialize printer object", nil)
-            return
-        }
+            guard let p = latestSession.printer else {
+                reject("INIT_ERROR", "Failed to initialize printer object", nil)
+                return
+            }
 
-        p.setConnectionEventDelegate(self)
-        p.setStatusChangeEventDelegate(self)
-        p.setReceiveEventDelegate(self)
-        self.printerToSessionId[ObjectIdentifier(p)] = sessionId
-        latestSession.target = target
+            p.setConnectionEventDelegate(self)
+            p.setStatusChangeEventDelegate(self)
+            p.setReceiveEventDelegate(self)
+            self.printerToSessionId[ObjectIdentifier(p)] = sessionId
+            latestSession.target = target
 
-        let connectTimeout = Int(timeout)
-        let result = p.connect(target, timeout: connectTimeout)
+            let connectTimeout = Int(timeout)
+            let result = p.connect(target, timeout: connectTimeout)
 
-        if result == EPOS2_SUCCESS.rawValue {
-            _ = p.startMonitor()
-            self.targetToSessionId[target] = sessionId
-            resolve("Connected to \(target)")
-        } else {
-            self.teardownPrinter(latestSession, disconnect: false)
-            reject("CONNECT_ERROR", "Failed to connect: \(result)", nil)
+            if result == EPOS2_SUCCESS.rawValue {
+                _ = p.startMonitor()
+                self.targetToSessionId[target] = sessionId
+                resolve("Connected to \(target)")
+            } else {
+                self.teardownPrinter(latestSession, disconnect: false)
+                reject("CONNECT_ERROR", "Failed to connect: \(result)", nil)
+            }
         }
     }
   }
 
   @objc(disconnect:resolver:rejecter:)
   func disconnect(_ sessionId: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
-    guard let session = sessions[sessionId] else {
-        resolve(true)
-        return
-    }
+    printerQueue.async { [weak self] in
+        guard let self = self else { return }
 
-    let result = teardownPrinter(session, disconnect: true)
+        guard let session = self.sessions[sessionId] else {
+            resolve(true)
+            return
+        }
 
-    if result == nil || result == EPOS2_SUCCESS.rawValue {
-        resolve(true)
-    } else {
-        resolve(false)
+        let result = self.teardownPrinter(session, disconnect: true)
+
+        if result == nil || result == EPOS2_SUCCESS.rawValue {
+            resolve(true)
+        } else {
+            resolve(false)
+        }
     }
   }
 
   // --- Delegate Methods ---
 
   func onConnection(_ deviceObj: Any!, eventType: Int32) {
-    guard
-        let obj = deviceObj as AnyObject?,
-        let sessionId = printerToSessionId[ObjectIdentifier(obj)],
-        let session = sessions[sessionId]
-    else { return }
-
-    var status = "UNKNOWN"
-    switch eventType {
-    case EPOS2_EVENT_RECONNECTING.rawValue:
-        status = "RECONNECTING"
-    case EPOS2_EVENT_RECONNECT.rawValue:
-        status = "RECONNECTED"
-    case EPOS2_EVENT_DISCONNECT.rawValue:
-        status = "DISCONNECTED"
-    default:
-        break
-    }
+    printerQueue.async { [weak self] in
+        guard let self = self else { return }
+        guard
+            let obj = deviceObj as AnyObject?,
+            let sessionId = self.printerToSessionId[ObjectIdentifier(obj)],
+            let session = self.sessions[sessionId]
+        else { return }
+
+        var status = "UNKNOWN"
+        switch eventType {
+        case EPOS2_EVENT_RECONNECTING.rawValue:
+            status = "RECONNECTING"
+        case EPOS2_EVENT_RECONNECT.rawValue:
+            status = "RECONNECTED"
+        case EPOS2_EVENT_DISCONNECT.rawValue:
+            status = "DISCONNECTED"
+        default:
+            break
+        }
 
-    sendEvent(withName: "onPrinterConnectionChange", body: [
-        "sessionId": session.sessionId,
-        "status": status,
-        "target": session.target ?? ""
-    ])
+        self.sendEvent(withName: "onPrinterConnectionChange", body: [
+            "sessionId": session.sessionId,
+            "status": status,
+            "target": session.target ?? ""
+        ])
+    }
   }
 
   func onPtrStatusChange(_ printerObj: Epos2Printer!, eventType: Int32) {
-    guard
-        let sessionId = printerToSessionId[ObjectIdentifier(printerObj)],
-        let session = sessions[sessionId]
-    else { return }
-
-    sendEvent(withName: "onPrinterStatusChange", body: [
-        "sessionId": session.sessionId,
-        "target": session.target ?? "",
-        "eventType": eventType
-    ])
+    printerQueue.async { [weak self] in
+        guard let self = self else { return }
+        guard
+            let sessionId = self.printerToSessionId[ObjectIdentifier(printerObj)],
+            let session = self.sessions[sessionId]
+        else { return }
+
+        self.sendEvent(withName: "onPrinterStatusChange", body: [
+            "sessionId": session.sessionId,
+            "target": session.target ?? "",
+            "eventType": eventType
+        ])
+    }
   }
 
   func onPtrReceive(_ printerObj: Epos2Printer!, code: Int32, status: Epos2PrinterStatusInfo!, printJobId: String!) {
-      guard
-          let sessionId = printerToSessionId[ObjectIdentifier(printerObj)],
-          let session = sessions[sessionId]
-      else { return }
-
-      session.printTimeoutWork?.cancel()
-      session.printTimeoutWork = nil
-
-      if let resolve = session.printResolve, let reject = session.printReject {
-          if code == EPOS2_CODE_SUCCESS.rawValue {
-              resolve(true)
-          } else {
-              reject("PRINT_FAILURE", "Print finished with error code: \(code)", nil)
+      printerQueue.async { [weak self] in
+          guard let self = self else { return }
+          guard
+              let sessionId = self.printerToSessionId[ObjectIdentifier(printerObj)],
+              let session = self.sessions[sessionId]
+          else { return }
+
+          session.printTimeoutWork?.cancel()
+          session.printTimeoutWork = nil
+
+          if let resolve = session.printResolve, let reject = session.printReject {
+              if code == EPOS2_CODE_SUCCESS.rawValue {
+                  resolve(true)
+              } else {
+                  reject("PRINT_FAILURE", "Print finished with error code: \(code)", nil)
+              }
+              session.printResolve = nil
+              session.printReject = nil
           }
-          session.printResolve = nil
-          session.printReject = nil
-      }
 
-      sendEvent(withName: "onPrinterReceive", body: [
-          "sessionId": session.sessionId,
-          "target": session.target ?? "",
-          "code": code
-      ])
+          self.sendEvent(withName: "onPrinterReceive", body: [
+              "sessionId": session.sessionId,
+              "target": session.target ?? "",
+              "code": code
+          ])
+      }
   }
 
   @objc(print:commands:resolver:rejecter:)
   func print(_ sessionId: String, commands: NSArray, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
-    guard let session = sessions[sessionId], let p = session.printer else {
-        reject("PRINT_ERROR", "Printer not connected", nil)
-        return
-    }
+    printerQueue.async { [weak self] in
+        guard let self = self else { return }
+        guard let session = self.sessions[sessionId], let p = session.printer else {
+            reject("PRINT_ERROR", "Printer not connected", nil)
+            return
+        }
 
-    if session.printResolve != nil {
-        reject("PRINT_BUSY", "Another print job is in progress", nil)
-        return
-    }
+        if session.printResolve != nil {
+            reject("PRINT_BUSY", "Another print job is in progress", nil)
+            return
+        }
 
-    p.clearCommandBuffer()
-
-    for command in commands {
-        if let cmd = command as? NSDictionary, let type = cmd["cmd"] as? String {
-            switch type {
-            case "addText":
-                if let data = cmd["data"] as? String {
-                  if let align = cmd["align"] as? String {
-                      var alignVal = EPOS2_ALIGN_LEFT.rawValue
-                      if align == "center" { alignVal = EPOS2_ALIGN_CENTER.rawValue }
-                      else if align == "right" { alignVal = EPOS2_ALIGN_RIGHT.rawValue }
-                      p.addTextAlign(alignVal)
-                  }
-                  if let bold = cmd["bold"] as? Bool {
-                      p.addTextStyle(EPOS2_PARAM_DEFAULT, ul: EPOS2_PARAM_DEFAULT, em: bold ? EPOS2_TRUE : EPOS2_FALSE, color: EPOS2_PARAM_DEFAULT)
-                  }
-                  if let size = cmd["size"] as? String {
-                  }
-                  p.addText(data)
+        p.clearCommandBuffer()
+
+        for command in commands {
+            if let cmd = command as? NSDictionary, let type = cmd["cmd"] as? String {
+                switch type {
+                case "addText":
+                    if let data = cmd["data"] as? String {
+                      if let align = cmd["align"] as? String {
+                          var alignVal = EPOS2_ALIGN_LEFT.rawValue
+                          if align == "center" { alignVal = EPOS2_ALIGN_CENTER.rawValue }
+                          else if align == "right" { alignVal = EPOS2_ALIGN_RIGHT.rawValue }
+                          p.addTextAlign(alignVal)
+                      }
+                      if let bold = cmd["bold"] as? Bool {
+                          p.addTextStyle(EPOS2_PARAM_DEFAULT, ul: EPOS2_PARAM_DEFAULT, em: bold ? EPOS2_TRUE : EPOS2_FALSE, color: EPOS2_PARAM_DEFAULT)
+                      }
+                      if let size = cmd["size"] as? String {
+                      }
+                      p.addText(data)
+                    }
+                case "addTextAlign":
+                    if let align = cmd["align"] as? String {
+                        var alignVal = EPOS2_ALIGN_LEFT.rawValue
+                        if align == "center" { alignVal = EPOS2_ALIGN_CENTER.rawValue }
+                        else if align == "right" { alignVal = EPOS2_ALIGN_RIGHT.rawValue }
+                        p.addTextAlign(alignVal)
+                    }
+                case "addTextStyle":
+                     if let bold = cmd["bold"] as? Bool {
+                         p.addTextStyle(EPOS2_PARAM_DEFAULT, ul: EPOS2_PARAM_DEFAULT, em: bold ? EPOS2_TRUE : EPOS2_FALSE, color: EPOS2_PARAM_DEFAULT)
+                     }
+                case "addTextSize":
+                    if let w = cmd["width"] as? Int, let h = cmd["height"] as? Int {
+                        p.addTextSize(Int(w), height: Int(h))
+                    }
+                case "addBarcode":
+                    if let data = cmd["data"] as? String, let typeStr = cmd["type"] as? String {
+                        var type = EPOS2_BARCODE_CODE39.rawValue
+                        if typeStr == "UPC-A" { type = EPOS2_BARCODE_UPC_A.rawValue }
+                        else if typeStr == "UPC-E" { type = EPOS2_BARCODE_UPC_E.rawValue }
+                        else if typeStr == "EAN13" { type = EPOS2_BARCODE_EAN13.rawValue }
+                        else if typeStr == "EAN8" { type = EPOS2_BARCODE_EAN8.rawValue }
+                        else if typeStr == "CODE39" { type = EPOS2_BARCODE_CODE39.rawValue }
+                        else if typeStr == "ITF" { type = EPOS2_BARCODE_ITF.rawValue }
+                        else if typeStr == "CODABAR" { type = EPOS2_BARCODE_CODABAR.rawValue }
+
+                        p.addBarcode(data, type: type, hri: EPOS2_HRI_BELOW.rawValue, font: EPOS2_FONT_A.rawValue, width: 2, height: 100)
+                    }
+                case "addSymbol":
+                     if let data = cmd["data"] as? String {
+                         p.addSymbol(data, type: EPOS2_SYMBOL_QRCODE_MODEL_2.rawValue, level: EPOS2_LEVEL_M.rawValue, width: 3, height: 3, size: 0)
+                     }
+                case "addCut":
+                    p.addCut(EPOS2_CUT_FEED.rawValue)
+                case "addFeedLine":
+                    if let line = cmd["line"] as? Int {
+                      p.addFeedLine(Int(line))
+                    }
+                case "addPulse":
+                    p.addPulse(EPOS2_DRAWER_2PIN.rawValue, time: EPOS2_PULSE_100.rawValue)
+                case "addTextLang":
+                    if let lang = cmd["lang"] as? Int {
+                        p.addTextLang(Int32(lang))
+                    }
+                case "addTextFont":
+                    if let font = cmd["font"] as? Int {
+                        p.addTextFont(Int32(font))
+                    }
+                case "addImage":
+                    if let image = self.image(for: cmd) {
+                        let width = Int(image.size.width.rounded(.up))
+                        let height = Int(image.size.height.rounded(.up))
+                        p.add(
+                            image,
+                            x: 0,
+                            y: 0,
+                            width: width,
+                            height: height,
+                            color: EPOS2_COLOR_1.rawValue,
+                            mode: EPOS2_MODE_MONO.rawValue,
+                            halftone: EPOS2_HALFTONE_DITHER.rawValue,
+                            brightness: Double(EPOS2_PARAM_DEFAULT),
+                            compress: EPOS2_COMPRESS_AUTO.rawValue
+                        )
+                    }
+                default:
+                    break
                 }
-            case "addTextAlign":
-                if let align = cmd["align"] as? String {
-                    var alignVal = EPOS2_ALIGN_LEFT.rawValue
-                    if align == "center" { alignVal = EPOS2_ALIGN_CENTER.rawValue }
-                    else if align == "right" { alignVal = EPOS2_ALIGN_RIGHT.rawValue }
-                    p.addTextAlign(alignVal)
-                }
-            case "addTextStyle":
-                 if let bold = cmd["bold"] as? Bool {
-                     p.addTextStyle(EPOS2_PARAM_DEFAULT, ul: EPOS2_PARAM_DEFAULT, em: bold ? EPOS2_TRUE : EPOS2_FALSE, color: EPOS2_PARAM_DEFAULT)
-                 }
-            case "addTextSize":
-                if let w = cmd["width"] as? Int, let h = cmd["height"] as? Int {
-                    p.addTextSize(Int(w), height: Int(h))
-                }
-            case "addBarcode":
-                if let data = cmd["data"] as? String, let typeStr = cmd["type"] as? String {
-                    var type = EPOS2_BARCODE_CODE39.rawValue 
-                    if typeStr == "UPC-A" { type = EPOS2_BARCODE_UPC_A.rawValue }
-                    else if typeStr == "UPC-E" { type = EPOS2_BARCODE_UPC_E.rawValue }
-                    else if typeStr == "EAN13" { type = EPOS2_BARCODE_EAN13.rawValue }
-                    else if typeStr == "EAN8" { type = EPOS2_BARCODE_EAN8.rawValue }
-                    else if typeStr == "CODE39" { type = EPOS2_BARCODE_CODE39.rawValue }
-                    else if typeStr == "ITF" { type = EPOS2_BARCODE_ITF.rawValue }
-                    else if typeStr == "CODABAR" { type = EPOS2_BARCODE_CODABAR.rawValue }
-
-                    p.addBarcode(data, type: type, hri: EPOS2_HRI_BELOW.rawValue, font: EPOS2_FONT_A.rawValue, width: 2, height: 100)
-                }
-            case "addSymbol":
-                 if let data = cmd["data"] as? String {
-                     p.addSymbol(data, type: EPOS2_SYMBOL_QRCODE_MODEL_2.rawValue, level: EPOS2_LEVEL_M.rawValue, width: 3, height: 3, size: 0)
-                 }
-            case "addCut":
-                p.addCut(EPOS2_CUT_FEED.rawValue)
-            case "addFeedLine":
-                if let line = cmd["line"] as? Int {
-                  p.addFeedLine(Int(line))
-                }
-            case "addPulse":
-                p.addPulse(EPOS2_DRAWER_2PIN.rawValue, time: EPOS2_PULSE_100.rawValue)
-            case "addTextLang":
-                if let lang = cmd["lang"] as? Int {
-                    p.addTextLang(Int32(lang))
-                }
-            case "addTextFont":
-                if let font = cmd["font"] as? Int {
-                    p.addTextFont(Int32(font))
-                }
-            case "addImage":
-                if let image = image(for: cmd) {
-                    let width = Int(image.size.width.rounded(.up))
-                    let height = Int(image.size.height.rounded(.up))
-                    p.addImage(
-                        image,
-                        x: 0,
-                        y: 0,
-                        width: width,
-                        height: height,
-                        color: EPOS2_COLOR_1.rawValue,
-                        mode: EPOS2_MODE_MONO.rawValue,
-                        halftone: EPOS2_HALFTONE_DITHER.rawValue,
-                        brightness: Double(EPOS2_PARAM_DEFAULT),
-                        compress: EPOS2_COMPRESS_AUTO.rawValue
-                    )
-                }
-            default:
-                break
             }
         }
-    }
 
-    session.printResolve = resolve
-    session.printReject = reject
-
-    let result = p.sendData(Int(EPOS2_PARAM_DEFAULT))
-    if result != EPOS2_SUCCESS.rawValue {
-        let errorMsg = getErrorDescription(result)
-        session.printResolve = nil
-        session.printReject = nil
-        reject("PRINT_ERROR", "Failed to send data: \(result) (\(errorMsg))", nil)
-    } else {
-        let timeoutWork = DispatchWorkItem { [weak self] in
-            guard
-                let self = self,
-                let timedSession = self.sessions[sessionId]
-            else { return }
-
-            if let reject = timedSession.printReject {
-                reject("PRINT_TIMEOUT", "Print timed out waiting for printer response", nil)
+        session.printResolve = resolve
+        session.printReject = reject
+
+        let result = p.sendData(Int(EPOS2_PARAM_DEFAULT))
+        if result != EPOS2_SUCCESS.rawValue {
+            let errorMsg = self.getErrorDescription(result)
+            session.printResolve = nil
+            session.printReject = nil
+            reject("PRINT_ERROR", "Failed to send data: \(result) (\(errorMsg))", nil)
+        } else {
+            let timeoutWork = DispatchWorkItem { [weak self] in
+                guard let self = self else { return }
+
+                self.printerQueue.async { [weak self] in
+                    guard
+                        let self = self,
+                        let timedSession = self.sessions[sessionId]
+                    else { return }
+
+                    if let reject = timedSession.printReject {
+                        reject("PRINT_TIMEOUT", "Print timed out waiting for printer response", nil)
+                    }
+                    timedSession.printResolve = nil
+                    timedSession.printReject = nil
+                    timedSession.printTimeoutWork = nil
+                    timedSession.printer?.clearCommandBuffer()
+                }
             }
-            timedSession.printResolve = nil
-            timedSession.printReject = nil
-            timedSession.printTimeoutWork = nil
-            timedSession.printer?.clearCommandBuffer()
+            session.printTimeoutWork = timeoutWork
+            DispatchQueue.main.asyncAfter(deadline: .now() + 30, execute: timeoutWork)
         }
-        session.printTimeoutWork = timeoutWork
-        DispatchQueue.main.asyncAfter(deadline: .now() + 30, execute: timeoutWork)
     }
   }
 
   @objc(getStatus:resolver:rejecter:)
   func getStatus(_ sessionId: String, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
-    guard let session = sessions[sessionId], let p = session.printer else {
-        reject("STATUS_ERROR", "Printer not connected", nil)
-        return
-    }
+    printerQueue.async { [weak self] in
+        guard let self = self else { return }
+        guard let session = self.sessions[sessionId], let p = session.printer else {
+            reject("STATUS_ERROR", "Printer not connected", nil)
+            return
+        }
 
-    if let status = p.getStatus() {
-        let statusDict: [String: Any] = [
-            "online": status.connection == EPOS2_TRUE,
-            "coverOpen": status.coverOpen == EPOS2_TRUE,
-            "paper": status.paper == EPOS2_PAPER_EMPTY.rawValue ? "EMPTY" : (status.paper == EPOS2_PAPER_NEAR_END.rawValue ? "NEAR_EMPTY" : "OK"),
-            "paperEmpty": status.paper == EPOS2_PAPER_EMPTY.rawValue, // legacy compat
-            "drawerOpen": status.drawer == EPOS2_DRAWER_HIGH.rawValue, // HIGH typically means open/signal high depending on wiring, assuming HIGH = Open for now based on common usage
-            "errorStatus": status.errorStatus == EPOS2_MECHANICAL_ERR.rawValue ? "MECHANICAL_ERR" : (status.errorStatus == EPOS2_AUTOCUTTER_ERR.rawValue ? "AUTOCUTTER_ERR" : "NONE")
-        ]
-        resolve(statusDict)
-    } else {
-        reject("STATUS_ERROR", "Failed to retrieve status", nil)
+        if let status = p.getStatus() {
+            let statusDict: [String: Any] = [
+                "online": status.connection == EPOS2_TRUE,
+                "coverOpen": status.coverOpen == EPOS2_TRUE,
+                "paper": status.paper == EPOS2_PAPER_EMPTY.rawValue ? "EMPTY" : (status.paper == EPOS2_PAPER_NEAR_END.rawValue ? "NEAR_EMPTY" : "OK"),
+                "paperEmpty": status.paper == EPOS2_PAPER_EMPTY.rawValue,
+                "drawerOpen": status.drawer == EPOS2_DRAWER_HIGH.rawValue,
+                "errorStatus": status.errorStatus == EPOS2_MECHANICAL_ERR.rawValue ? "MECHANICAL_ERR" : (status.errorStatus == EPOS2_AUTOCUTTER_ERR.rawValue ? "AUTOCUTTER_ERR" : "NONE")
+            ]
+            resolve(statusDict)
+        } else {
+            reject("STATUS_ERROR", "Failed to retrieve status", nil)
+        }
     }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@munchi_oy/react-native-epson-printer",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "Munchi Printer SDK Bridge",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",