react-native-earl-thermal-printer 1.0.0

package/android/src/main/java/com/pinmi/react/printer/RNPrinterPackage.java

@@ -0,0 +1,57 @@
+package com.pinmi.react.printer;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.TurboReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.module.model.ReactModuleInfo;
+import com.facebook.react.module.model.ReactModuleInfoProvider;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * TurboReactPackage that registers all printer TurboModules.
+ *
+ * @author Ordovez, Earl Romeo
+ */
+public class RNPrinterPackage extends TurboReactPackage {
+
+    @Nullable
+    @Override
+    public NativeModule getModule(@NonNull String name, @NonNull ReactApplicationContext reactContext) {
+        switch (name) {
+            case RNUSBPrinterModule.NAME:
+                return new RNUSBPrinterModule(reactContext);
+            case RNBLEPrinterModule.NAME:
+                return new RNBLEPrinterModule(reactContext);
+            case RNNetPrinterModule.NAME:
+                return new RNNetPrinterModule(reactContext);
+            default:
+                return null;
+        }
+    }
+
+    @Override
+    public ReactModuleInfoProvider getReactModuleInfoProvider() {
+        return () -> {
+            final Map<String, ReactModuleInfo> moduleInfos = new HashMap<>();
+            boolean isTurboModule = true;
+            moduleInfos.put(RNUSBPrinterModule.NAME, new ReactModuleInfo(
+                    RNUSBPrinterModule.NAME,
+                    RNUSBPrinterModule.class.getName(),
+                    false, false, false, false, isTurboModule));
+            moduleInfos.put(RNBLEPrinterModule.NAME, new ReactModuleInfo(
+                    RNBLEPrinterModule.NAME,
+                    RNBLEPrinterModule.class.getName(),
+                    false, false, false, false, isTurboModule));
+            moduleInfos.put(RNNetPrinterModule.NAME, new ReactModuleInfo(
+                    RNNetPrinterModule.NAME,
+                    RNNetPrinterModule.class.getName(),
+                    false, false, false, false, isTurboModule));
+            return moduleInfos;
+        };
+    }
+}

package/android/src/main/java/com/pinmi/react/printer/RNUSBPrinterModule.java

@@ -0,0 +1,79 @@
+package com.pinmi.react.printer;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactMethod;
+import com.pinmi.react.printer.adapter.PrinterAdapter;
+import com.pinmi.react.printer.adapter.USBPrinterAdapter;
+import com.pinmi.react.printer.adapter.USBPrinterDeviceId;
+
+/**
+ * TurboModule implementation for USB thermal receipt printers.
+ *
+ * @author Ordovez, Earl Romeo
+ */
+public class RNUSBPrinterModule extends NativeUSBPrinterSpec implements RNPrinterModule {
+
+    public static final String NAME = "RNUSBPrinter";
+
+    private PrinterAdapter adapter;
+
+    public RNUSBPrinterModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+    }
+
+    @Override
+    @NonNull
+    public String getName() {
+        return NAME;
+    }
+
+    @Override
+    @ReactMethod
+    public void init(Promise promise) {
+        this.adapter = USBPrinterAdapter.getInstance();
+        this.adapter.init(getReactApplicationContext(), promise);
+    }
+
+    @Override
+    @ReactMethod
+    public void closeConn() {
+        if (adapter != null) {
+            adapter.closeConnectionIfExists();
+        }
+    }
+
+    @Override
+    @ReactMethod
+    public void getDeviceList(Promise promise) {
+        adapter.getDeviceList(promise);
+    }
+
+    @Override
+    @ReactMethod
+    public void connectPrinter(double vendorId, double productId, Promise promise) {
+        adapter.selectDevice(
+                USBPrinterDeviceId.valueOf((int) vendorId, (int) productId),
+                promise);
+    }
+
+    @Override
+    @ReactMethod
+    public void printRawData(String base64Data, Promise promise) {
+        adapter.printRawData(base64Data, promise);
+    }
+
+    @Override
+    @ReactMethod
+    public void printImageData(String imageUrl, Promise promise) {
+        adapter.printImageData(imageUrl, promise);
+    }
+
+    @Override
+    @ReactMethod
+    public void printQrCode(String qrCode, Promise promise) {
+        adapter.printQrCode(qrCode, promise);
+    }
+}

package/android/src/main/java/com/pinmi/react/printer/adapter/BLEPrinterAdapter.java

@@ -0,0 +1,391 @@
+package com.pinmi.react.printer.adapter;
+
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothSocket;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Color;
+import android.util.Base64;
+import android.util.Log;
+import android.widget.Toast;
+
+import com.facebook.common.internal.ImmutableMap;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.WritableArray;
+import com.google.zxing.EncodeHintType;
+import com.google.zxing.WriterException;
+import com.google.zxing.common.BitMatrix;
+import com.google.zxing.qrcode.QRCodeWriter;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.util.Set;
+import java.util.UUID;
+
+/**
+ * BLE (Bluetooth) printer adapter implementation.
+ * Migrated to Promise-based API for React Native New Architecture (TurboModules).
+ *
+ * @author Ordovez, Earl Romeo
+ */
+public class BLEPrinterAdapter implements PrinterAdapter {
+    private static BLEPrinterAdapter mInstance;
+
+    private String LOG_TAG = "RNBLEPrinter";
+
+    private BluetoothDevice mBluetoothDevice;
+    private BluetoothSocket mBluetoothSocket;
+
+    private ReactApplicationContext mContext;
+
+    private final static char ESC_CHAR = 0x1B;
+    private static byte[] SELECT_BIT_IMAGE_MODE = { 0x1B, 0x2A, 33 };
+    private final static byte[] SET_LINE_SPACE_24 = new byte[] { ESC_CHAR, 0x33, 24 };
+    private final static byte[] SET_LINE_SPACE_32 = new byte[] { ESC_CHAR, 0x33, 32 };
+    private final static byte[] LINE_FEED = new byte[] { 0x0A };
+    private static byte[] CENTER_ALIGN = { 0x1B, 0X61, 0X31 };
+
+    private BLEPrinterAdapter() {
+    }
+
+    public static BLEPrinterAdapter getInstance() {
+        if (mInstance == null) {
+            mInstance = new BLEPrinterAdapter();
+        }
+        return mInstance;
+    }
+
+    @Override
+    public void init(ReactApplicationContext reactContext, Promise promise) {
+        this.mContext = reactContext;
+        BluetoothAdapter bluetoothAdapter = getBTAdapter();
+        if (bluetoothAdapter == null) {
+            promise.reject("ERR_BT_ADAPTER", "No bluetooth adapter available");
+            return;
+        }
+        if (!bluetoothAdapter.isEnabled()) {
+            promise.reject("ERR_BT_DISABLED", "Bluetooth adapter is not enabled");
+            return;
+        }
+        promise.resolve("RNBLEPrinter initialized");
+    }
+
+    private static BluetoothAdapter getBTAdapter() {
+        return BluetoothAdapter.getDefaultAdapter();
+    }
+
+    @Override
+    public void getDeviceList(Promise promise) {
+        BluetoothAdapter bluetoothAdapter = getBTAdapter();
+        if (bluetoothAdapter == null) {
+            promise.reject("ERR_BT_ADAPTER", "No bluetooth adapter available");
+            return;
+        }
+        if (!bluetoothAdapter.isEnabled()) {
+            promise.reject("ERR_BT_DISABLED", "Bluetooth is not enabled");
+            return;
+        }
+        WritableArray array = Arguments.createArray();
+        Set<BluetoothDevice> pairedDevices = getBTAdapter().getBondedDevices();
+        for (BluetoothDevice device : pairedDevices) {
+            array.pushMap(new BLEPrinterDevice(device).toRNWritableMap());
+        }
+        promise.resolve(array);
+    }
+
+    @Override
+    public void selectDevice(PrinterDeviceId printerDeviceId, Promise promise) {
+        BluetoothAdapter bluetoothAdapter = getBTAdapter();
+        if (bluetoothAdapter == null) {
+            promise.reject("ERR_BT_ADAPTER", "No bluetooth adapter available");
+            return;
+        }
+        if (!bluetoothAdapter.isEnabled()) {
+            promise.reject("ERR_BT_DISABLED", "Bluetooth is not enabled");
+            return;
+        }
+        BLEPrinterDeviceId blePrinterDeviceId = (BLEPrinterDeviceId) printerDeviceId;
+        if (this.mBluetoothDevice != null) {
+            if (this.mBluetoothDevice.getAddress().equals(blePrinterDeviceId.getInnerMacAddress())
+                    && this.mBluetoothSocket != null) {
+                Log.v(LOG_TAG, "do not need to reconnect");
+                promise.resolve(new BLEPrinterDevice(this.mBluetoothDevice).toRNWritableMap());
+                return;
+            } else {
+                closeConnectionIfExists();
+            }
+        }
+        Set<BluetoothDevice> pairedDevices = getBTAdapter().getBondedDevices();
+        for (BluetoothDevice device : pairedDevices) {
+            if (device.getAddress().equals(blePrinterDeviceId.getInnerMacAddress())) {
+                try {
+                    connectBluetoothDevice(device);
+                    promise.resolve(new BLEPrinterDevice(this.mBluetoothDevice).toRNWritableMap());
+                    return;
+                } catch (IOException e) {
+                    e.printStackTrace();
+                    promise.reject("ERR_BT_CONNECT", e.getMessage());
+                    return;
+                }
+            }
+        }
+        String errorText = "Can not find the specified printing device, please perform Bluetooth pairing in the system settings first.";
+        Toast.makeText(this.mContext, errorText, Toast.LENGTH_LONG).show();
+        promise.reject("ERR_NOT_FOUND", errorText);
+    }
+
+    private void connectBluetoothDevice(BluetoothDevice device) throws IOException {
+        UUID uuid = UUID.fromString("00001101-0000-1000-8000-00805f9b34fb");
+        this.mBluetoothSocket = device.createRfcommSocketToServiceRecord(uuid);
+        this.mBluetoothSocket.connect();
+        this.mBluetoothDevice = device;
+    }
+
+    @Override
+    public void closeConnectionIfExists() {
+        try {
+            if (this.mBluetoothSocket != null) {
+                this.mBluetoothSocket.close();
+                this.mBluetoothSocket = null;
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+
+        if (this.mBluetoothDevice != null) {
+            this.mBluetoothDevice = null;
+        }
+    }
+
+    @Override
+    public void printRawData(String rawBase64Data, Promise promise) {
+        if (this.mBluetoothSocket == null) {
+            promise.reject("ERR_NO_CONN", "Bluetooth connection is not built, may be you forgot to connectPrinter");
+            return;
+        }
+        final String rawData = rawBase64Data;
+        final BluetoothSocket socket = this.mBluetoothSocket;
+        Log.v(LOG_TAG, "start to print raw data " + rawBase64Data);
+        new Thread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    byte[] bytes = Base64.decode(rawData, Base64.DEFAULT);
+                    OutputStream printerOutputStream = socket.getOutputStream();
+                    printerOutputStream.write(bytes, 0, bytes.length);
+                    printerOutputStream.flush();
+                    promise.resolve(null);
+                } catch (IOException e) {
+                    Log.e(LOG_TAG, "failed to print data" + rawData);
+                    e.printStackTrace();
+                    promise.reject("ERR_PRINT", e.getMessage());
+                }
+            }
+        }).start();
+    }
+
+    public static Bitmap getBitmapFromURL(String src) {
+        try {
+            URL url = new URL(src);
+            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
+            connection.setDoInput(true);
+            connection.connect();
+            InputStream input = connection.getInputStream();
+            Bitmap myBitmap = BitmapFactory.decodeStream(input);
+
+            ByteArrayOutputStream baos = new ByteArrayOutputStream();
+            myBitmap.compress(Bitmap.CompressFormat.PNG, 100, baos);
+
+            return myBitmap;
+        } catch (IOException e) {
+            return null;
+        }
+    }
+
+    @Override
+    public void printImageData(String imageUrl, Promise promise) {
+        final Bitmap bitmapImage = getBitmapFromURL(imageUrl);
+
+        if (bitmapImage == null) {
+            promise.reject("ERR_IMAGE", "image not found");
+            return;
+        }
+        if (this.mBluetoothSocket == null) {
+            promise.reject("ERR_NO_CONN", "Bluetooth connection is not built, may be you forgot to connectPrinter");
+            return;
+        }
+
+        final BluetoothSocket socket = this.mBluetoothSocket;
+
+        try {
+            int[][] pixels = getPixelsSlow(bitmapImage);
+            OutputStream printerOutputStream = socket.getOutputStream();
+
+            printerOutputStream.write(SET_LINE_SPACE_24);
+            printerOutputStream.write(CENTER_ALIGN);
+
+            for (int y = 0; y < pixels.length; y += 24) {
+                printerOutputStream.write(SELECT_BIT_IMAGE_MODE);
+                printerOutputStream.write(
+                        new byte[] { (byte) (0x00ff & pixels[y].length), (byte) ((0xff00 & pixels[y].length) >> 8) });
+                for (int x = 0; x < pixels[y].length; x++) {
+                    printerOutputStream.write(recollectSlice(y, x, pixels));
+                }
+                printerOutputStream.write(LINE_FEED);
+            }
+            printerOutputStream.write(SET_LINE_SPACE_32);
+            printerOutputStream.write(LINE_FEED);
+            printerOutputStream.flush();
+            promise.resolve(null);
+        } catch (IOException e) {
+            Log.e(LOG_TAG, "failed to print data");
+            e.printStackTrace();
+            promise.reject("ERR_PRINT_IMAGE", e.getMessage());
+        }
+    }
+
+    @Override
+    public void printQrCode(String qrCode, Promise promise) {
+        final Bitmap bitmapImage = TextToQrImageEncode(qrCode);
+
+        if (bitmapImage == null) {
+            promise.reject("ERR_QR", "QR code generation failed");
+            return;
+        }
+        if (this.mBluetoothSocket == null) {
+            promise.reject("ERR_NO_CONN", "Bluetooth connection is not built, may be you forgot to connectPrinter");
+            return;
+        }
+
+        final BluetoothSocket socket = this.mBluetoothSocket;
+
+        try {
+            int[][] pixels = getPixelsSlow(bitmapImage);
+            OutputStream printerOutputStream = socket.getOutputStream();
+
+            printerOutputStream.write(SET_LINE_SPACE_24);
+            printerOutputStream.write(CENTER_ALIGN);
+
+            for (int y = 0; y < pixels.length; y += 24) {
+                printerOutputStream.write(SELECT_BIT_IMAGE_MODE);
+                printerOutputStream.write(
+                        new byte[] { (byte) (0x00ff & pixels[y].length), (byte) ((0xff00 & pixels[y].length) >> 8) });
+                for (int x = 0; x < pixels[y].length; x++) {
+                    printerOutputStream.write(recollectSlice(y, x, pixels));
+                }
+                printerOutputStream.write(LINE_FEED);
+            }
+            printerOutputStream.write(SET_LINE_SPACE_32);
+            printerOutputStream.write(LINE_FEED);
+            printerOutputStream.flush();
+            promise.resolve(null);
+        } catch (IOException e) {
+            Log.e(LOG_TAG, "failed to print data");
+            e.printStackTrace();
+            promise.reject("ERR_PRINT_QR", e.getMessage());
+        }
+    }
+
+    private Bitmap TextToQrImageEncode(String Value) {
+        com.google.zxing.Writer writer = new QRCodeWriter();
+        BitMatrix bitMatrix = null;
+        try {
+            bitMatrix = writer.encode(Value, com.google.zxing.BarcodeFormat.QR_CODE, 250, 250,
+                    ImmutableMap.of(EncodeHintType.MARGIN, 1));
+            int width = 250;
+            int height = 250;
+            Bitmap bmp = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
+
+            for (int i = 0; i < width; i++) {
+                for (int j = 0; j < height; j++) {
+                    bmp.setPixel(i, j, bitMatrix.get(i, j) ? Color.BLACK : Color.WHITE);
+                }
+            }
+            return bmp;
+        } catch (WriterException e) {
+            return null;
+        }
+    }
+
+    public static int[][] getPixelsSlow(Bitmap image2) {
+        Bitmap image = resizeTheImageForPrinting(image2);
+        int width = image.getWidth();
+        int height = image.getHeight();
+        int[][] result = new int[height][width];
+        for (int row = 0; row < height; row++) {
+            for (int col = 0; col < width; col++) {
+                result[row][col] = getRGB(image, col, row);
+            }
+        }
+        return result;
+    }
+
+    private byte[] recollectSlice(int y, int x, int[][] img) {
+        byte[] slices = new byte[] { 0, 0, 0 };
+        for (int yy = y, i = 0; yy < y + 24 && i < 3; yy += 8, i++) {
+            byte slice = 0;
+            for (int b = 0; b < 8; b++) {
+                int yyy = yy + b;
+                if (yyy >= img.length) {
+                    continue;
+                }
+                int col = img[yyy][x];
+                boolean v = shouldPrintColor(col);
+                slice |= (byte) ((v ? 1 : 0) << (7 - b));
+            }
+            slices[i] = slice;
+        }
+        return slices;
+    }
+
+    private boolean shouldPrintColor(int col) {
+        final int threshold = 127;
+        int a, r, g, b, luminance;
+        a = (col >> 24) & 0xff;
+        if (a != 0xff) {
+            return false;
+        }
+        r = (col >> 16) & 0xff;
+        g = (col >> 8) & 0xff;
+        b = col & 0xff;
+
+        luminance = (int) (0.299 * r + 0.587 * g + 0.114 * b);
+        return luminance < threshold;
+    }
+
+    public static Bitmap resizeTheImageForPrinting(Bitmap image) {
+        int width = image.getWidth();
+        int height = image.getHeight();
+        if (width > 200 || height > 200) {
+            if (width > height) {
+                float decreaseSizeBy = (200.0f / width);
+                return getBitmapResized(image, decreaseSizeBy);
+            } else {
+                float decreaseSizeBy = (200.0f / height);
+                return getBitmapResized(image, decreaseSizeBy);
+            }
+        }
+        return image;
+    }
+
+    public static int getRGB(Bitmap bmpOriginal, int col, int row) {
+        int pixel = bmpOriginal.getPixel(col, row);
+        int R = Color.red(pixel);
+        int G = Color.green(pixel);
+        int B = Color.blue(pixel);
+        return Color.rgb(R, G, B);
+    }
+
+    public static Bitmap getBitmapResized(Bitmap image, float decreaseSizeBy) {
+        Bitmap resized = Bitmap.createScaledBitmap(image, (int) (image.getWidth() * decreaseSizeBy),
+                (int) (image.getHeight() * decreaseSizeBy), true);
+        return resized;
+    }
+}

package/android/src/main/java/com/pinmi/react/printer/adapter/BLEPrinterDevice.java

@@ -0,0 +1,33 @@
+package com.pinmi.react.printer.adapter;
+
+import android.bluetooth.BluetoothDevice;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableMap;
+
+/**
+ * Created by xiesubin on 2017/9/21.
+ */
+
+public class BLEPrinterDevice implements PrinterDevice {
+    private BluetoothDevice mBluetoothDevice;
+    private BLEPrinterDeviceId mPrinterDeviceId;
+
+    public BLEPrinterDevice(BluetoothDevice bluetoothDevice) {
+        this.mBluetoothDevice = bluetoothDevice;
+        this.mPrinterDeviceId = BLEPrinterDeviceId.valueOf(bluetoothDevice.getAddress());
+    }
+
+    @Override
+    public PrinterDeviceId getPrinterDeviceId() {
+        return this.mPrinterDeviceId;
+    }
+
+    @Override
+    public WritableMap toRNWritableMap() {
+        WritableMap deviceMap = Arguments.createMap();
+        deviceMap.putString("inner_mac_address", this.mPrinterDeviceId.getInnerMacAddress());
+        deviceMap.putString("device_name", this.mBluetoothDevice.getName());
+        return deviceMap;
+    }
+}

package/android/src/main/java/com/pinmi/react/printer/adapter/BLEPrinterDeviceId.java

@@ -0,0 +1,38 @@
+package com.pinmi.react.printer.adapter;
+
+/**
+ * Created by xiesubin on 2017/9/21.
+ */
+
+public class BLEPrinterDeviceId extends PrinterDeviceId {
+    private String innerMacAddress;
+
+    public static BLEPrinterDeviceId valueOf(String innerMacAddress) {
+        return new BLEPrinterDeviceId(innerMacAddress);
+    }
+
+    private BLEPrinterDeviceId(String innerMacAddress) {
+        this.innerMacAddress = innerMacAddress;
+    }
+
+    public String getInnerMacAddress() {
+        return innerMacAddress;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        if (!super.equals(o)) return false;
+
+        BLEPrinterDeviceId that = (BLEPrinterDeviceId) o;
+
+        return innerMacAddress.equals(that.innerMacAddress);
+
+    }
+
+    @Override
+    public int hashCode() {
+        return innerMacAddress.hashCode();
+    }
+}