@munchi_oy/react-native-epson-printer 1.0.0

package/android/src/main/java/com/munchiepsonprinter/MunchiEpsonModule.java

@@ -0,0 +1,1212 @@
+package com.munchiepsonprinter;
+
+import android.Manifest;
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothManager;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.location.LocationManager;
+import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Base64;
+
+import androidx.annotation.NonNull;
+
+import com.epson.epos2.ConnectionListener;
+import com.epson.epos2.Epos2CallbackCode;
+import com.epson.epos2.Epos2Exception;
+import com.epson.epos2.discovery.DeviceInfo;
+import com.epson.epos2.discovery.Discovery;
+import com.epson.epos2.discovery.DiscoveryListener;
+import com.epson.epos2.discovery.FilterOption;
+import com.epson.epos2.printer.Printer;
+import com.epson.epos2.printer.PrinterStatusInfo;
+import com.epson.epos2.printer.ReceiveListener;
+import com.epson.epos2.printer.StatusChangeListener;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableType;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.IdentityHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+
+public class MunchiEpsonModule extends ReactContextBaseJavaModule implements ConnectionListener, StatusChangeListener, ReceiveListener, DiscoveryListener {
+    private static final String MODULE_NAME = "MunchiEpsonModule";
+    private static final String EVENT_PRINTER_STATUS_CHANGE = "onPrinterStatusChange";
+    private static final String EVENT_PRINTER_CONNECTION_CHANGE = "onPrinterConnectionChange";
+    private static final String EVENT_PRINTER_RECEIVE = "onPrinterReceive";
+
+    private static final int DEFAULT_DISCOVERY_TIMEOUT_MS = 5000;
+    private static final int PRINT_TIMEOUT_MS = 30000;
+    private static final int CONNECTION_CACHE_TTL_MS = 120000;
+
+    private final ReactApplicationContext reactContext;
+    private final Handler mainHandler = new Handler(Looper.getMainLooper());
+    private final Object lock = new Object();
+
+    private final Map<String, EpsonSession> sessions = new HashMap<>();
+    private final Map<Printer, String> printerToSessionId = new IdentityHashMap<>();
+    private final Map<String, String> targetToSessionId = new HashMap<>();
+    private final Map<String, CachedConnection> cachedConnections = new HashMap<>();
+
+    private Promise discoveryPromise;
+    private WritableArray discoveredPrinters;
+    private Set<String> discoveredTargets;
+    private Runnable discoveryTimeoutRunnable;
+
+    public MunchiEpsonModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        this.reactContext = reactContext;
+    }
+
+    @NonNull
+    @Override
+    public String getName() {
+        return MODULE_NAME;
+    }
+
+    @ReactMethod
+    public void addListener(String eventName) {
+    }
+
+    @ReactMethod
+    public void removeListeners(double count) {
+    }
+
+    @ReactMethod
+    public void initSession(Promise promise) {
+        String sessionId = UUID.randomUUID().toString();
+        synchronized (lock) {
+            sessions.put(sessionId, new EpsonSession(sessionId));
+        }
+        promise.resolve(sessionId);
+    }
+
+    @ReactMethod
+    public void disposeSession(String sessionId, Promise promise) {
+        EpsonSession session;
+        synchronized (lock) {
+            session = sessions.remove(sessionId);
+        }
+
+        if (session != null) {
+            teardownPrinter(session, true);
+        }
+
+        promise.resolve(null);
+    }
+
+    @ReactMethod
+    public void discover(ReadableMap params, Promise promise) {
+        if (!ensureDiscoverReadiness(promise)) {
+            return;
+        }
+
+        int timeout = DEFAULT_DISCOVERY_TIMEOUT_MS;
+        if (params != null && params.hasKey("timeout") && !params.isNull("timeout")) {
+            timeout = (int) params.getDouble("timeout");
+        }
+        if (timeout <= 0) {
+            timeout = DEFAULT_DISCOVERY_TIMEOUT_MS;
+        }
+
+        synchronized (lock) {
+            if (discoveryPromise != null) {
+                promise.reject("DISCOVERY_BUSY", "Discovery is already in progress");
+                return;
+            }
+            discoveryPromise = promise;
+            discoveredPrinters = Arguments.createArray();
+            discoveredTargets = new HashSet<>();
+        }
+
+        try {
+            stopDiscoveryQuietly();
+
+            FilterOption filter = new FilterOption();
+            filter.setPortType(Discovery.PORTTYPE_ALL);
+            filter.setDeviceType(Discovery.TYPE_PRINTER);
+            filter.setEpsonFilter(Discovery.FILTER_NAME);
+            filter.setUsbDeviceName(Discovery.TRUE);
+
+            Discovery.start(reactContext.getApplicationContext(), filter, this);
+
+            Runnable timeoutRunnable = this::stopDiscoveryAndResolve;
+            synchronized (lock) {
+                discoveryTimeoutRunnable = timeoutRunnable;
+            }
+            mainHandler.postDelayed(timeoutRunnable, timeout);
+        } catch (Exception error) {
+            Promise pending;
+            synchronized (lock) {
+                pending = discoveryPromise;
+                clearDiscoveryStateLocked();
+            }
+            if (pending != null) {
+                rejectWithEposError(pending, "DISCOVERY_ERROR", "Failed to start discovery", error);
+            }
+        }
+    }
+
+    @ReactMethod
+    public void connect(String sessionId, String target, double timeout, double model, double lang, Promise promise) {
+        int safeModel = normalizeModel((int) model);
+        int safeLang = normalizeLanguage((int) lang);
+
+        EpsonSession session;
+        CachedConnection cachedConnection;
+        synchronized (lock) {
+            session = sessions.get(sessionId);
+            if (session == null) {
+                promise.reject("SESSION_ERROR", "Session not found");
+                return;
+            }
+
+            String ownerSessionId = targetToSessionId.get(target);
+            if (ownerSessionId != null && !ownerSessionId.equals(sessionId)) {
+                promise.reject("TARGET_IN_USE", "Target is already connected by another session: " + target);
+                return;
+            }
+        }
+
+        if (!ensureBluetoothOperationReadiness(target, promise)) {
+            return;
+        }
+
+        synchronized (lock) {
+            CachedConnection existingCache = cachedConnections.remove(target);
+            if (existingCache != null) {
+                cancelCacheEvictionLocked(existingCache);
+            }
+            cachedConnection = existingCache;
+        }
+
+        teardownPrinter(session, true);
+
+        Printer printer = null;
+        if (cachedConnection != null) {
+            if (cachedConnection.model == safeModel
+                && cachedConnection.lang == safeLang
+                && isConnectionHealthy(cachedConnection.printer)) {
+                printer = cachedConnection.printer;
+            } else {
+                disconnectPrinterQuietly(cachedConnection.printer);
+            }
+        }
+
+        if (printer != null) {
+            synchronized (lock) {
+                EpsonSession latestSession = sessions.get(sessionId);
+                if (latestSession == null) {
+                    disconnectPrinterQuietly(printer);
+                    promise.reject("SESSION_ERROR", "Session disposed while connecting");
+                    return;
+                }
+
+                latestSession.printer = printer;
+                latestSession.target = target;
+                latestSession.model = safeModel;
+                latestSession.lang = safeLang;
+                printerToSessionId.put(printer, sessionId);
+                targetToSessionId.put(target, sessionId);
+            }
+            promise.resolve(null);
+            return;
+        }
+
+        try {
+            printer = new Printer(safeModel, safeLang, reactContext.getApplicationContext());
+            printer.setConnectionEventListener(this);
+            printer.setStatusChangeEventListener(this);
+            printer.setReceiveEventListener(this);
+            printer.connect(target, (int) timeout);
+        } catch (Exception error) {
+            if (printer != null) {
+                try {
+                    printer.setReceiveEventListener(null);
+                    printer.setConnectionEventListener(null);
+                    printer.setStatusChangeEventListener(null);
+                    printer.disconnect();
+                } catch (Exception ignored) {
+                }
+            }
+            rejectWithEposError(promise, "CONNECT_ERROR", "Failed to connect", error);
+            return;
+        }
+
+        synchronized (lock) {
+            EpsonSession latestSession = sessions.get(sessionId);
+            if (latestSession == null) {
+                try {
+                    printer.disconnect();
+                } catch (Exception ignored) {
+                }
+                promise.reject("SESSION_ERROR", "Session disposed while connecting");
+                return;
+            }
+
+            latestSession.printer = printer;
+            latestSession.target = target;
+            latestSession.model = safeModel;
+            latestSession.lang = safeLang;
+            printerToSessionId.put(printer, sessionId);
+            targetToSessionId.put(target, sessionId);
+        }
+
+        promise.resolve(null);
+    }
+
+    @ReactMethod
+    public void disconnect(String sessionId, Promise promise) {
+        EpsonSession session;
+        synchronized (lock) {
+            session = sessions.get(sessionId);
+        }
+
+        if (session == null) {
+            promise.resolve(true);
+            return;
+        }
+
+        teardownPrinter(session, true);
+        promise.resolve(true);
+    }
+
+    @ReactMethod
+    public void print(String sessionId, ReadableArray commands, Promise promise) {
+        EpsonSession session;
+        Printer printer;
+        synchronized (lock) {
+            session = sessions.get(sessionId);
+            if (session == null || session.printer == null) {
+                promise.reject("PRINT_ERROR", "Printer not connected");
+                return;
+            }
+            if (session.printPromise != null) {
+                promise.reject("PRINT_BUSY", "Another print job is in progress");
+                return;
+            }
+            printer = session.printer;
+        }
+
+        if (!ensureBluetoothOperationReadiness(session.target, promise)) {
+            return;
+        }
+
+        PrinterStatusInfo status;
+        try {
+            status = printer.getStatus();
+        } catch (Exception error) {
+            detachUnhealthyPrinter(sessionId, printer);
+            rejectWithEposError(promise, "PRINT_ERROR", "Printer is not reachable", error);
+            return;
+        }
+
+        if (!isStatusReady(status)) {
+            detachUnhealthyPrinter(sessionId, printer);
+            promise.reject("PRINTER_OFFLINE", "Printer is offline or unreachable");
+            return;
+        }
+
+        try {
+            printer.clearCommandBuffer();
+            applyCommands(printer, commands);
+        } catch (Exception error) {
+            rejectWithEposError(promise, "PRINT_ERROR", "Failed to build print data", error);
+            return;
+        }
+
+        synchronized (lock) {
+            session.printPromise = promise;
+            Runnable timeoutRunnable = () -> handlePrintTimeout(sessionId);
+            session.printTimeoutRunnable = timeoutRunnable;
+            mainHandler.postDelayed(timeoutRunnable, PRINT_TIMEOUT_MS);
+        }
+
+        try {
+            printer.sendData(Printer.PARAM_DEFAULT);
+        } catch (Exception error) {
+            detachUnhealthyPrinter(sessionId, printer);
+            Promise pending = null;
+            synchronized (lock) {
+                EpsonSession latestSession = sessions.get(sessionId);
+                if (latestSession != null) {
+                    pending = latestSession.printPromise;
+                    cancelPrintTimeoutLocked(latestSession);
+                    latestSession.printPromise = null;
+                    latestSession.printTimeoutRunnable = null;
+                }
+            }
+            if (pending != null) {
+                rejectWithEposError(pending, "PRINT_ERROR", "Failed to send data", error);
+            }
+        }
+    }
+
+    @ReactMethod
+    public void getStatus(String sessionId, Promise promise) {
+        EpsonSession session;
+        synchronized (lock) {
+            session = sessions.get(sessionId);
+        }
+
+        if (session == null || session.printer == null) {
+            promise.reject("STATUS_ERROR", "Printer not connected");
+            return;
+        }
+
+        if (!ensureBluetoothOperationReadiness(session.target, promise)) {
+            return;
+        }
+
+        try {
+            PrinterStatusInfo status = session.printer.getStatus();
+            if (status == null) {
+                promise.reject("STATUS_ERROR", "Failed to retrieve status");
+                return;
+            }
+
+            WritableMap statusMap = Arguments.createMap();
+            boolean paperEmpty = status.getPaper() == Printer.PAPER_EMPTY;
+            statusMap.putBoolean("online", isStatusReady(status));
+            statusMap.putBoolean("coverOpen", status.getCoverOpen() == Printer.TRUE);
+            statusMap.putBoolean("paperEmpty", paperEmpty);
+            statusMap.putString("paper", mapPaperStatus(status.getPaper()));
+            statusMap.putBoolean("drawerOpen", status.getDrawer() == Printer.DRAWER_HIGH);
+            statusMap.putString("errorStatus", mapErrorStatus(status.getErrorStatus()));
+
+            promise.resolve(statusMap);
+        } catch (Exception error) {
+            rejectWithEposError(promise, "STATUS_ERROR", "Failed to retrieve status", error);
+        }
+    }
+
+    @Override
+    public void onConnection(Object deviceObj, int eventType) {
+        if (!(deviceObj instanceof Printer)) {
+            return;
+        }
+
+        String sessionId;
+        EpsonSession session;
+        String target;
+        synchronized (lock) {
+            sessionId = printerToSessionId.get((Printer) deviceObj);
+            session = sessionId == null ? null : sessions.get(sessionId);
+            target = session != null ? session.target : null;
+            if (eventType == ConnectionListener.EVENT_DISCONNECT && session != null) {
+                printerToSessionId.remove((Printer) deviceObj);
+                if (target != null && session.sessionId.equals(targetToSessionId.get(target))) {
+                    targetToSessionId.remove(target);
+                }
+                session.printer = null;
+                session.target = null;
+                session.model = -1;
+                session.lang = -1;
+            }
+        }
+
+        if (session == null) {
+            return;
+        }
+
+        WritableMap body = Arguments.createMap();
+        body.putString("sessionId", session.sessionId);
+        body.putString("status", mapConnectionEvent(eventType));
+        body.putString("target", target == null ? "" : target);
+        emitEvent(EVENT_PRINTER_CONNECTION_CHANGE, body);
+    }
+
+    @Override
+    public void onPtrStatusChange(Printer printer, int eventType) {
+        String sessionId;
+        EpsonSession session;
+        synchronized (lock) {
+            sessionId = printerToSessionId.get(printer);
+            session = sessionId == null ? null : sessions.get(sessionId);
+        }
+
+        if (session == null) {
+            return;
+        }
+
+        WritableMap body = Arguments.createMap();
+        body.putString("sessionId", session.sessionId);
+        body.putString("target", session.target == null ? "" : session.target);
+        body.putInt("eventType", eventType);
+        emitEvent(EVENT_PRINTER_STATUS_CHANGE, body);
+    }
+
+    @Override
+    public void onPtrReceive(Printer printer, int code, PrinterStatusInfo status, String printJobId) {
+        EpsonSession session;
+        Promise printPromise = null;
+        synchronized (lock) {
+            String sessionId = printerToSessionId.get(printer);
+            session = sessionId == null ? null : sessions.get(sessionId);
+            if (session != null) {
+                printPromise = session.printPromise;
+                cancelPrintTimeoutLocked(session);
+                session.printPromise = null;
+                session.printTimeoutRunnable = null;
+            }
+        }
+
+        if (session == null) {
+            return;
+        }
+
+        if (printPromise != null) {
+            if (code == Epos2CallbackCode.CODE_SUCCESS) {
+                printPromise.resolve(true);
+            } else {
+                printPromise.reject("PRINT_FAILURE", "Print finished with error code: " + code);
+            }
+        }
+
+        WritableMap body = Arguments.createMap();
+        body.putString("sessionId", session.sessionId);
+        body.putString("target", session.target == null ? "" : session.target);
+        body.putInt("code", code);
+        emitEvent(EVENT_PRINTER_RECEIVE, body);
+    }
+
+    @Override
+    public void onDiscovery(DeviceInfo deviceInfo) {
+        if (deviceInfo == null) {
+            return;
+        }
+
+        synchronized (lock) {
+            if (discoveryPromise == null || discoveredPrinters == null || discoveredTargets == null) {
+                return;
+            }
+
+            String target = valueOrEmpty(deviceInfo.getTarget());
+            if (discoveredTargets.contains(target)) {
+                return;
+            }
+            discoveredTargets.add(target);
+
+            WritableMap printer = Arguments.createMap();
+            printer.putString("target", target);
+            printer.putString("name", valueOrEmpty(deviceInfo.getDeviceName()));
+            printer.putString("macAddress", valueOrEmpty(deviceInfo.getMacAddress()));
+            printer.putString("ipAddress", valueOrEmpty(deviceInfo.getIpAddress()));
+            printer.putString("bdAddress", valueOrEmpty(deviceInfo.getBdAddress()));
+            printer.putString("type", "EPSON");
+
+            discoveredPrinters.pushMap(printer);
+        }
+    }
+
+    @Override
+    public void invalidate() {
+        stopDiscoveryQuietly();
+
+        synchronized (lock) {
+            for (EpsonSession session : sessions.values()) {
+                teardownPrinter(session, false);
+            }
+            sessions.clear();
+            printerToSessionId.clear();
+            targetToSessionId.clear();
+            clearCachedConnectionsLocked();
+            clearDiscoveryStateLocked();
+        }
+
+        super.invalidate();
+    }
+
+    private void stopDiscoveryAndResolve() {
+        Promise promise;
+        WritableArray results;
+        synchronized (lock) {
+            promise = discoveryPromise;
+            results = discoveredPrinters;
+            clearDiscoveryStateLocked();
+        }
+
+        stopDiscoveryQuietly();
+
+        if (promise != null) {
+            promise.resolve(results == null ? Arguments.createArray() : results);
+        }
+    }
+
+    private void stopDiscoveryQuietly() {
+        synchronized (lock) {
+            if (discoveryTimeoutRunnable != null) {
+                mainHandler.removeCallbacks(discoveryTimeoutRunnable);
+                discoveryTimeoutRunnable = null;
+            }
+        }
+
+        while (true) {
+            try {
+                Discovery.stop();
+                return;
+            } catch (Epos2Exception error) {
+                if (error.getErrorStatus() != Epos2Exception.ERR_PROCESSING) {
+                    return;
+                }
+            } catch (Exception ignored) {
+                return;
+            }
+        }
+    }
+
+    private void clearDiscoveryStateLocked() {
+        discoveryPromise = null;
+        discoveredPrinters = null;
+        discoveredTargets = null;
+        discoveryTimeoutRunnable = null;
+    }
+
+    private void teardownPrinter(EpsonSession session, boolean disconnect) {
+        Promise pendingPromise = null;
+        Printer printer;
+        String target;
+        int model;
+        int lang;
+
+        synchronized (lock) {
+            if (session.printPromise != null) {
+                pendingPromise = session.printPromise;
+            }
+            cancelPrintTimeoutLocked(session);
+            session.printPromise = null;
+            session.printTimeoutRunnable = null;
+
+            if (session.target != null && session.sessionId.equals(targetToSessionId.get(session.target))) {
+                targetToSessionId.remove(session.target);
+            }
+
+            if (session.printer != null) {
+                printerToSessionId.remove(session.printer);
+            }
+
+            target = session.target;
+            model = session.model;
+            lang = session.lang;
+            printer = session.printer;
+            session.printer = null;
+            session.target = null;
+            session.model = -1;
+            session.lang = -1;
+        }
+
+        if (pendingPromise != null) {
+            pendingPromise.reject("PRINT_CANCELED", "Print canceled because printer session was torn down");
+        }
+
+        if (printer == null) {
+            return;
+        }
+
+        if (disconnect && target != null && model >= 0 && lang >= 0) {
+            synchronized (lock) {
+                if (!targetToSessionId.containsKey(target)) {
+                    cacheConnectionLocked(target, model, lang, printer);
+                    return;
+                }
+            }
+        }
+
+        disconnectPrinterQuietly(printer);
+    }
+
+    private void cacheConnectionLocked(String target, int model, int lang, Printer printer) {
+        CachedConnection existing = cachedConnections.remove(target);
+        if (existing != null) {
+            cancelCacheEvictionLocked(existing);
+            disconnectPrinterQuietly(existing.printer);
+        }
+
+        CachedConnection cached = new CachedConnection(target, model, lang, printer);
+        Runnable evictionRunnable = () -> evictCachedConnection(target);
+        cached.evictionRunnable = evictionRunnable;
+        cachedConnections.put(target, cached);
+        mainHandler.postDelayed(evictionRunnable, CONNECTION_CACHE_TTL_MS);
+    }
+
+    private void evictCachedConnection(String target) {
+        CachedConnection cached;
+        synchronized (lock) {
+            cached = cachedConnections.remove(target);
+            if (cached == null) {
+                return;
+            }
+            cancelCacheEvictionLocked(cached);
+        }
+        disconnectPrinterQuietly(cached.printer);
+    }
+
+    private void cancelCacheEvictionLocked(CachedConnection cached) {
+        if (cached.evictionRunnable != null) {
+            mainHandler.removeCallbacks(cached.evictionRunnable);
+            cached.evictionRunnable = null;
+        }
+    }
+
+    private void clearCachedConnectionsLocked() {
+        for (CachedConnection cached : cachedConnections.values()) {
+            cancelCacheEvictionLocked(cached);
+            disconnectPrinterQuietly(cached.printer);
+        }
+        cachedConnections.clear();
+    }
+
+    private boolean isConnectionHealthy(Printer printer) {
+        try {
+            PrinterStatusInfo status = printer.getStatus();
+            return isStatusReady(status);
+        } catch (Exception ignored) {
+            return false;
+        }
+    }
+
+    private boolean isStatusReady(PrinterStatusInfo status) {
+        return status != null
+            && status.getConnection() == Printer.TRUE
+            && status.getOnline() == Printer.TRUE;
+    }
+
+    private void detachUnhealthyPrinter(String sessionId, Printer printer) {
+        EpsonSession session;
+        synchronized (lock) {
+            session = sessions.get(sessionId);
+            if (session == null || session.printer != printer) {
+                return;
+            }
+        }
+        teardownPrinter(session, false);
+    }
+
+    private void disconnectPrinterQuietly(Printer printer) {
+        try {
+            printer.setReceiveEventListener(null);
+            printer.setConnectionEventListener(null);
+            printer.setStatusChangeEventListener(null);
+            printer.disconnect();
+        } catch (Exception ignored) {
+        }
+    }
+
+    private void cancelPrintTimeoutLocked(EpsonSession session) {
+        if (session.printTimeoutRunnable != null) {
+            mainHandler.removeCallbacks(session.printTimeoutRunnable);
+        }
+    }
+
+    private void handlePrintTimeout(String sessionId) {
+        Promise pendingPromise = null;
+        EpsonSession session;
+
+        synchronized (lock) {
+            session = sessions.get(sessionId);
+            if (session != null) {
+                pendingPromise = session.printPromise;
+                session.printPromise = null;
+                session.printTimeoutRunnable = null;
+            }
+        }
+
+        if (pendingPromise != null) {
+            pendingPromise.reject("PRINT_TIMEOUT", "Print timed out waiting for printer response");
+        }
+
+        if (session != null && session.printer != null) {
+            detachUnhealthyPrinter(sessionId, session.printer);
+        }
+    }
+
+    private void applyCommands(Printer printer, ReadableArray commands) throws Epos2Exception {
+        if (commands == null) {
+            return;
+        }
+
+        for (int i = 0; i < commands.size(); i++) {
+            if (commands.getType(i) != ReadableType.Map) {
+                continue;
+            }
+
+            ReadableMap command = commands.getMap(i);
+            if (command == null || !command.hasKey("cmd") || command.isNull("cmd")) {
+                continue;
+            }
+
+            String type = command.getString("cmd");
+            if (type == null) {
+                continue;
+            }
+
+            switch (type) {
+                case "addText":
+                    applyTextCommand(printer, command);
+                    break;
+                case "addTextAlign":
+                    applyAlignCommand(printer, command);
+                    break;
+                case "addTextStyle":
+                    applyTextStyleCommand(printer, command);
+                    break;
+                case "addTextSize":
+                    applyTextSizeCommand(printer, command);
+                    break;
+                case "addBarcode":
+                    applyBarcodeCommand(printer, command);
+                    break;
+                case "addSymbol":
+                    applySymbolCommand(printer, command);
+                    break;
+                case "addCut":
+                    printer.addCut(Printer.CUT_FEED);
+                    break;
+                case "addFeedLine":
+                    printer.addFeedLine(optionalInt(command, "line", 1));
+                    break;
+                case "addPulse":
+                    printer.addPulse(Printer.DRAWER_2PIN, Printer.PULSE_100);
+                    break;
+                case "addTextLang":
+                    if (hasNumeric(command, "lang")) {
+                        printer.addTextLang((int) command.getDouble("lang"));
+                    }
+                    break;
+                case "addTextFont":
+                    if (hasNumeric(command, "font")) {
+                        printer.addTextFont((int) command.getDouble("font"));
+                    }
+                    break;
+                case "addImage":
+                    applyImageCommand(printer, command);
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+
+    private void applyTextCommand(Printer printer, ReadableMap command) throws Epos2Exception {
+        String data = optionalString(command, "data");
+        if (data == null) {
+            return;
+        }
+
+        if (command.hasKey("align") && !command.isNull("align")) {
+            applyAlignCommand(printer, command);
+        }
+
+        if (command.hasKey("bold") && !command.isNull("bold") && command.getType("bold") == ReadableType.Boolean) {
+            boolean bold = command.getBoolean("bold");
+            printer.addTextStyle(Printer.PARAM_DEFAULT, Printer.PARAM_DEFAULT, bold ? Printer.TRUE : Printer.FALSE, Printer.PARAM_DEFAULT);
+        }
+
+        printer.addText(data);
+    }
+
+    private void applyAlignCommand(Printer printer, ReadableMap command) throws Epos2Exception {
+        String align = optionalString(command, "align");
+        int alignValue = Printer.ALIGN_LEFT;
+        if ("center".equals(align)) {
+            alignValue = Printer.ALIGN_CENTER;
+        } else if ("right".equals(align)) {
+            alignValue = Printer.ALIGN_RIGHT;
+        }
+        printer.addTextAlign(alignValue);
+    }
+
+    private void applyTextStyleCommand(Printer printer, ReadableMap command) throws Epos2Exception {
+        if (command.hasKey("bold") && !command.isNull("bold") && command.getType("bold") == ReadableType.Boolean) {
+            boolean bold = command.getBoolean("bold");
+            printer.addTextStyle(Printer.PARAM_DEFAULT, Printer.PARAM_DEFAULT, bold ? Printer.TRUE : Printer.FALSE, Printer.PARAM_DEFAULT);
+        }
+    }
+
+    private void applyTextSizeCommand(Printer printer, ReadableMap command) throws Epos2Exception {
+        int width = optionalInt(command, "width", 1);
+        int height = optionalInt(command, "height", 1);
+        printer.addTextSize(width, height);
+    }
+
+    private void applyBarcodeCommand(Printer printer, ReadableMap command) throws Epos2Exception {
+        String data = optionalString(command, "data");
+        if (data == null) {
+            return;
+        }
+
+        String barcodeType = optionalString(command, "type");
+        int type = Printer.BARCODE_CODE39;
+        if ("UPC-A".equals(barcodeType)) {
+            type = Printer.BARCODE_UPC_A;
+        } else if ("UPC-E".equals(barcodeType)) {
+            type = Printer.BARCODE_UPC_E;
+        } else if ("EAN13".equals(barcodeType)) {
+            type = Printer.BARCODE_EAN13;
+        } else if ("EAN8".equals(barcodeType)) {
+            type = Printer.BARCODE_EAN8;
+        } else if ("ITF".equals(barcodeType)) {
+            type = Printer.BARCODE_ITF;
+        } else if ("CODABAR".equals(barcodeType)) {
+            type = Printer.BARCODE_CODABAR;
+        }
+
+        int width = optionalInt(command, "width", 2);
+        int height = optionalInt(command, "height", 100);
+        printer.addBarcode(data, type, Printer.HRI_BELOW, Printer.FONT_A, width, height);
+    }
+
+    private void applySymbolCommand(Printer printer, ReadableMap command) throws Epos2Exception {
+        String data = optionalString(command, "data");
+        if (data == null) {
+            return;
+        }
+
+        String levelText = optionalString(command, "level");
+        int level = Printer.LEVEL_M;
+        if ("L".equalsIgnoreCase(levelText)) {
+            level = Printer.LEVEL_L;
+        } else if ("Q".equalsIgnoreCase(levelText)) {
+            level = Printer.LEVEL_Q;
+        } else if ("H".equalsIgnoreCase(levelText)) {
+            level = Printer.LEVEL_H;
+        }
+
+        int width = optionalInt(command, "width", 3);
+        printer.addSymbol(data, Printer.SYMBOL_QRCODE_MODEL_2, level, width, width, 0);
+    }
+
+    private void applyImageCommand(Printer printer, ReadableMap command) throws Epos2Exception {
+        String base64 = optionalString(command, "data");
+        if (base64 == null) {
+            return;
+        }
+
+        byte[] imageBytes;
+        try {
+            imageBytes = Base64.decode(base64, Base64.DEFAULT);
+        } catch (Exception ignored) {
+            return;
+        }
+
+        Bitmap bitmap = BitmapFactory.decodeByteArray(imageBytes, 0, imageBytes.length);
+        if (bitmap == null) {
+            return;
+        }
+
+        printer.addImage(
+            bitmap,
+            0,
+            0,
+            bitmap.getWidth(),
+            bitmap.getHeight(),
+            Printer.COLOR_1,
+            Printer.MODE_MONO,
+            Printer.HALFTONE_DITHER,
+            Printer.PARAM_DEFAULT,
+            Printer.COMPRESS_AUTO
+        );
+    }
+
+    private boolean hasNumeric(ReadableMap map, String key) {
+        return map.hasKey(key) && !map.isNull(key) && map.getType(key) == ReadableType.Number;
+    }
+
+    private int optionalInt(ReadableMap map, String key, int fallback) {
+        if (hasNumeric(map, key)) {
+            return (int) map.getDouble(key);
+        }
+        return fallback;
+    }
+
+    private String optionalString(ReadableMap map, String key) {
+        if (!map.hasKey(key) || map.isNull(key) || map.getType(key) != ReadableType.String) {
+            return null;
+        }
+        return map.getString(key);
+    }
+
+    private String valueOrEmpty(String value) {
+        return value == null ? "" : value;
+    }
+
+    private String mapConnectionEvent(int eventType) {
+        if (eventType == ConnectionListener.EVENT_RECONNECTING) {
+            return "RECONNECTING";
+        }
+        if (eventType == ConnectionListener.EVENT_RECONNECT) {
+            return "RECONNECTED";
+        }
+        if (eventType == ConnectionListener.EVENT_DISCONNECT) {
+            return "DISCONNECTED";
+        }
+        return "UNKNOWN";
+    }
+
+    private String mapPaperStatus(int paperStatus) {
+        if (paperStatus == Printer.PAPER_EMPTY) {
+            return "EMPTY";
+        }
+        if (paperStatus == Printer.PAPER_NEAR_END) {
+            return "NEAR_EMPTY";
+        }
+        return "OK";
+    }
+
+    private String mapErrorStatus(int errorStatus) {
+        if (errorStatus == Printer.MECHANICAL_ERR) {
+            return "MECHANICAL_ERR";
+        }
+        if (errorStatus == Printer.AUTOCUTTER_ERR) {
+            return "AUTOCUTTER_ERR";
+        }
+        return "NONE";
+    }
+
+    private boolean ensureDiscoverReadiness(Promise promise) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            if (!hasPermission(Manifest.permission.BLUETOOTH_SCAN)) {
+                promise.reject("PERMISSION_DENIED", "Missing Android permission: android.permission.BLUETOOTH_SCAN");
+                return false;
+            }
+            return true;
+        }
+
+        if (!hasPermission(Manifest.permission.ACCESS_FINE_LOCATION)) {
+            promise.reject("PERMISSION_DENIED", "Missing Android permission: android.permission.ACCESS_FINE_LOCATION");
+            return false;
+        }
+
+        if (!isLocationEnabled()) {
+            promise.reject("LOCATION_DISABLED", "Location services must be enabled for Bluetooth discovery");
+            return false;
+        }
+
+        return true;
+    }
+
+    private boolean ensureBluetoothOperationReadiness(String target, Promise promise) {
+        if (!isBluetoothTarget(target)) {
+            return true;
+        }
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            if (!hasPermission(Manifest.permission.BLUETOOTH_CONNECT)) {
+                promise.reject("PERMISSION_DENIED", "Missing Android permission: android.permission.BLUETOOTH_CONNECT");
+                return false;
+            }
+        } else {
+            if (!hasPermission(Manifest.permission.BLUETOOTH)) {
+                promise.reject("PERMISSION_DENIED", "Missing Android permission: android.permission.BLUETOOTH");
+                return false;
+            }
+        }
+
+        if (!isBluetoothEnabled()) {
+            promise.reject("BLUETOOTH_DISABLED", "Bluetooth is disabled");
+            return false;
+        }
+
+        return true;
+    }
+
+    private boolean hasPermission(String permission) {
+        return reactContext.checkSelfPermission(permission) == PackageManager.PERMISSION_GRANTED;
+    }
+
+    private boolean isBluetoothTarget(String target) {
+        return target != null && target.toUpperCase().startsWith("BT:");
+    }
+
+    private boolean isBluetoothEnabled() {
+        BluetoothManager bluetoothManager = (BluetoothManager) reactContext.getSystemService(Context.BLUETOOTH_SERVICE);
+        if (bluetoothManager == null) {
+            return false;
+        }
+        BluetoothAdapter adapter = bluetoothManager.getAdapter();
+        return adapter != null && adapter.isEnabled();
+    }
+
+    private boolean isLocationEnabled() {
+        LocationManager locationManager = (LocationManager) reactContext.getSystemService(Context.LOCATION_SERVICE);
+        if (locationManager == null) {
+            return false;
+        }
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+            return locationManager.isLocationEnabled();
+        }
+        return locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER)
+            || locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
+    }
+
+    private int normalizeLanguage(int lang) {
+        if (lang >= 0 && lang <= 7) {
+            return lang;
+        }
+        return Printer.LANG_EN;
+    }
+
+    private int normalizeModel(int model) {
+        switch (model) {
+            case 0:
+            case 1:
+            case 2:
+            case 3:
+            case 4:
+            case 5:
+            case 6:
+            case 7:
+            case 8:
+            case 9:
+            case 10:
+            case 11:
+            case 12:
+            case 13:
+            case 14:
+            case 15:
+            case 16:
+            case 17:
+            case 18:
+            case 19:
+            case 20:
+                return model;
+            case 21:
+                return Printer.TM_M30II;
+            case 22:
+                return Printer.TS_100;
+            case 23:
+                return Printer.TM_M50;
+            case 24:
+                return Printer.TM_T88VII;
+            case 25:
+                return Printer.TM_L90LFC;
+            case 26:
+                return Printer.TM_L100;
+            case 27:
+                return Printer.TM_P20II;
+            case 28:
+                return Printer.TM_P80II;
+            case 29:
+                return Printer.TM_M30III;
+            case 30:
+                return Printer.TM_M50II;
+            case 31:
+                return Printer.TM_M55;
+            case 32:
+                return Printer.TM_U220II;
+            case 33:
+                return Printer.SB_H50;
+            case 34:
+                return Printer.SB_M30;
+            default:
+                return Printer.TM_M30III;
+        }
+    }
+
+    private void rejectWithEposError(Promise promise, String code, String message, Exception error) {
+        if (error instanceof Epos2Exception) {
+            Epos2Exception epos2Error = (Epos2Exception) error;
+            int status = epos2Error.getErrorStatus();
+            promise.reject(code, message + ": " + status + " (" + eposErrorStatusToString(status) + ")", error);
+            return;
+        }
+
+        String errorMessage = error.getMessage() == null ? message : message + ": " + error.getMessage();
+        promise.reject(code, errorMessage, error);
+    }
+
+    private String eposErrorStatusToString(int code) {
+        switch (code) {
+            case 0:
+                return "SUCCESS";
+            case Epos2Exception.ERR_PARAM:
+                return "ERR_PARAM";
+            case Epos2Exception.ERR_CONNECT:
+                return "ERR_CONNECT";
+            case Epos2Exception.ERR_TIMEOUT:
+                return "ERR_TIMEOUT";
+            case Epos2Exception.ERR_MEMORY:
+                return "ERR_MEMORY";
+            case Epos2Exception.ERR_ILLEGAL:
+                return "ERR_ILLEGAL";
+            case Epos2Exception.ERR_PROCESSING:
+                return "ERR_PROCESSING";
+            case Epos2Exception.ERR_NOT_FOUND:
+                return "ERR_NOT_FOUND";
+            case Epos2Exception.ERR_IN_USE:
+                return "ERR_IN_USE";
+            case Epos2Exception.ERR_TYPE_INVALID:
+                return "ERR_TYPE_INVALID";
+            case Epos2Exception.ERR_DISCONNECT:
+                return "ERR_DISCONNECT";
+            case Epos2Exception.ERR_ALREADY_OPENED:
+                return "ERR_ALREADY_OPENED";
+            case Epos2Exception.ERR_ALREADY_USED:
+                return "ERR_ALREADY_USED";
+            case Epos2Exception.ERR_BOX_COUNT_OVER:
+                return "ERR_BOX_COUNT_OVER";
+            case Epos2Exception.ERR_BOX_CLIENT_OVER:
+                return "ERR_BOX_CLIENT_OVER";
+            case Epos2Exception.ERR_UNSUPPORTED:
+                return "ERR_UNSUPPORTED";
+            case Epos2Exception.ERR_FAILURE:
+                return "ERR_FAILURE";
+            default:
+                return "UNKNOWN_ERROR_" + code;
+        }
+    }
+
+    private void emitEvent(String eventName, WritableMap body) {
+        if (!reactContext.hasActiveCatalystInstance()) {
+            return;
+        }
+        reactContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+            .emit(eventName, body);
+    }
+
+    private static final class EpsonSession {
+        final String sessionId;
+        Printer printer;
+        String target;
+        int model = -1;
+        int lang = -1;
+        Promise printPromise;
+        Runnable printTimeoutRunnable;
+
+        EpsonSession(String sessionId) {
+            this.sessionId = sessionId;
+        }
+    }
+
+    private static final class CachedConnection {
+        final String target;
+        final int model;
+        final int lang;
+        final Printer printer;
+        Runnable evictionRunnable;
+
+        CachedConnection(String target, int model, int lang, Printer printer) {
+            this.target = target;
+            this.model = model;
+            this.lang = lang;
+            this.printer = printer;
+        }
+    }
+}