@amitkhare/capacitor-cat-printer 0.5.0 → 0.5.2

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

@@ -3,15 +3,27 @@ package khare.catprinter.plugin;
 import android.graphics.Bitmap;
 import android.graphics.Canvas;
 import android.graphics.Color;
+import android.graphics.ColorMatrix;
+import android.graphics.ColorMatrixColorFilter;
 import android.graphics.Paint;
 import android.graphics.Typeface;
 import android.text.Layout;
+import android.text.SpannableStringBuilder;
+import android.text.Spanned;
 import android.text.StaticLayout;
 import android.text.TextPaint;
+import android.text.style.AbsoluteSizeSpan;
+import android.text.style.StrikethroughSpan;
+import android.text.style.StyleSpan;
+import android.text.style.UnderlineSpan;
+import android.util.Base64;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
 
 /**
  * Image processing utilities for thermal printing.
- * Handles resizing, dithering, and text rendering.
+ * Handles resizing, dithering, text rendering, and image adjustments.
  */
 public class ImageProcessor {
 
@@ -29,15 +41,72 @@ public class ImageProcessor {
         return Bitmap.createScaledBitmap(source, targetWidth, targetHeight, true);
     }
 
+    /**
+     * Adjust brightness and contrast of an image
+     * @param source Source bitmap
+     * @param brightness -100 to 100 (0 = no change)
+     * @param contrast -100 to 100 (0 = no change)
+     * @return Adjusted bitmap
+     */
+    public static Bitmap adjustBrightnessContrast(Bitmap source, int brightness, int contrast) {
+        if (brightness == 0 && contrast == 0) {
+            return source;
+        }
+
+        Bitmap result = Bitmap.createBitmap(source.getWidth(), source.getHeight(), source.getConfig());
+        Canvas canvas = new Canvas(result);
+        Paint paint = new Paint();
+
+        // Normalize values
+        float brightnessValue = brightness / 100f;
+        float contrastValue = (contrast + 100) / 100f;
+        contrastValue = contrastValue * contrastValue; // Square for better response
+
+        // Create color matrix for brightness/contrast
+        float[] matrix = new float[] {
+            contrastValue, 0, 0, 0, brightnessValue * 255,
+            0, contrastValue, 0, 0, brightnessValue * 255,
+            0, 0, contrastValue, 0, brightnessValue * 255,
+            0, 0, 0, 1, 0
+        };
+
+        ColorMatrix colorMatrix = new ColorMatrix(matrix);
+        paint.setColorFilter(new ColorMatrixColorFilter(colorMatrix));
+        canvas.drawBitmap(source, 0, 0, paint);
+
+        return result;
+    }
+
+    /**
+     * Invert colors of an image
+     */
+    public static Bitmap invertColors(Bitmap source) {
+        Bitmap result = Bitmap.createBitmap(source.getWidth(), source.getHeight(), source.getConfig());
+        Canvas canvas = new Canvas(result);
+        Paint paint = new Paint();
+
+        // Invert color matrix
+        float[] matrix = new float[] {
+            -1, 0, 0, 0, 255,
+            0, -1, 0, 0, 255,
+            0, 0, -1, 0, 255,
+            0, 0, 0, 1, 0
+        };
+
+        ColorMatrix colorMatrix = new ColorMatrix(matrix);
+        paint.setColorFilter(new ColorMatrixColorFilter(colorMatrix));
+        canvas.drawBitmap(source, 0, 0, paint);
+
+        return result;
+    }
+
     /**
      * Convert image to 1-bit monochrome bitmap data
-     * Uses simple threshold dithering (good for receipts)
      */
     public static byte[] toMonochrome(Bitmap source, int threshold) {
         int width = source.getWidth();
         int height = source.getHeight();
         
-        // Ensure width is multiple of 8
         int bytesPerLine = (width + 7) / 8;
         byte[] result = new byte[bytesPerLine * height];
         
@@ -48,13 +117,11 @@ public class ImageProcessor {
             for (int x = 0; x < width; x++) {
                 int pixel = pixels[y * width + x];
                 
-                // Convert to grayscale
                 int r = Color.red(pixel);
                 int g = Color.green(pixel);
                 int b = Color.blue(pixel);
                 int gray = (r * 299 + g * 587 + b * 114) / 1000;
                 
-                // Apply threshold (black = 1, white = 0 for thermal printer)
                 if (gray < threshold) {
                     int byteIndex = y * bytesPerLine + (x / 8);
                     int bitIndex = 7 - (x % 8);
@@ -68,7 +135,6 @@ public class ImageProcessor {
 
     /**
      * Convert image to 1-bit using Floyd-Steinberg dithering
-     * Better for images with gradients
      */
     public static byte[] toMonochromeDithered(Bitmap source, int threshold) {
         int width = source.getWidth();
@@ -77,7 +143,6 @@ public class ImageProcessor {
         int bytesPerLine = (width + 7) / 8;
         byte[] result = new byte[bytesPerLine * height];
         
-        // Get pixels and convert to grayscale float array for error diffusion
         int[] pixels = new int[width * height];
         source.getPixels(pixels, 0, width, 0, 0, width, height);
         
@@ -90,7 +155,6 @@ public class ImageProcessor {
             gray[i] = (r * 299 + g * 587 + b * 114) / 1000f;
         }
         
-        // Floyd-Steinberg dithering
         for (int y = 0; y < height; y++) {
             for (int x = 0; x < width; x++) {
                 int idx = y * width + x;
@@ -98,14 +162,12 @@ public class ImageProcessor {
                 float newPixel = oldPixel < threshold ? 0 : 255;
                 float error = oldPixel - newPixel;
                 
-                // Set bit if black
                 if (newPixel == 0) {
                     int byteIndex = y * bytesPerLine + (x / 8);
                     int bitIndex = 7 - (x % 8);
                     result[byteIndex] |= (1 << bitIndex);
                 }
                 
-                // Distribute error to neighbors
                 if (x + 1 < width) {
                     gray[idx + 1] += error * 7 / 16f;
                 }
@@ -124,16 +186,46 @@ public class ImageProcessor {
         return result;
     }
 
+
     /**
-     * Render text to a bitmap
+     * Render text to a bitmap with full styling support
      */
     public static Bitmap renderText(String text, int paperWidth, int fontSize, 
-                                     String align, boolean bold, float lineSpacing) {
-        // Create paint for text
+                                     String align, boolean bold, boolean italic,
+                                     boolean underline, boolean strikethrough,
+                                     float lineSpacing, boolean wordWrap, boolean rtl,
+                                     String fontPath) {
         TextPaint textPaint = new TextPaint(Paint.ANTI_ALIAS_FLAG);
         textPaint.setColor(Color.BLACK);
         textPaint.setTextSize(fontSize);
-        textPaint.setTypeface(bold ? Typeface.DEFAULT_BOLD : Typeface.MONOSPACE);
+        
+        // Set typeface with custom font or system font
+        Typeface typeface = Typeface.MONOSPACE;
+        if (fontPath != null && !fontPath.isEmpty()) {
+            try {
+                File fontFile = new File(fontPath);
+                if (fontFile.exists()) {
+                    typeface = Typeface.createFromFile(fontFile);
+                }
+            } catch (Exception e) {
+                // Fall back to default
+            }
+        }
+        
+        // Apply bold/italic style
+        int style = Typeface.NORMAL;
+        if (bold && italic) {
+            style = Typeface.BOLD_ITALIC;
+        } else if (bold) {
+            style = Typeface.BOLD;
+        } else if (italic) {
+            style = Typeface.ITALIC;
+        }
+        textPaint.setTypeface(Typeface.create(typeface, style));
+        
+        // Apply underline and strikethrough
+        textPaint.setUnderlineText(underline);
+        textPaint.setStrikeThruText(strikethrough);
         
         // Determine alignment
         Layout.Alignment alignment;
@@ -148,9 +240,25 @@ public class ImageProcessor {
                 alignment = Layout.Alignment.ALIGN_NORMAL;
         }
         
-        // Create static layout to measure and render text
+        // Handle RTL text
+        String processedText = text;
+        if (rtl) {
+            StringBuilder sb = new StringBuilder();
+            String[] lines = text.split("\n");
+            for (int i = 0; i < lines.length; i++) {
+                if (i > 0) sb.append("\n");
+                sb.append(new StringBuilder(lines[i]).reverse().toString());
+            }
+            processedText = sb.toString();
+            if (alignment == Layout.Alignment.ALIGN_NORMAL) {
+                alignment = Layout.Alignment.ALIGN_OPPOSITE;
+            } else if (alignment == Layout.Alignment.ALIGN_OPPOSITE) {
+                alignment = Layout.Alignment.ALIGN_NORMAL;
+            }
+        }
+        
         StaticLayout.Builder builder = StaticLayout.Builder.obtain(
-            text, 0, text.length(), textPaint, paperWidth
+            processedText, 0, processedText.length(), textPaint, paperWidth
         );
         builder.setAlignment(alignment);
         builder.setLineSpacing(0, lineSpacing);
@@ -158,21 +266,218 @@ public class ImageProcessor {
         
         StaticLayout layout = builder.build();
         
-        // Create bitmap with calculated height
-        int height = layout.getHeight();
-        // Ensure height is at least 1 pixel
-        height = Math.max(height, 1);
+        int height = Math.max(layout.getHeight(), 1);
         
         Bitmap bitmap = Bitmap.createBitmap(paperWidth, height, Bitmap.Config.ARGB_8888);
         Canvas canvas = new Canvas(bitmap);
         canvas.drawColor(Color.WHITE);
+        layout.draw(canvas);
+        
+        return bitmap;
+    }
+
+    /**
+     * Render text to a bitmap (backward compatible overload)
+     */
+    public static Bitmap renderText(String text, int paperWidth, int fontSize, 
+                                     String align, boolean bold, float lineSpacing,
+                                     boolean wordWrap, boolean rtl) {
+        return renderText(text, paperWidth, fontSize, align, bold, false, false, false,
+                         lineSpacing, wordWrap, rtl, null);
+    }
+
+    /**
+     * Render text to a bitmap (simple overload)
+     */
+    public static Bitmap renderText(String text, int paperWidth, int fontSize, 
+                                     String align, boolean bold, float lineSpacing) {
+        return renderText(text, paperWidth, fontSize, align, bold, false, false, false,
+                         lineSpacing, true, false, null);
+    }
+
+    /**
+     * Render rich text with mixed formatting (different styles per segment)
+     * Uses SpannableStringBuilder to apply different styles to different parts of text
+     */
+    public static Bitmap renderRichText(String[] texts, boolean[] bolds, boolean[] italics,
+                                         boolean[] underlines, boolean[] strikethroughs,
+                                         int[] fontSizes, int defaultFontSize,
+                                         int paperWidth, String align, float lineSpacing,
+                                         boolean rtl, String fontPath) {
+        SpannableStringBuilder builder = new SpannableStringBuilder();
+        
+        for (int i = 0; i < texts.length; i++) {
+            String text = texts[i];
+            if (text == null || text.isEmpty()) continue;
+            
+            int start = builder.length();
+            builder.append(text);
+            int end = builder.length();
+            
+            // Apply bold/italic style
+            boolean bold = i < bolds.length && bolds[i];
+            boolean italic = i < italics.length && italics[i];
+            if (bold && italic) {
+                builder.setSpan(new StyleSpan(Typeface.BOLD_ITALIC), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
+            } else if (bold) {
+                builder.setSpan(new StyleSpan(Typeface.BOLD), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
+            } else if (italic) {
+                builder.setSpan(new StyleSpan(Typeface.ITALIC), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
+            }
+            
+            // Apply underline
+            if (i < underlines.length && underlines[i]) {
+                builder.setSpan(new UnderlineSpan(), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
+            }
+            
+            // Apply strikethrough
+            if (i < strikethroughs.length && strikethroughs[i]) {
+                builder.setSpan(new StrikethroughSpan(), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
+            }
+            
+            // Apply font size if different from default
+            int fontSize = i < fontSizes.length ? fontSizes[i] : defaultFontSize;
+            if (fontSize != defaultFontSize) {
+                builder.setSpan(new AbsoluteSizeSpan(fontSize, false), start, end, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
+            }
+        }
+        
+        TextPaint textPaint = new TextPaint(Paint.ANTI_ALIAS_FLAG);
+        textPaint.setColor(Color.BLACK);
+        textPaint.setTextSize(defaultFontSize);
+        
+        // Set typeface with custom font or system font
+        Typeface typeface = Typeface.MONOSPACE;
+        if (fontPath != null && !fontPath.isEmpty()) {
+            try {
+                File fontFile = new File(fontPath);
+                if (fontFile.exists()) {
+                    typeface = Typeface.createFromFile(fontFile);
+                }
+            } catch (Exception e) {
+                // Fall back to default
+            }
+        }
+        textPaint.setTypeface(typeface);
         
-        // Draw text
+        // Determine alignment
+        Layout.Alignment alignment;
+        switch (align) {
+            case "center":
+                alignment = Layout.Alignment.ALIGN_CENTER;
+                break;
+            case "right":
+                alignment = Layout.Alignment.ALIGN_OPPOSITE;
+                break;
+            default:
+                alignment = Layout.Alignment.ALIGN_NORMAL;
+        }
+        
+        // Handle RTL
+        CharSequence processedText = builder;
+        if (rtl) {
+            // For RTL, reverse each line
+            String fullText = builder.toString();
+            StringBuilder sb = new StringBuilder();
+            String[] lines = fullText.split("\n");
+            for (int i = 0; i < lines.length; i++) {
+                if (i > 0) sb.append("\n");
+                sb.append(new StringBuilder(lines[i]).reverse().toString());
+            }
+            // Note: RTL with spans is complex, this is a simplified approach
+            processedText = sb.toString();
+            if (alignment == Layout.Alignment.ALIGN_NORMAL) {
+                alignment = Layout.Alignment.ALIGN_OPPOSITE;
+            } else if (alignment == Layout.Alignment.ALIGN_OPPOSITE) {
+                alignment = Layout.Alignment.ALIGN_NORMAL;
+            }
+        }
+        
+        StaticLayout.Builder layoutBuilder = StaticLayout.Builder.obtain(
+            processedText, 0, processedText.length(), textPaint, paperWidth
+        );
+        layoutBuilder.setAlignment(alignment);
+        layoutBuilder.setLineSpacing(0, lineSpacing);
+        layoutBuilder.setIncludePad(true);
+        
+        StaticLayout layout = layoutBuilder.build();
+        
+        int height = Math.max(layout.getHeight(), 1);
+        
+        Bitmap bitmap = Bitmap.createBitmap(paperWidth, height, Bitmap.Config.ARGB_8888);
+        Canvas canvas = new Canvas(bitmap);
+        canvas.drawColor(Color.WHITE);
         layout.draw(canvas);
         
         return bitmap;
     }
 
+    /**
+     * Render a table/receipt format
+     */
+    public static Bitmap renderTable(String[][] rows, int[] columnWidths, String[] alignments,
+                                      boolean[] boldRows, int paperWidth, int fontSize,
+                                      boolean showLines, String lineChar) {
+        TextPaint textPaint = new TextPaint(Paint.ANTI_ALIAS_FLAG);
+        textPaint.setColor(Color.BLACK);
+        textPaint.setTextSize(fontSize);
+        textPaint.setTypeface(Typeface.MONOSPACE);
+        
+        float lineHeight = fontSize * 1.3f;
+        int totalHeight = (int) (rows.length * lineHeight);
+        if (showLines) {
+            totalHeight += (rows.length - 1) * (int) lineHeight; // Add space for lines
+        }
+        totalHeight = Math.max(totalHeight, 1);
+        
+        Bitmap bitmap = Bitmap.createBitmap(paperWidth, totalHeight, Bitmap.Config.ARGB_8888);
+        Canvas canvas = new Canvas(bitmap);
+        canvas.drawColor(Color.WHITE);
+        
+        float y = fontSize;
+        
+        for (int rowIdx = 0; rowIdx < rows.length; rowIdx++) {
+            String[] row = rows[rowIdx];
+            boolean isBold = boldRows != null && rowIdx < boldRows.length && boldRows[rowIdx];
+            textPaint.setTypeface(isBold ? Typeface.DEFAULT_BOLD : Typeface.MONOSPACE);
+            
+            int x = 0;
+            for (int colIdx = 0; colIdx < row.length; colIdx++) {
+                String cellText = row[colIdx];
+                int colWidth = (colIdx < columnWidths.length) ? columnWidths[colIdx] : paperWidth / row.length;
+                String colAlign = (colIdx < alignments.length) ? alignments[colIdx] : "left";
+                
+                float textWidth = textPaint.measureText(cellText);
+                float textX = x;
+                
+                if ("center".equals(colAlign)) {
+                    textX = x + (colWidth - textWidth) / 2;
+                } else if ("right".equals(colAlign)) {
+                    textX = x + colWidth - textWidth;
+                }
+                
+                canvas.drawText(cellText, textX, y, textPaint);
+                x += colWidth;
+            }
+            
+            y += lineHeight;
+            
+            // Draw separator line if needed
+            if (showLines && rowIdx < rows.length - 1) {
+                StringBuilder line = new StringBuilder();
+                int charWidth = (int) textPaint.measureText(lineChar);
+                int numChars = paperWidth / Math.max(charWidth, 1);
+                for (int i = 0; i < numChars; i++) {
+                    line.append(lineChar);
+                }
+                canvas.drawText(line.toString(), 0, y, textPaint);
+                y += lineHeight;
+            }
+        }
+        
+        return bitmap;
+    }
+
     /**
      * Flip bitmap horizontally
      */
@@ -183,12 +488,10 @@ public class ImageProcessor {
         for (int y = 0; y < height; y++) {
             int lineStart = y * bytesPerLine;
             
-            // Copy line to temp with reversed bytes and bits
             for (int x = 0; x < bytesPerLine; x++) {
                 temp[bytesPerLine - 1 - x] = PrinterProtocol.reverseBits(data[lineStart + x]);
             }
             
-            // Copy back
             System.arraycopy(temp, 0, data, lineStart, bytesPerLine);
         }
     }
@@ -204,10 +507,41 @@ public class ImageProcessor {
             int topLine = y * bytesPerLine;
             int bottomLine = (height - 1 - y) * bytesPerLine;
             
-            // Swap lines
             System.arraycopy(data, topLine, temp, 0, bytesPerLine);
             System.arraycopy(data, bottomLine, data, topLine, bytesPerLine);
             System.arraycopy(temp, 0, data, bottomLine, bytesPerLine);
         }
     }
+
+    /**
+     * Convert bitmap to base64 PNG for preview
+     */
+    public static String bitmapToBase64(Bitmap bitmap) {
+        ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        bitmap.compress(Bitmap.CompressFormat.PNG, 100, baos);
+        byte[] bytes = baos.toByteArray();
+        return Base64.encodeToString(bytes, Base64.NO_WRAP);
+    }
+
+    /**
+     * Convert monochrome byte array back to bitmap for preview
+     */
+    public static Bitmap monochromeToPreviewBitmap(byte[] data, int width, int height) {
+        int bytesPerLine = width / 8;
+        Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
+        
+        int[] pixels = new int[width * height];
+        
+        for (int y = 0; y < height; y++) {
+            for (int x = 0; x < width; x++) {
+                int byteIndex = y * bytesPerLine + (x / 8);
+                int bitIndex = 7 - (x % 8);
+                boolean isBlack = (data[byteIndex] & (1 << bitIndex)) != 0;
+                pixels[y * width + x] = isBlack ? Color.BLACK : Color.WHITE;
+            }
+        }
+        
+        bitmap.setPixels(pixels, 0, width, 0, 0, width, height);
+        return bitmap;
+    }
 }

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

@@ -208,6 +208,14 @@ public class PrinterProtocol {
         return makeCommand(0xa0, intToBytes(pixels, 2));
     }
 
+    /**
+     * Get device info command (0xa8)
+     * Queries printer for model/firmware information
+     */
+    public static byte[] cmdGetDeviceInfo() {
+        return makeCommand(0xa8, new byte[]{0x00});
+    }
+
     /**
      * Create bitmap line command with bit reversal
      */
@@ -219,6 +227,17 @@ public class PrinterProtocol {
         return makeCommand(0xa2, reversed);
     }
 
+    /**
+     * Create compressed bitmap line command for newer printers (GB03+)
+     * Currently uses same format as regular bitmap - compression not yet implemented
+     * TODO: Implement actual compression algorithm from reference
+     */
+    public static byte[] cmdDrawCompressedBitmap(byte[] lineData) {
+        // For now, fall back to regular bitmap command
+        // The reference implementation also does this: draw_compressed_bitmap just calls draw_bitmap
+        return cmdDrawBitmap(lineData);
+    }
+
     /**
      * Check if data matches flow pause signal
      */
@@ -240,4 +259,77 @@ public class PrinterProtocol {
         }
         return true;
     }
+
+    // ==================== MODEL DETECTION ====================
+
+    /**
+     * Known printer models from reference implementation
+     */
+    public static final String[] KNOWN_MODELS = {
+        "_ZZ00", "GB01", "GB02", "GB03", "GT01", 
+        "MX05", "MX06", "MX08", "MX09", "MX10", "MX11", "YT01"
+    };
+
+    /**
+     * Models that support compressed data (new kind)
+     */
+    public static final String[] NEW_KIND_MODELS = {"GB03"};
+
+    /**
+     * Models with feeding problems that need workarounds
+     */
+    public static final String[] PROBLEM_FEEDING_MODELS = {"MX05", "MX06", "MX08", "MX09", "MX10"};
+
+    /**
+     * Detect printer model from device name
+     * @param deviceName Bluetooth device name
+     * @return Model string (e.g., "GB01", "GT01") or "_ZZ00" if unknown
+     */
+    public static String detectModel(String deviceName) {
+        if (deviceName == null || deviceName.isEmpty()) {
+            return "_ZZ00";
+        }
+        
+        String upperName = deviceName.toUpperCase();
+        
+        // Check for known model prefixes
+        for (String model : KNOWN_MODELS) {
+            if (upperName.contains(model)) {
+                return model;
+            }
+        }
+        
+        // Try to extract model pattern (2 letters + 2 digits)
+        for (int i = 0; i <= upperName.length() - 4; i++) {
+            String sub = upperName.substring(i, i + 4);
+            if (Character.isLetter(sub.charAt(0)) && 
+                Character.isLetter(sub.charAt(1)) &&
+                Character.isDigit(sub.charAt(2)) && 
+                Character.isDigit(sub.charAt(3))) {
+                return sub;
+            }
+        }
+        
+        return "_ZZ00";
+    }
+
+    /**
+     * Check if model is "new kind" (supports compressed data)
+     */
+    public static boolean isNewKind(String model) {
+        for (String m : NEW_KIND_MODELS) {
+            if (m.equals(model)) return true;
+        }
+        return false;
+    }
+
+    /**
+     * Check if model has feeding problems
+     */
+    public static boolean hasFeedingProblems(String model) {
+        for (String m : PROBLEM_FEEDING_MODELS) {
+            if (m.equals(model)) return true;
+        }
+        return false;
+    }
 }