@amitkhare/capacitor-cat-printer 0.5.0

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

@@ -0,0 +1,348 @@
+package khare.catprinter.plugin;
+
+import android.Manifest;
+import android.annotation.SuppressLint;
+import android.os.Build;
+import android.util.Log;
+
+import com.getcapacitor.JSArray;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.PermissionState;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+import com.getcapacitor.annotation.Permission;
+import com.getcapacitor.annotation.PermissionCallback;
+
+import java.util.List;
+
+/**
+ * Capacitor plugin for Cat thermal printers.
+ * Bridges JavaScript API to native Android BLE functionality.
+ */
+@CapacitorPlugin(
+    name = "CatPrinter",
+    permissions = {
+        @Permission(
+            alias = "bluetooth",
+            strings = {
+                Manifest.permission.BLUETOOTH,
+                Manifest.permission.BLUETOOTH_ADMIN
+            }
+        ),
+        @Permission(
+            alias = "bluetoothScan",
+            strings = {
+                Manifest.permission.BLUETOOTH_SCAN
+            }
+        ),
+        @Permission(
+            alias = "bluetoothConnect",
+            strings = {
+                Manifest.permission.BLUETOOTH_CONNECT
+            }
+        ),
+        @Permission(
+            alias = "location",
+            strings = {
+                Manifest.permission.ACCESS_FINE_LOCATION,
+                Manifest.permission.ACCESS_COARSE_LOCATION
+            }
+        )
+    }
+)
+public class CatPrinterPlugin extends Plugin {
+    private static final String TAG = "CatPrinterPlugin";
+    
+    private CatPrinterCore printerCore;
+
+    @Override
+    public void load() {
+        printerCore = new CatPrinterCore(getContext());
+    }
+
+    // ==================== PERMISSION HANDLING ====================
+
+    private boolean hasBluetoothPermissions() {
+        // Location is required for BLE scanning on all Android versions
+        boolean hasLocation = getPermissionState("location") == PermissionState.GRANTED;
+        Log.d(TAG, "Location permission: " + hasLocation);
+        
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            // Android 12+ also needs new Bluetooth permissions
+            boolean hasScan = getPermissionState("bluetoothScan") == PermissionState.GRANTED;
+            boolean hasConnect = getPermissionState("bluetoothConnect") == PermissionState.GRANTED;
+            Log.d(TAG, "Android 12+ permissions - Scan: " + hasScan + ", Connect: " + hasConnect + ", Location: " + hasLocation);
+            return hasScan && hasConnect && hasLocation;
+        } else {
+            // Android 11 and below
+            boolean hasBluetooth = getPermissionState("bluetooth") == PermissionState.GRANTED;
+            Log.d(TAG, "Android <12 permissions - Location: " + hasLocation + ", Bluetooth: " + hasBluetooth);
+            return hasLocation && hasBluetooth;
+        }
+    }
+
+    private void requestBluetoothPermissions(PluginCall call, String callbackName) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            // Android 12+ needs Bluetooth + Location permissions
+            Log.d(TAG, "Requesting Android 12+ Bluetooth + Location permissions");
+            requestPermissionForAliases(new String[]{"bluetoothScan", "bluetoothConnect", "location"}, call, callbackName);
+        } else {
+            Log.d(TAG, "Requesting Android <12 Bluetooth + Location permissions");
+            requestPermissionForAliases(new String[]{"bluetooth", "location"}, call, callbackName);
+        }
+    }
+
+    // ==================== SCANNING ====================
+
+    @PluginMethod
+    public void scan(PluginCall call) {
+        Log.d(TAG, "scan() called, checking permissions...");
+        if (!hasBluetoothPermissions()) {
+            Log.d(TAG, "Permissions not granted, requesting...");
+            requestBluetoothPermissions(call, "scanPermissionCallback");
+            return;
+        }
+        
+        Log.d(TAG, "Permissions granted, starting scan...");
+        performScan(call);
+    }
+
+    @PermissionCallback
+    private void scanPermissionCallback(PluginCall call) {
+        Log.d(TAG, "Permission callback received");
+        if (hasBluetoothPermissions()) {
+            Log.d(TAG, "Permissions now granted, starting scan...");
+            performScan(call);
+        } else {
+            Log.e(TAG, "Permissions still not granted");
+            call.reject("Bluetooth permissions required");
+        }
+    }
+
+    private void performScan(PluginCall call) {
+        int duration = call.getInt("duration", 4000);
+        
+        printerCore.startScan(duration, new CatPrinterCore.ScanResultCallback() {
+            @Override
+            public void onDeviceFound(String name, String address, int rssi) {
+                JSObject device = new JSObject();
+                device.put("name", name);
+                device.put("address", address);
+                device.put("rssi", rssi);
+                notifyListeners("scanResult", device);
+            }
+
+            @Override
+            public void onScanComplete(List<CatPrinterCore.BleDeviceInfo> devices) {
+                JSObject result = new JSObject();
+                JSArray devicesArray = new JSArray();
+                
+                for (CatPrinterCore.BleDeviceInfo device : devices) {
+                    JSObject deviceObj = new JSObject();
+                    deviceObj.put("name", device.name);
+                    deviceObj.put("address", device.address);
+                    deviceObj.put("rssi", device.rssi);
+                    devicesArray.put(deviceObj);
+                }
+                
+                result.put("devices", devicesArray);
+                call.resolve(result);
+            }
+
+            @Override
+            public void onScanError(String error) {
+                call.reject(error);
+            }
+        });
+    }
+
+    @PluginMethod
+    public void stopScan(PluginCall call) {
+        printerCore.stopScan();
+        call.resolve();
+    }
+
+    // ==================== CONNECTION ====================
+
+    @PluginMethod
+    public void connect(PluginCall call) {
+        if (!hasBluetoothPermissions()) {
+            requestBluetoothPermissions(call, "connectPermissionCallback");
+            return;
+        }
+        
+        performConnect(call);
+    }
+
+    @PermissionCallback
+    private void connectPermissionCallback(PluginCall call) {
+        if (hasBluetoothPermissions()) {
+            performConnect(call);
+        } else {
+            call.reject("Bluetooth permissions required");
+        }
+    }
+
+    private void performConnect(PluginCall call) {
+        String address = call.getString("address");
+        if (address == null || address.isEmpty()) {
+            call.reject("Address is required");
+            return;
+        }
+        
+        int paperWidth = call.getInt("paperWidth", PrinterProtocol.WIDTH_58MM);
+        
+        printerCore.connect(address, paperWidth, new CatPrinterCore.ConnectionCallback() {
+            @Override
+            public void onConnected() {
+                JSObject state = new JSObject();
+                state.put("connected", true);
+                state.put("address", address);
+                notifyListeners("connectionState", state);
+                call.resolve();
+            }
+
+            @Override
+            public void onDisconnected() {
+                JSObject state = new JSObject();
+                state.put("connected", false);
+                notifyListeners("connectionState", state);
+            }
+
+            @Override
+            public void onError(String error) {
+                call.reject(error);
+            }
+        });
+    }
+
+    @PluginMethod
+    public void disconnect(PluginCall call) {
+        printerCore.disconnect();
+        
+        JSObject state = new JSObject();
+        state.put("connected", false);
+        notifyListeners("connectionState", state);
+        
+        call.resolve();
+    }
+
+    @PluginMethod
+    public void isConnected(PluginCall call) {
+        JSObject result = new JSObject();
+        result.put("connected", printerCore.isConnected());
+        
+        if (printerCore.isConnected()) {
+            result.put("address", printerCore.getConnectedAddress());
+            result.put("paperWidth", printerCore.getPaperWidth());
+        }
+        
+        call.resolve(result);
+    }
+
+    // ==================== PRINTING ====================
+
+    @PluginMethod
+    public void printImage(PluginCall call) {
+        String imageBase64 = call.getString("imageBase64");
+        if (imageBase64 == null || imageBase64.isEmpty()) {
+            call.reject("imageBase64 is required");
+            return;
+        }
+        
+        Float energyObj = call.getFloat("energy", 0.5f);
+        float energy = energyObj != null ? energyObj : 0.5f;
+        int quality = call.getInt("quality", 3);
+        int feedAfter = call.getInt("feedAfter", 100);
+        int threshold = call.getInt("threshold", 127);
+        Boolean ditherObj = call.getBoolean("dither", true);
+        boolean dither = ditherObj != null ? ditherObj : true;
+        
+        printerCore.printImage(imageBase64, energy, quality, feedAfter, threshold, dither,
+            new CatPrinterCore.PrintCallback() {
+                @Override
+                public void onProgress(int percent, String status, String message) {
+                    JSObject progress = new JSObject();
+                    progress.put("percent", percent);
+                    progress.put("status", status);
+                    progress.put("message", message);
+                    notifyListeners("printProgress", progress);
+                }
+
+                @Override
+                public void onComplete() {
+                    call.resolve();
+                }
+
+                @Override
+                public void onError(String error) {
+                    call.reject(error);
+                }
+            });
+    }
+
+    @PluginMethod
+    public void printText(PluginCall call) {
+        String text = call.getString("text");
+        if (text == null || text.isEmpty()) {
+            call.reject("text is required");
+            return;
+        }
+        
+        int fontSize = call.getInt("fontSize", 24);
+        String align = call.getString("align", "left");
+        Boolean boldObj = call.getBoolean("bold", false);
+        boolean bold = boldObj != null ? boldObj : false;
+        Float lineSpacingObj = call.getFloat("lineSpacing", 1.2f);
+        float lineSpacing = lineSpacingObj != null ? lineSpacingObj : 1.2f;
+        Float energyObj = call.getFloat("energy", 0.6f);
+        float energy = energyObj != null ? energyObj : 0.6f;
+        int quality = call.getInt("quality", 3);
+        int feedAfter = call.getInt("feedAfter", 100);
+        
+        printerCore.printText(text, fontSize, align, bold, lineSpacing, 
+            energy, quality, feedAfter,
+            new CatPrinterCore.PrintCallback() {
+                @Override
+                public void onProgress(int percent, String status, String message) {
+                    JSObject progress = new JSObject();
+                    progress.put("percent", percent);
+                    progress.put("status", status);
+                    progress.put("message", message);
+                    notifyListeners("printProgress", progress);
+                }
+
+                @Override
+                public void onComplete() {
+                    call.resolve();
+                }
+
+                @Override
+                public void onError(String error) {
+                    call.reject(error);
+                }
+            });
+    }
+
+    @PluginMethod
+    public void feedPaper(PluginCall call) {
+        int pixels = call.getInt("pixels", 100);
+        
+        printerCore.feedPaper(pixels, new CatPrinterCore.PrintCallback() {
+            @Override
+            public void onProgress(int percent, String status, String message) {}
+
+            @Override
+            public void onComplete() {
+                call.resolve();
+            }
+
+            @Override
+            public void onError(String error) {
+                call.reject(error);
+            }
+        });
+    }
+}

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

@@ -0,0 +1,213 @@
+package khare.catprinter.plugin;
+
+import android.graphics.Bitmap;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.graphics.Typeface;
+import android.text.Layout;
+import android.text.StaticLayout;
+import android.text.TextPaint;
+
+/**
+ * Image processing utilities for thermal printing.
+ * Handles resizing, dithering, and text rendering.
+ */
+public class ImageProcessor {
+
+    /**
+     * Resize image to fit paper width while maintaining aspect ratio
+     */
+    public static Bitmap resizeToWidth(Bitmap source, int targetWidth) {
+        if (source.getWidth() == targetWidth) {
+            return source;
+        }
+        
+        float ratio = (float) targetWidth / source.getWidth();
+        int targetHeight = Math.round(source.getHeight() * ratio);
+        
+        return Bitmap.createScaledBitmap(source, targetWidth, targetHeight, true);
+    }
+
+    /**
+     * 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];
+        
+        int[] pixels = new int[width * height];
+        source.getPixels(pixels, 0, width, 0, 0, width, height);
+        
+        for (int y = 0; y < height; y++) {
+            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);
+                    result[byteIndex] |= (1 << bitIndex);
+                }
+            }
+        }
+        
+        return result;
+    }
+
+    /**
+     * 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();
+        int height = source.getHeight();
+        
+        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);
+        
+        float[] gray = new float[width * height];
+        for (int i = 0; i < pixels.length; i++) {
+            int pixel = pixels[i];
+            int r = Color.red(pixel);
+            int g = Color.green(pixel);
+            int b = Color.blue(pixel);
+            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;
+                float oldPixel = gray[idx];
+                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;
+                }
+                if (y + 1 < height) {
+                    if (x > 0) {
+                        gray[idx + width - 1] += error * 3 / 16f;
+                    }
+                    gray[idx + width] += error * 5 / 16f;
+                    if (x + 1 < width) {
+                        gray[idx + width + 1] += error * 1 / 16f;
+                    }
+                }
+            }
+        }
+        
+        return result;
+    }
+
+    /**
+     * Render text to a bitmap
+     */
+    public static Bitmap renderText(String text, int paperWidth, int fontSize, 
+                                     String align, boolean bold, float lineSpacing) {
+        // Create paint for text
+        TextPaint textPaint = new TextPaint(Paint.ANTI_ALIAS_FLAG);
+        textPaint.setColor(Color.BLACK);
+        textPaint.setTextSize(fontSize);
+        textPaint.setTypeface(bold ? Typeface.DEFAULT_BOLD : Typeface.MONOSPACE);
+        
+        // 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;
+        }
+        
+        // Create static layout to measure and render text
+        StaticLayout.Builder builder = StaticLayout.Builder.obtain(
+            text, 0, text.length(), textPaint, paperWidth
+        );
+        builder.setAlignment(alignment);
+        builder.setLineSpacing(0, lineSpacing);
+        builder.setIncludePad(true);
+        
+        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);
+        
+        Bitmap bitmap = Bitmap.createBitmap(paperWidth, height, Bitmap.Config.ARGB_8888);
+        Canvas canvas = new Canvas(bitmap);
+        canvas.drawColor(Color.WHITE);
+        
+        // Draw text
+        layout.draw(canvas);
+        
+        return bitmap;
+    }
+
+    /**
+     * Flip bitmap horizontally
+     */
+    public static void flipHorizontal(byte[] data, int width, int height) {
+        int bytesPerLine = width / 8;
+        byte[] temp = new byte[bytesPerLine];
+        
+        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);
+        }
+    }
+
+    /**
+     * Flip bitmap vertically
+     */
+    public static void flipVertical(byte[] data, int width, int height) {
+        int bytesPerLine = width / 8;
+        byte[] temp = new byte[bytesPerLine];
+        
+        for (int y = 0; y < height / 2; y++) {
+            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);
+        }
+    }
+}