@amitkhare/capacitor-cat-printer 0.5.0 → 0.5.2

package/android/src/main/java/khare/catprinter/plugin/CatPrinterCore.java

@@ -48,10 +48,13 @@ public class CatPrinterCore {
     
     private String connectedAddress;
     private int paperWidth = PrinterProtocol.WIDTH_58MM;
+    private boolean dryRunMode = false;
+    private int connectionTimeout = 10000; // Default 10 seconds
     
     private final AtomicBoolean isScanning = new AtomicBoolean(false);
     private final AtomicBoolean isPaused = new AtomicBoolean(false);
     private final AtomicBoolean isPrinting = new AtomicBoolean(false);
+    private final AtomicBoolean isCancelled = new AtomicBoolean(false);
     
     private final ConcurrentLinkedQueue<byte[]> writeQueue = new ConcurrentLinkedQueue<>();
     private final AtomicBoolean isWriting = new AtomicBoolean(false);
@@ -247,9 +250,21 @@ public class CatPrinterCore {
 
     // ==================== CONNECTION ====================
 
-    public void connect(String address, int width, ConnectionCallback callback) {
+    private Runnable connectionTimeoutRunnable;
+
+    public void connect(String address, int width, int timeout, boolean dryRun, ConnectionCallback callback) {
         this.connectionCallback = callback;
         this.paperWidth = width;
+        this.connectionTimeout = timeout;
+        this.dryRunMode = dryRun;
+
+        // In dry-run mode, simulate connection
+        if (dryRun) {
+            Log.d(TAG, "Dry-run mode: simulating connection to " + address);
+            connectedAddress = address;
+            mainHandler.post(() -> callback.onConnected());
+            return;
+        }
 
         if (bluetoothAdapter == null) {
             callback.onError("Bluetooth not available");
@@ -267,10 +282,31 @@ public class CatPrinterCore {
             return;
         }
 
+        // Set up connection timeout
+        connectionTimeoutRunnable = () -> {
+            if (gatt != null && txCharacteristic == null) {
+                Log.e(TAG, "Connection timeout after " + timeout + "ms");
+                disconnect();
+                mainHandler.post(() -> callback.onError("Connection timeout"));
+            }
+        };
+        mainHandler.postDelayed(connectionTimeoutRunnable, timeout);
+
         gatt = device.connectGatt(context, false, gattCallback, BluetoothDevice.TRANSPORT_LE);
     }
 
+    // Overload for backward compatibility
+    public void connect(String address, int width, ConnectionCallback callback) {
+        connect(address, width, 10000, false, callback);
+    }
+
     public void disconnect() {
+        // Cancel connection timeout if pending
+        if (connectionTimeoutRunnable != null) {
+            mainHandler.removeCallbacks(connectionTimeoutRunnable);
+            connectionTimeoutRunnable = null;
+        }
+        
         if (gatt != null) {
             gatt.disconnect();
             gatt.close();
@@ -278,14 +314,23 @@ public class CatPrinterCore {
         }
         txCharacteristic = null;
         connectedAddress = null;
+        dryRunMode = false;
         isPaused.set(false);
         writeQueue.clear();
     }
 
     public boolean isConnected() {
+        // In dry-run mode, we're always "connected" if address is set
+        if (dryRunMode && connectedAddress != null) {
+            return true;
+        }
         return gatt != null && txCharacteristic != null;
     }
 
+    public boolean isDryRunMode() {
+        return dryRunMode;
+    }
+
     public String getConnectedAddress() {
         return connectedAddress;
     }
@@ -319,6 +364,12 @@ public class CatPrinterCore {
                     BluetoothGattCharacteristic rx = service.getCharacteristic(PrinterProtocol.RX_CHAR_UUID);
                     
                     if (tx != null && rx != null) {
+                        // Cancel connection timeout
+                        if (connectionTimeoutRunnable != null) {
+                            mainHandler.removeCallbacks(connectionTimeoutRunnable);
+                            connectionTimeoutRunnable = null;
+                        }
+                        
                         txCharacteristic = tx;
                         connectedAddress = gatt.getDevice().getAddress();
                         
@@ -390,6 +441,13 @@ public class CatPrinterCore {
     }
 
     private void processWriteQueue() {
+        // Check if cancelled - stop processing
+        if (isCancelled.get()) {
+            writeQueue.clear();
+            isWriting.set(false);
+            return;
+        }
+        
         if (isPaused.get() || isWriting.get() || writeQueue.isEmpty()) {
             return;
         }
@@ -423,6 +481,12 @@ public class CatPrinterCore {
         int sleepInterval = 50;
         
         while ((!writeQueue.isEmpty() || isWriting.get()) && waited < maxWaitMs) {
+            // Check if cancelled - stop waiting
+            if (isCancelled.get()) {
+                writeQueue.clear();
+                return;
+            }
+            
             try {
                 Thread.sleep(sleepInterval);
                 waited += sleepInterval;
@@ -445,7 +509,9 @@ public class CatPrinterCore {
     // ==================== PRINTING ====================
 
     public void printImage(String base64Image, float energy, int quality, 
-                          int feedAfter, int threshold, boolean dither, PrintCallback callback) {
+                          int feedAfter, int threshold, boolean dither,
+                          boolean flipH, boolean flipV, boolean compress,
+                          PrintCallback callback) {
         this.printCallback = callback;
         
         if (!isConnected()) {
@@ -459,11 +525,18 @@ public class CatPrinterCore {
         }
 
         isPrinting.set(true);
+        isCancelled.set(false);  // Reset cancel flag
 
         new Thread(() -> {
             try {
                 reportProgress(0, "processing", "Decoding image");
                 
+                // Check for cancellation
+                if (isCancelled.get()) {
+                    handleCancellation();
+                    return;
+                }
+                
                 // Decode base64 image
                 byte[] imageBytes = Base64.decode(base64Image, Base64.DEFAULT);
                 Bitmap bitmap = BitmapFactory.decodeByteArray(imageBytes, 0, imageBytes.length);
@@ -476,6 +549,12 @@ public class CatPrinterCore {
 
                 reportProgress(10, "processing", "Resizing image");
                 
+                // Check for cancellation
+                if (isCancelled.get()) {
+                    handleCancellation();
+                    return;
+                }
+                
                 // Resize to paper width
                 bitmap = ImageProcessor.resizeToWidth(bitmap, paperWidth);
                 
@@ -492,12 +571,22 @@ public class CatPrinterCore {
                 }
                 int height = bitmap.getHeight();
                 
-                Log.d(TAG, "Printing " + height + " lines");
+                // Apply flipping if requested
+                if (flipH) {
+                    reportProgress(25, "processing", "Flipping horizontally");
+                    ImageProcessor.flipHorizontal(monoData, paperWidth, height);
+                }
+                if (flipV) {
+                    reportProgress(27, "processing", "Flipping vertically");
+                    ImageProcessor.flipVertical(monoData, paperWidth, height);
+                }
+                
+                Log.d(TAG, "Printing " + height + " lines" + (dryRunMode ? " (DRY RUN)" : ""));
                 
                 bitmap.recycle();
 
-                // Print the bitmap
-                printBitmapData(monoData, paperWidth, height, energy, quality, feedAfter);
+                // Print the bitmap (with compression flag for newer printers)
+                printBitmapData(monoData, paperWidth, height, energy, quality, feedAfter, compress);
                 
             } catch (Exception e) {
                 Log.e(TAG, "Print error", e);
@@ -507,9 +596,16 @@ public class CatPrinterCore {
         }).start();
     }
 
+    // Overload for backward compatibility
+    public void printImage(String base64Image, float energy, int quality, 
+                          int feedAfter, int threshold, boolean dither, PrintCallback callback) {
+        printImage(base64Image, energy, quality, feedAfter, threshold, dither, false, false, false, callback);
+    }
+
     public void printText(String text, int fontSize, String align, boolean bold,
                          float lineSpacing, float energy, int quality, 
-                         int feedAfter, PrintCallback callback) {
+                         int feedAfter, boolean wordWrap, boolean rtl,
+                         PrintCallback callback) {
         this.printCallback = callback;
         
         if (!isConnected()) {
@@ -523,14 +619,21 @@ public class CatPrinterCore {
         }
 
         isPrinting.set(true);
+        isCancelled.set(false);  // Reset cancel flag
 
         new Thread(() -> {
             try {
                 reportProgress(0, "processing", "Rendering text");
                 
-                // Render text to bitmap
+                // Check for cancellation
+                if (isCancelled.get()) {
+                    handleCancellation();
+                    return;
+                }
+                
+                // Render text to bitmap with word wrap and RTL support
                 Bitmap bitmap = ImageProcessor.renderText(text, paperWidth, fontSize, 
-                                                          align, bold, lineSpacing);
+                                                          align, bold, lineSpacing, wordWrap, rtl);
                 
                 reportProgress(20, "processing", "Converting to monochrome");
                 
@@ -538,10 +641,12 @@ public class CatPrinterCore {
                 byte[] monoData = ImageProcessor.toMonochrome(bitmap, 127);
                 int height = bitmap.getHeight();
                 
+                Log.d(TAG, "Printing text: " + height + " lines" + (dryRunMode ? " (DRY RUN)" : ""));
+                
                 bitmap.recycle();
 
                 // Print the bitmap
-                printBitmapData(monoData, paperWidth, height, energy, quality, feedAfter);
+                printBitmapData(monoData, paperWidth, height, energy, quality, feedAfter, false);
                 
             } catch (Exception e) {
                 Log.e(TAG, "Print error", e);
@@ -551,13 +656,49 @@ public class CatPrinterCore {
         }).start();
     }
 
+    // Overload for backward compatibility
+    public void printText(String text, int fontSize, String align, boolean bold,
+                         float lineSpacing, float energy, int quality, 
+                         int feedAfter, PrintCallback callback) {
+        printText(text, fontSize, align, bold, lineSpacing, energy, quality, feedAfter, true, false, callback);
+    }
+
     private void printBitmapData(byte[] data, int width, int height, 
-                                 float energy, int quality, int feedAfter) {
+                                 float energy, int quality, int feedAfter, boolean compress) {
         try {
             int bytesPerLine = width / 8;
             int totalLines = height;
             
-            reportProgress(30, "printing", "Initializing printer");
+            reportProgress(30, "printing", dryRunMode ? "Simulating print..." : "Initializing printer");
+            
+            // In dry-run mode, simulate the print process without sending data
+            if (dryRunMode) {
+                for (int line = 0; line < totalLines; line++) {
+                    // Check for cancellation
+                    if (isCancelled.get()) {
+                        handleCancellation();
+                        return;
+                    }
+                    
+                    // Simulate processing time
+                    if (line % 100 == 0) {
+                        Thread.sleep(10);
+                        int progress = 30 + (int) ((line / (float) totalLines) * 60);
+                        reportProgress(progress, "printing", "Simulating line " + line + "/" + totalLines);
+                    }
+                }
+                
+                reportProgress(90, "feeding", "Simulation complete");
+                Thread.sleep(100);
+                
+                isPrinting.set(false);
+                reportProgress(100, "done", "Dry run complete");
+                
+                if (printCallback != null) {
+                    mainHandler.post(() -> printCallback.onComplete());
+                }
+                return;
+            }
             
             // Calculate energy and speed values
             // Reference: energy = int(args.energy * 0xffff)
@@ -565,12 +706,21 @@ public class CatPrinterCore {
             // Reference: speed = 4 * (quality + 5), quality 1-4 -> speed 24-36
             int speedValue = 4 * (quality + 5);
             
+            // Check if this is a new-kind printer that supports compression
+            String model = PrinterProtocol.detectModel(getConnectedDeviceName());
+            boolean isNewKind = PrinterProtocol.isNewKind(model);
+            boolean useCompression = compress && isNewKind;
+            
             // === PREPARE PHASE (matches reference _prepare method) ===
             // 1. Get device state
             queueWrite(PrinterProtocol.cmdGetDeviceState());
             
-            // 2. Start printing (use standard command, not new)
-            queueWrite(PrinterProtocol.cmdStartPrinting());
+            // 2. Start printing (use new command for new-kind printers)
+            if (isNewKind) {
+                queueWrite(PrinterProtocol.cmdStartPrintingNew());
+            } else {
+                queueWrite(PrinterProtocol.cmdStartPrinting());
+            }
             
             // 3. Set DPI
             queueWrite(PrinterProtocol.cmdSetDpi200());
@@ -599,11 +749,22 @@ public class CatPrinterCore {
             
             // === PRINT BITMAP DATA ===
             for (int line = 0; line < totalLines; line++) {
+                // Check for cancellation
+                if (isCancelled.get()) {
+                    handleCancellation();
+                    return;
+                }
+                
                 int offset = line * bytesPerLine;
                 byte[] lineData = new byte[bytesPerLine];
                 System.arraycopy(data, offset, lineData, 0, bytesPerLine);
                 
-                queueWrite(PrinterProtocol.cmdDrawBitmap(lineData));
+                if (useCompression) {
+                    // Use compressed bitmap command for newer printers
+                    queueWrite(PrinterProtocol.cmdDrawCompressedBitmap(lineData));
+                } else {
+                    queueWrite(PrinterProtocol.cmdDrawBitmap(lineData));
+                }
                 
                 // Report progress every 50 lines
                 if (line % 50 == 0) {
@@ -653,9 +814,531 @@ public class CatPrinterCore {
         callback.onComplete();
     }
 
+    /**
+     * Cancel an ongoing print job
+     */
+    public void cancelPrint(PrintCallback callback) {
+        Log.d(TAG, "Cancel requested, isPrinting=" + isPrinting.get());
+        
+        // Always set cancelled flag and clear queue, even if not currently printing
+        isCancelled.set(true);
+        writeQueue.clear();
+        
+        if (isPrinting.get()) {
+            // Let the print loop handle the cancellation
+            Log.d(TAG, "Cancelling active print job...");
+        } else {
+            // Reset the flag if nothing was printing
+            isCancelled.set(false);
+        }
+        
+        callback.onComplete();
+    }
+
+    public void retractPaper(int pixels, PrintCallback callback) {
+        if (!isConnected()) {
+            callback.onError("Not connected to printer");
+            return;
+        }
+
+        queueWrite(PrinterProtocol.cmdRetractPaper(pixels));
+        callback.onComplete();
+    }
+
+    public void getDeviceInfo(PrintCallback callback) {
+        if (!isConnected()) {
+            callback.onError("Not connected to printer");
+            return;
+        }
+
+        // Send device info command
+        queueWrite(PrinterProtocol.cmdGetDeviceInfo());
+        // Note: Response comes via onCharacteristicChanged, but we don't have
+        // a way to capture it yet. For now, just confirm command was sent.
+        callback.onComplete();
+    }
+
+    /**
+     * Get the connected device name for model detection
+     */
+    public String getConnectedDeviceName() {
+        if (gatt != null && gatt.getDevice() != null) {
+            return gatt.getDevice().getName();
+        }
+        return null;
+    }
+
+    /**
+     * Get detected printer model info
+     */
+    public PrinterModelInfo getPrinterModel() {
+        String deviceName = getConnectedDeviceName();
+        String model = PrinterProtocol.detectModel(deviceName);
+        boolean isNewKind = PrinterProtocol.isNewKind(model);
+        boolean hasFeedingProblems = PrinterProtocol.hasFeedingProblems(model);
+        
+        return new PrinterModelInfo(
+            model,
+            isNewKind,
+            hasFeedingProblems,
+            paperWidth,
+            deviceName != null ? deviceName : ""
+        );
+    }
+
+    public static class PrinterModelInfo {
+        public String model;
+        public boolean isNewKind;
+        public boolean hasFeedingProblems;
+        public int paperWidth;
+        public String deviceName;
+
+        public PrinterModelInfo(String model, boolean isNewKind, boolean hasFeedingProblems, 
+                               int paperWidth, String deviceName) {
+            this.model = model;
+            this.isNewKind = isNewKind;
+            this.hasFeedingProblems = hasFeedingProblems;
+            this.paperWidth = paperWidth;
+            this.deviceName = deviceName;
+        }
+    }
+
     private void reportProgress(int percent, String status, String message) {
         if (printCallback != null) {
             mainHandler.post(() -> printCallback.onProgress(percent, status, message));
         }
     }
+
+    private void handleCancellation() {
+        Log.d(TAG, "Print job cancelled");
+        writeQueue.clear();
+        isWriting.set(false);
+        isPrinting.set(false);
+        
+        // Try to send stop command to printer (best effort)
+        if (gatt != null && txCharacteristic != null && !dryRunMode) {
+            try {
+                byte[] stopCmd = PrinterProtocol.cmdEndLattice();
+                txCharacteristic.setValue(stopCmd);
+                txCharacteristic.setWriteType(BluetoothGattCharacteristic.WRITE_TYPE_NO_RESPONSE);
+                gatt.writeCharacteristic(txCharacteristic);
+            } catch (Exception e) {
+                Log.w(TAG, "Failed to send stop command", e);
+            }
+        }
+        
+        isCancelled.set(false);
+        
+        reportProgress(0, "error", "Print cancelled");
+        
+        if (printCallback != null) {
+            mainHandler.post(() -> printCallback.onError("Print cancelled by user"));
+        }
+    }
+
+    // ==================== NEW FEATURES ====================
+
+    // Auto-reconnect settings
+    private boolean autoReconnectEnabled = false;
+    private int autoReconnectMaxAttempts = 3;
+    private int autoReconnectDelayMs = 2000;
+    private int autoReconnectAttempts = 0;
+    private String lastConnectedAddress = null;
+    private int lastPaperWidth = PrinterProtocol.WIDTH_58MM;
+
+    /**
+     * Set auto-reconnect options
+     */
+    public void setAutoReconnect(boolean enabled, int maxAttempts, int delayMs) {
+        this.autoReconnectEnabled = enabled;
+        this.autoReconnectMaxAttempts = maxAttempts;
+        this.autoReconnectDelayMs = delayMs;
+        this.autoReconnectAttempts = 0;
+    }
+
+    /**
+     * Print text with full styling support
+     */
+    public void printTextStyled(String text, int fontSize, String align, boolean bold,
+                                boolean italic, boolean underline, boolean strikethrough,
+                                float lineSpacing, float energy, int quality, 
+                                int feedAfter, boolean wordWrap, boolean rtl,
+                                String fontPath, PrintCallback callback) {
+        this.printCallback = callback;
+        
+        if (!isConnected()) {
+            callback.onError("Not connected to printer");
+            return;
+        }
+
+        if (isPrinting.get()) {
+            callback.onError("Already printing");
+            return;
+        }
+
+        isPrinting.set(true);
+        isCancelled.set(false);
+
+        new Thread(() -> {
+            try {
+                reportProgress(0, "processing", "Rendering styled text");
+                
+                if (isCancelled.get()) {
+                    handleCancellation();
+                    return;
+                }
+                
+                Bitmap bitmap = ImageProcessor.renderText(text, paperWidth, fontSize, 
+                    align, bold, italic, underline, strikethrough,
+                    lineSpacing, wordWrap, rtl, fontPath);
+                
+                reportProgress(20, "processing", "Converting to monochrome");
+                
+                byte[] monoData = ImageProcessor.toMonochrome(bitmap, 127);
+                int height = bitmap.getHeight();
+                
+                bitmap.recycle();
+
+                printBitmapData(monoData, paperWidth, height, energy, quality, feedAfter, false);
+                
+            } catch (Exception e) {
+                Log.e(TAG, "Print error", e);
+                isPrinting.set(false);
+                mainHandler.post(() -> callback.onError(e.getMessage()));
+            }
+        }).start();
+    }
+
+    /**
+     * Print rich text with mixed formatting (different styles per segment)
+     */
+    public void printRichText(String[] texts, boolean[] bolds, boolean[] italics,
+                              boolean[] underlines, boolean[] strikethroughs, int[] fontSizes,
+                              int defaultFontSize, String align, float lineSpacing,
+                              float energy, int quality, int feedAfter, boolean rtl,
+                              String fontPath, PrintCallback callback) {
+        this.printCallback = callback;
+        
+        if (!isConnected()) {
+            callback.onError("Not connected to printer");
+            return;
+        }
+
+        if (isPrinting.get()) {
+            callback.onError("Already printing");
+            return;
+        }
+
+        isPrinting.set(true);
+        isCancelled.set(false);
+
+        new Thread(() -> {
+            try {
+                reportProgress(0, "processing", "Rendering rich text");
+                
+                if (isCancelled.get()) {
+                    handleCancellation();
+                    return;
+                }
+                
+                Bitmap bitmap = ImageProcessor.renderRichText(texts, bolds, italics, 
+                    underlines, strikethroughs, fontSizes, defaultFontSize,
+                    paperWidth, align, lineSpacing, rtl, fontPath);
+                
+                reportProgress(20, "processing", "Converting to monochrome");
+                
+                byte[] monoData = ImageProcessor.toMonochrome(bitmap, 127);
+                int height = bitmap.getHeight();
+                
+                bitmap.recycle();
+
+                printBitmapData(monoData, paperWidth, height, energy, quality, feedAfter, false);
+                
+            } catch (Exception e) {
+                Log.e(TAG, "Rich text print error", e);
+                isPrinting.set(false);
+                mainHandler.post(() -> callback.onError(e.getMessage()));
+            }
+        }).start();
+    }
+
+    /**
+     * Print image with brightness/contrast/invert adjustments
+     */
+    public void printImageAdjusted(String base64Image, float energy, int quality, 
+                                   int feedAfter, int threshold, boolean dither,
+                                   boolean flipH, boolean flipV, boolean compress,
+                                   int brightness, int contrast, boolean invert,
+                                   PrintCallback callback) {
+        this.printCallback = callback;
+        
+        if (!isConnected()) {
+            callback.onError("Not connected to printer");
+            return;
+        }
+
+        if (isPrinting.get()) {
+            callback.onError("Already printing");
+            return;
+        }
+
+        isPrinting.set(true);
+        isCancelled.set(false);
+
+        new Thread(() -> {
+            try {
+                reportProgress(0, "processing", "Decoding image");
+                
+                if (isCancelled.get()) {
+                    handleCancellation();
+                    return;
+                }
+                
+                byte[] imageBytes = Base64.decode(base64Image, Base64.DEFAULT);
+                Bitmap bitmap = BitmapFactory.decodeByteArray(imageBytes, 0, imageBytes.length);
+                
+                if (bitmap == null) {
+                    throw new Exception("Failed to decode image");
+                }
+
+                reportProgress(10, "processing", "Resizing image");
+                bitmap = ImageProcessor.resizeToWidth(bitmap, paperWidth);
+
+                // Apply brightness/contrast adjustments
+                if (brightness != 0 || contrast != 0) {
+                    reportProgress(15, "processing", "Adjusting brightness/contrast");
+                    bitmap = ImageProcessor.adjustBrightnessContrast(bitmap, brightness, contrast);
+                }
+
+                // Apply invert
+                if (invert) {
+                    reportProgress(17, "processing", "Inverting colors");
+                    bitmap = ImageProcessor.invertColors(bitmap);
+                }
+
+                reportProgress(20, "processing", "Converting to monochrome");
+                
+                byte[] monoData;
+                if (dither) {
+                    monoData = ImageProcessor.toMonochromeDithered(bitmap, threshold);
+                } else {
+                    monoData = ImageProcessor.toMonochrome(bitmap, threshold);
+                }
+                int height = bitmap.getHeight();
+                
+                if (flipH) {
+                    ImageProcessor.flipHorizontal(monoData, paperWidth, height);
+                }
+                if (flipV) {
+                    ImageProcessor.flipVertical(monoData, paperWidth, height);
+                }
+                
+                bitmap.recycle();
+
+                printBitmapData(monoData, paperWidth, height, energy, quality, feedAfter, compress);
+                
+            } catch (Exception e) {
+                Log.e(TAG, "Print error", e);
+                isPrinting.set(false);
+                mainHandler.post(() -> callback.onError(e.getMessage()));
+            }
+        }).start();
+    }
+
+    /**
+     * Print a barcode
+     */
+    public void printBarcode(String data, String type, int height, boolean showText,
+                             String align, float energy, int feedAfter, PrintCallback callback) {
+        this.printCallback = callback;
+        
+        if (!isConnected()) {
+            callback.onError("Not connected to printer");
+            return;
+        }
+
+        if (isPrinting.get()) {
+            callback.onError("Already printing");
+            return;
+        }
+
+        isPrinting.set(true);
+        isCancelled.set(false);
+
+        new Thread(() -> {
+            try {
+                reportProgress(0, "processing", "Generating barcode");
+                
+                Bitmap bitmap = BarcodeGenerator.createAlignedBarcode(data, type, paperWidth, 
+                    height, showText, align);
+                
+                reportProgress(20, "processing", "Converting to monochrome");
+                
+                byte[] monoData = ImageProcessor.toMonochrome(bitmap, 127);
+                int bitmapHeight = bitmap.getHeight();
+                
+                bitmap.recycle();
+
+                printBitmapData(monoData, paperWidth, bitmapHeight, energy, 3, feedAfter, false);
+                
+            } catch (Exception e) {
+                Log.e(TAG, "Barcode print error", e);
+                isPrinting.set(false);
+                mainHandler.post(() -> callback.onError(e.getMessage()));
+            }
+        }).start();
+    }
+
+    /**
+     * Print a QR code
+     */
+    public void printQRCode(String data, int size, String errorCorrection, String align,
+                            float energy, int feedAfter, PrintCallback callback) {
+        this.printCallback = callback;
+        
+        if (!isConnected()) {
+            callback.onError("Not connected to printer");
+            return;
+        }
+
+        if (isPrinting.get()) {
+            callback.onError("Already printing");
+            return;
+        }
+
+        isPrinting.set(true);
+        isCancelled.set(false);
+
+        new Thread(() -> {
+            try {
+                reportProgress(0, "processing", "Generating QR code");
+                
+                Bitmap bitmap = BarcodeGenerator.createAlignedQRCode(data, paperWidth, size,
+                    errorCorrection, align);
+                
+                reportProgress(20, "processing", "Converting to monochrome");
+                
+                byte[] monoData = ImageProcessor.toMonochrome(bitmap, 127);
+                int height = bitmap.getHeight();
+                
+                bitmap.recycle();
+
+                printBitmapData(monoData, paperWidth, height, energy, 3, feedAfter, false);
+                
+            } catch (Exception e) {
+                Log.e(TAG, "QR code print error", e);
+                isPrinting.set(false);
+                mainHandler.post(() -> callback.onError(e.getMessage()));
+            }
+        }).start();
+    }
+
+    /**
+     * Print a formatted table
+     */
+    public void printTable(String[][] rows, int[] columnWidths, String[] alignments,
+                           boolean[] boldRows, boolean showLines, String lineChar,
+                           int fontSize, float energy, int feedAfter, PrintCallback callback) {
+        this.printCallback = callback;
+        
+        if (!isConnected()) {
+            callback.onError("Not connected to printer");
+            return;
+        }
+
+        if (isPrinting.get()) {
+            callback.onError("Already printing");
+            return;
+        }
+
+        isPrinting.set(true);
+        isCancelled.set(false);
+
+        new Thread(() -> {
+            try {
+                reportProgress(0, "processing", "Rendering table");
+                
+                Bitmap bitmap = ImageProcessor.renderTable(rows, columnWidths, alignments,
+                    boldRows, paperWidth, fontSize, showLines, lineChar);
+                
+                reportProgress(20, "processing", "Converting to monochrome");
+                
+                byte[] monoData = ImageProcessor.toMonochrome(bitmap, 127);
+                int height = bitmap.getHeight();
+                
+                bitmap.recycle();
+
+                printBitmapData(monoData, paperWidth, height, energy, 3, feedAfter, false);
+                
+            } catch (Exception e) {
+                Log.e(TAG, "Table print error", e);
+                isPrinting.set(false);
+                mainHandler.post(() -> callback.onError(e.getMessage()));
+            }
+        }).start();
+    }
+
+    /**
+     * Get print preview as base64 image
+     */
+    public PreviewResult getPreview(String type, Object options) {
+        try {
+            Bitmap bitmap = null;
+            
+            // Generate bitmap based on type (simplified - actual implementation would parse options)
+            // This is a placeholder - the actual implementation would be in the plugin layer
+            
+            if (bitmap != null) {
+                String base64 = ImageProcessor.bitmapToBase64(bitmap);
+                int width = bitmap.getWidth();
+                int height = bitmap.getHeight();
+                bitmap.recycle();
+                return new PreviewResult(base64, width, height);
+            }
+        } catch (Exception e) {
+            Log.e(TAG, "Preview error", e);
+        }
+        return null;
+    }
+
+    public static class PreviewResult {
+        public String imageBase64;
+        public int width;
+        public int height;
+
+        public PreviewResult(String imageBase64, int width, int height) {
+            this.imageBase64 = imageBase64;
+            this.width = width;
+            this.height = height;
+        }
+    }
+
+    /**
+     * Get printer status (battery, paper, firmware)
+     * Note: Most cat printers don't report this info, so values may be null
+     */
+    public PrinterStatus getPrinterStatus() {
+        PrinterStatus status = new PrinterStatus();
+        status.connected = isConnected();
+        status.paperWidth = paperWidth;
+        
+        // These would need to be populated from device responses
+        // Most cat printers don't report battery/paper status
+        status.batteryLevel = null;
+        status.isCharging = null;
+        status.hasPaper = null;
+        status.firmwareVersion = null;
+        
+        return status;
+    }
+
+    public static class PrinterStatus {
+        public boolean connected;
+        public Integer batteryLevel;
+        public Boolean isCharging;
+        public Boolean hasPaper;
+        public String firmwareVersion;
+        public int paperWidth;
+        public String rawData;
+    }
 }