@amitkhare/capacitor-cat-printer 0.5.0

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

@@ -0,0 +1,661 @@
+package khare.catprinter.plugin;
+
+import android.annotation.SuppressLint;
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothGatt;
+import android.bluetooth.BluetoothGattCallback;
+import android.bluetooth.BluetoothGattCharacteristic;
+import android.bluetooth.BluetoothGattDescriptor;
+import android.bluetooth.BluetoothGattService;
+import android.bluetooth.BluetoothManager;
+import android.bluetooth.BluetoothProfile;
+import android.bluetooth.le.BluetoothLeScanner;
+import android.bluetooth.le.ScanCallback;
+import android.bluetooth.le.ScanResult;
+import android.bluetooth.le.ScanSettings;
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Base64;
+import android.util.Log;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * Core BLE printer functionality.
+ * Handles scanning, connection, and printing operations.
+ * 
+ * Note: BLE permissions are handled by CatPrinterPlugin before calling these methods.
+ */
+@SuppressLint("MissingPermission")
+public class CatPrinterCore {
+    private static final String TAG = "CatPrinterCore";
+    private static final int MTU_SIZE = 200;
+    private static final int WRITE_DELAY_MS = 20;
+
+    private final Context context;
+    private final Handler mainHandler;
+    
+    private BluetoothAdapter bluetoothAdapter;
+    private BluetoothGatt gatt;
+    private BluetoothGattCharacteristic txCharacteristic;
+    
+    private String connectedAddress;
+    private int paperWidth = PrinterProtocol.WIDTH_58MM;
+    
+    private final AtomicBoolean isScanning = new AtomicBoolean(false);
+    private final AtomicBoolean isPaused = new AtomicBoolean(false);
+    private final AtomicBoolean isPrinting = new AtomicBoolean(false);
+    
+    private final ConcurrentLinkedQueue<byte[]> writeQueue = new ConcurrentLinkedQueue<>();
+    private final AtomicBoolean isWriting = new AtomicBoolean(false);
+
+    // Callbacks
+    private ScanResultCallback scanCallback;
+    private ConnectionCallback connectionCallback;
+    private PrintCallback printCallback;
+
+    public interface ScanResultCallback {
+        void onDeviceFound(String name, String address, int rssi);
+        void onScanComplete(List<BleDeviceInfo> devices);
+        void onScanError(String error);
+    }
+
+    public interface ConnectionCallback {
+        void onConnected();
+        void onDisconnected();
+        void onError(String error);
+    }
+
+    public interface PrintCallback {
+        void onProgress(int percent, String status, String message);
+        void onComplete();
+        void onError(String error);
+    }
+
+    public static class BleDeviceInfo {
+        public String name;
+        public String address;
+        public int rssi;
+
+        public BleDeviceInfo(String name, String address, int rssi) {
+            this.name = name;
+            this.address = address;
+            this.rssi = rssi;
+        }
+    }
+
+    public CatPrinterCore(Context context) {
+        this.context = context;
+        this.mainHandler = new Handler(Looper.getMainLooper());
+        initBluetooth();
+    }
+    
+    private void initBluetooth() {
+        BluetoothManager bluetoothManager = (BluetoothManager) context.getSystemService(Context.BLUETOOTH_SERVICE);
+        if (bluetoothManager != null) {
+            bluetoothAdapter = bluetoothManager.getAdapter();
+        }
+    }
+    
+    private BluetoothLeScanner getScanner() {
+        if (bluetoothAdapter == null) {
+            initBluetooth();
+        }
+        if (bluetoothAdapter != null && bluetoothAdapter.isEnabled()) {
+            return bluetoothAdapter.getBluetoothLeScanner();
+        }
+        return null;
+    }
+
+    // ==================== SCANNING ====================
+    
+    private ScanCallback activeScanCallback;
+
+    public void startScan(int durationMs, ScanResultCallback callback) {
+        this.scanCallback = callback;
+        
+        if (bluetoothAdapter == null) {
+            initBluetooth();
+        }
+        
+        if (bluetoothAdapter == null || !bluetoothAdapter.isEnabled()) {
+            callback.onScanError("Bluetooth is not enabled. Please enable Bluetooth and try again.");
+            return;
+        }
+
+        final BluetoothLeScanner bleScanner = getScanner();
+        if (bleScanner == null) {
+            callback.onScanError("BLE scanner not available. Please enable Bluetooth and try again.");
+            return;
+        }
+
+        if (isScanning.get()) {
+            stopScan();
+        }
+
+        final List<BleDeviceInfo> foundDevices = new ArrayList<>();
+        
+        activeScanCallback = new ScanCallback() {
+            @Override
+            public void onScanResult(int callbackType, ScanResult result) {
+                BluetoothDevice device = result.getDevice();
+                String name = device.getName();
+                String address = device.getAddress();
+                int rssi = result.getRssi();
+                
+                // Show all devices - use address as name if no name available
+                if (name == null || name.isEmpty()) {
+                    name = address;
+                }
+                
+                // Check if already in list
+                boolean exists = false;
+                synchronized (foundDevices) {
+                    for (BleDeviceInfo info : foundDevices) {
+                        if (info.address.equals(address)) {
+                            exists = true;
+                            break;
+                        }
+                    }
+                    
+                    if (!exists) {
+                        BleDeviceInfo info = new BleDeviceInfo(name, address, rssi);
+                        foundDevices.add(info);
+                    }
+                }
+                
+                if (!exists) {
+                    final String finalName = name;
+                    mainHandler.post(() -> callback.onDeviceFound(finalName, address, rssi));
+                }
+            }
+
+            @Override
+            public void onScanFailed(int errorCode) {
+                isScanning.set(false);
+                activeScanCallback = null;
+                String errorMsg = "Scan failed: ";
+                switch (errorCode) {
+                    case ScanCallback.SCAN_FAILED_ALREADY_STARTED:
+                        errorMsg += "Already started";
+                        break;
+                    case ScanCallback.SCAN_FAILED_APPLICATION_REGISTRATION_FAILED:
+                        errorMsg += "App registration failed";
+                        break;
+                    case ScanCallback.SCAN_FAILED_FEATURE_UNSUPPORTED:
+                        errorMsg += "Feature unsupported";
+                        break;
+                    case ScanCallback.SCAN_FAILED_INTERNAL_ERROR:
+                        errorMsg += "Internal error";
+                        break;
+                    default:
+                        errorMsg += "Error code " + errorCode;
+                }
+                final String finalErrorMsg = errorMsg;
+                mainHandler.post(() -> callback.onScanError(finalErrorMsg));
+            }
+        };
+
+        // Use low latency scan settings for faster discovery
+        ScanSettings scanSettings = new ScanSettings.Builder()
+            .setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY)
+            .build();
+
+        isScanning.set(true);
+        Log.d(TAG, "Starting BLE scan with low latency mode...");
+        bleScanner.startScan(null, scanSettings, activeScanCallback);
+
+        // Stop scan after duration
+        mainHandler.postDelayed(() -> {
+            if (isScanning.get() && activeScanCallback != null) {
+                try {
+                    bleScanner.stopScan(activeScanCallback);
+                } catch (Exception e) {
+                    Log.w(TAG, "Error stopping scan", e);
+                }
+                isScanning.set(false);
+                activeScanCallback = null;
+                
+                synchronized (foundDevices) {
+                    callback.onScanComplete(new ArrayList<>(foundDevices));
+                }
+            }
+        }, durationMs);
+    }
+
+    public void stopScan() {
+        if (isScanning.get() && activeScanCallback != null) {
+            BluetoothLeScanner bleScanner = getScanner();
+            if (bleScanner != null) {
+                try {
+                    bleScanner.stopScan(activeScanCallback);
+                } catch (Exception e) {
+                    Log.w(TAG, "Error stopping scan", e);
+                }
+            }
+            isScanning.set(false);
+            activeScanCallback = null;
+        }
+    }
+
+    // ==================== CONNECTION ====================
+
+    public void connect(String address, int width, ConnectionCallback callback) {
+        this.connectionCallback = callback;
+        this.paperWidth = width;
+
+        if (bluetoothAdapter == null) {
+            callback.onError("Bluetooth not available");
+            return;
+        }
+
+        // Disconnect existing connection
+        if (gatt != null) {
+            disconnect();
+        }
+
+        BluetoothDevice device = bluetoothAdapter.getRemoteDevice(address);
+        if (device == null) {
+            callback.onError("Device not found: " + address);
+            return;
+        }
+
+        gatt = device.connectGatt(context, false, gattCallback, BluetoothDevice.TRANSPORT_LE);
+    }
+
+    public void disconnect() {
+        if (gatt != null) {
+            gatt.disconnect();
+            gatt.close();
+            gatt = null;
+        }
+        txCharacteristic = null;
+        connectedAddress = null;
+        isPaused.set(false);
+        writeQueue.clear();
+    }
+
+    public boolean isConnected() {
+        return gatt != null && txCharacteristic != null;
+    }
+
+    public String getConnectedAddress() {
+        return connectedAddress;
+    }
+
+    public int getPaperWidth() {
+        return paperWidth;
+    }
+
+    private final BluetoothGattCallback gattCallback = new BluetoothGattCallback() {
+        @Override
+        public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
+            if (newState == BluetoothProfile.STATE_CONNECTED) {
+                Log.d(TAG, "Connected to GATT server");
+                gatt.discoverServices();
+            } else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
+                Log.d(TAG, "Disconnected from GATT server");
+                connectedAddress = null;
+                txCharacteristic = null;
+                if (connectionCallback != null) {
+                    mainHandler.post(() -> connectionCallback.onDisconnected());
+                }
+            }
+        }
+
+        @Override
+        public void onServicesDiscovered(BluetoothGatt gatt, int status) {
+            if (status == BluetoothGatt.GATT_SUCCESS) {
+                // Find the printer service and characteristics
+                for (BluetoothGattService service : gatt.getServices()) {
+                    BluetoothGattCharacteristic tx = service.getCharacteristic(PrinterProtocol.TX_CHAR_UUID);
+                    BluetoothGattCharacteristic rx = service.getCharacteristic(PrinterProtocol.RX_CHAR_UUID);
+                    
+                    if (tx != null && rx != null) {
+                        txCharacteristic = tx;
+                        connectedAddress = gatt.getDevice().getAddress();
+                        
+                        // Enable notifications on RX for flow control
+                        gatt.setCharacteristicNotification(rx, true);
+                        BluetoothGattDescriptor descriptor = rx.getDescriptor(PrinterProtocol.CCCD_UUID);
+                        if (descriptor != null) {
+                            descriptor.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
+                            gatt.writeDescriptor(descriptor);
+                        }
+                        
+                        if (connectionCallback != null) {
+                            mainHandler.post(() -> connectionCallback.onConnected());
+                        }
+                        return;
+                    }
+                }
+                
+                // Characteristics not found
+                if (connectionCallback != null) {
+                    mainHandler.post(() -> connectionCallback.onError("Printer characteristics not found"));
+                }
+            } else {
+                if (connectionCallback != null) {
+                    mainHandler.post(() -> connectionCallback.onError("Service discovery failed"));
+                }
+            }
+        }
+
+        @Override
+        public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
+            byte[] data = characteristic.getValue();
+            if (data != null) {
+                if (PrinterProtocol.isFlowPause(data)) {
+                    isPaused.set(true);
+                    Log.d(TAG, "Flow control: PAUSE");
+                } else if (PrinterProtocol.isFlowResume(data)) {
+                    isPaused.set(false);
+                    Log.d(TAG, "Flow control: RESUME");
+                    processWriteQueue();
+                }
+            }
+        }
+
+        @Override
+        public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
+            isWriting.set(false);
+            if (status == BluetoothGatt.GATT_SUCCESS) {
+                processWriteQueue();
+            } else {
+                Log.e(TAG, "Write failed with status: " + status);
+            }
+        }
+    };
+
+    // ==================== WRITING ====================
+
+    private void queueWrite(byte[] data) {
+        // Split into MTU-sized chunks
+        int offset = 0;
+        while (offset < data.length) {
+            int chunkSize = Math.min(MTU_SIZE, data.length - offset);
+            byte[] chunk = new byte[chunkSize];
+            System.arraycopy(data, offset, chunk, 0, chunkSize);
+            writeQueue.add(chunk);
+            offset += chunkSize;
+        }
+        processWriteQueue();
+    }
+
+    private void processWriteQueue() {
+        if (isPaused.get() || isWriting.get() || writeQueue.isEmpty()) {
+            return;
+        }
+        
+        if (gatt == null || txCharacteristic == null) {
+            writeQueue.clear();
+            return;
+        }
+
+        byte[] data = writeQueue.poll();
+        if (data != null) {
+            isWriting.set(true);
+            txCharacteristic.setValue(data);
+            txCharacteristic.setWriteType(BluetoothGattCharacteristic.WRITE_TYPE_NO_RESPONSE);
+            
+            boolean success = gatt.writeCharacteristic(txCharacteristic);
+            if (!success) {
+                isWriting.set(false);
+                Log.e(TAG, "Failed to initiate write");
+            }
+            
+            // Small delay between writes
+            mainHandler.postDelayed(this::processWriteQueue, WRITE_DELAY_MS);
+        }
+    }
+
+    private void flushQueue() {
+        // Wait for queue to empty with timeout
+        int maxWaitMs = 60000; // 60 second timeout for long images
+        int waited = 0;
+        int sleepInterval = 50;
+        
+        while ((!writeQueue.isEmpty() || isWriting.get()) && waited < maxWaitMs) {
+            try {
+                Thread.sleep(sleepInterval);
+                waited += sleepInterval;
+                
+                // If paused, wait but don't count against timeout
+                if (isPaused.get()) {
+                    waited = Math.max(0, waited - sleepInterval);
+                }
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+                break;
+            }
+        }
+        
+        if (waited >= maxWaitMs) {
+            Log.w(TAG, "Flush timeout - queue may not be empty");
+        }
+    }
+
+    // ==================== PRINTING ====================
+
+    public void printImage(String base64Image, float energy, int quality, 
+                          int feedAfter, int threshold, boolean dither, 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);
+
+        new Thread(() -> {
+            try {
+                reportProgress(0, "processing", "Decoding image");
+                
+                // Decode base64 image
+                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");
+                }
+                
+                Log.d(TAG, "Original image size: " + bitmap.getWidth() + "x" + bitmap.getHeight());
+
+                reportProgress(10, "processing", "Resizing image");
+                
+                // Resize to paper width
+                bitmap = ImageProcessor.resizeToWidth(bitmap, paperWidth);
+                
+                Log.d(TAG, "Resized image size: " + bitmap.getWidth() + "x" + bitmap.getHeight());
+
+                reportProgress(20, "processing", "Converting to monochrome");
+                
+                // Convert to 1-bit monochrome (use dithering for better quality)
+                byte[] monoData;
+                if (dither) {
+                    monoData = ImageProcessor.toMonochromeDithered(bitmap, threshold);
+                } else {
+                    monoData = ImageProcessor.toMonochrome(bitmap, threshold);
+                }
+                int height = bitmap.getHeight();
+                
+                Log.d(TAG, "Printing " + height + " lines");
+                
+                bitmap.recycle();
+
+                // Print the bitmap
+                printBitmapData(monoData, paperWidth, height, energy, quality, feedAfter);
+                
+            } catch (Exception e) {
+                Log.e(TAG, "Print error", e);
+                isPrinting.set(false);
+                mainHandler.post(() -> callback.onError(e.getMessage()));
+            }
+        }).start();
+    }
+
+    public void printText(String text, int fontSize, String align, boolean bold,
+                         float lineSpacing, float energy, int quality, 
+                         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);
+
+        new Thread(() -> {
+            try {
+                reportProgress(0, "processing", "Rendering text");
+                
+                // Render text to bitmap
+                Bitmap bitmap = ImageProcessor.renderText(text, paperWidth, fontSize, 
+                                                          align, bold, lineSpacing);
+                
+                reportProgress(20, "processing", "Converting to monochrome");
+                
+                // Convert to 1-bit (use lower threshold for text - sharper)
+                byte[] monoData = ImageProcessor.toMonochrome(bitmap, 127);
+                int height = bitmap.getHeight();
+                
+                bitmap.recycle();
+
+                // Print the bitmap
+                printBitmapData(monoData, paperWidth, height, energy, quality, feedAfter);
+                
+            } catch (Exception e) {
+                Log.e(TAG, "Print error", e);
+                isPrinting.set(false);
+                mainHandler.post(() -> callback.onError(e.getMessage()));
+            }
+        }).start();
+    }
+
+    private void printBitmapData(byte[] data, int width, int height, 
+                                 float energy, int quality, int feedAfter) {
+        try {
+            int bytesPerLine = width / 8;
+            int totalLines = height;
+            
+            reportProgress(30, "printing", "Initializing printer");
+            
+            // Calculate energy and speed values
+            // Reference: energy = int(args.energy * 0xffff)
+            int energyValue = (int) (energy * 0xffff);
+            // Reference: speed = 4 * (quality + 5), quality 1-4 -> speed 24-36
+            int speedValue = 4 * (quality + 5);
+            
+            // === PREPARE PHASE (matches reference _prepare method) ===
+            // 1. Get device state
+            queueWrite(PrinterProtocol.cmdGetDeviceState());
+            
+            // 2. Start printing (use standard command, not new)
+            queueWrite(PrinterProtocol.cmdStartPrinting());
+            
+            // 3. Set DPI
+            queueWrite(PrinterProtocol.cmdSetDpi200());
+            
+            // 4. Set speed (if specified)
+            if (speedValue > 0) {
+                queueWrite(PrinterProtocol.cmdSetSpeed(speedValue));
+            }
+            
+            // 5. Set energy (if specified)
+            if (energyValue > 0) {
+                queueWrite(PrinterProtocol.cmdSetEnergy(energyValue));
+            }
+            
+            // 6. Apply energy
+            queueWrite(PrinterProtocol.cmdApplyEnergy());
+            
+            // 7. Update device
+            queueWrite(PrinterProtocol.cmdUpdateDevice());
+            
+            // 8. Flush before starting lattice (important!)
+            flushQueue();
+            
+            // 9. Start lattice
+            queueWrite(PrinterProtocol.cmdStartLattice());
+            
+            // === PRINT BITMAP DATA ===
+            for (int line = 0; line < totalLines; line++) {
+                int offset = line * bytesPerLine;
+                byte[] lineData = new byte[bytesPerLine];
+                System.arraycopy(data, offset, lineData, 0, bytesPerLine);
+                
+                queueWrite(PrinterProtocol.cmdDrawBitmap(lineData));
+                
+                // Report progress every 50 lines
+                if (line % 50 == 0) {
+                    int progress = 30 + (int) ((line / (float) totalLines) * 60);
+                    reportProgress(progress, "printing", "Printing line " + line + "/" + totalLines);
+                }
+            }
+            
+            reportProgress(90, "feeding", "Finishing");
+            
+            // === FINISH PHASE (matches reference _finish method) ===
+            // 1. End lattice
+            queueWrite(PrinterProtocol.cmdEndLattice());
+            
+            // 2. Set speed to 8 for feeding
+            queueWrite(PrinterProtocol.cmdSetSpeed(8));
+            
+            // 3. Feed paper
+            queueWrite(PrinterProtocol.cmdFeedPaper(feedAfter));
+            
+            // 4. Get device state
+            queueWrite(PrinterProtocol.cmdGetDeviceState());
+            
+            // 5. Final flush
+            flushQueue();
+            
+            isPrinting.set(false);
+            reportProgress(100, "done", "Complete");
+            
+            if (printCallback != null) {
+                mainHandler.post(() -> printCallback.onComplete());
+            }
+            
+        } catch (Exception e) {
+            isPrinting.set(false);
+            throw new RuntimeException(e);
+        }
+    }
+
+    public void feedPaper(int pixels, PrintCallback callback) {
+        if (!isConnected()) {
+            callback.onError("Not connected to printer");
+            return;
+        }
+
+        queueWrite(PrinterProtocol.cmdFeedPaper(pixels));
+        callback.onComplete();
+    }
+
+    private void reportProgress(int percent, String status, String message) {
+        if (printCallback != null) {
+            mainHandler.post(() -> printCallback.onProgress(percent, status, message));
+        }
+    }
+}