react-native-earl-thermal-printer 1.0.0

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

@@ -0,0 +1,433 @@
+package com.pinmi.react.printer.adapter;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.graphics.Color;
+import android.net.wifi.WifiManager;
+import android.os.Build;
+import android.util.Base64;
+import android.util.Log;
+
+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.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+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.InetSocketAddress;
+import java.net.Socket;
+import java.net.URL;
+import java.util.ArrayList;
+
+import androidx.annotation.RequiresApi;
+
+/**
+ * Network (TCP/IP) printer adapter implementation.
+ * Migrated to Promise-based API for React Native New Architecture (TurboModules).
+ *
+ * @author Ordovez, Earl Romeo
+ */
+public class NetPrinterAdapter implements PrinterAdapter {
+    private static NetPrinterAdapter mInstance;
+    private ReactApplicationContext mContext;
+    private String LOG_TAG = "RNNetPrinter";
+    private NetPrinterDevice mNetDevice;
+
+    private int[] PRINTER_ON_PORTS = { 9100 };
+    private static final String EVENT_SCANNER_RESOLVED = "scannerResolved";
+    private static final String EVENT_SCANNER_RUNNING = "scannerRunning";
+
+    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 Socket mSocket;
+
+    private boolean isRunning = false;
+
+    private NetPrinterAdapter() {
+    }
+
+    public static NetPrinterAdapter getInstance() {
+        if (mInstance == null) {
+            mInstance = new NetPrinterAdapter();
+        }
+        return mInstance;
+    }
+
+    @Override
+    public void init(ReactApplicationContext reactContext, Promise promise) {
+        this.mContext = reactContext;
+        promise.resolve("RNNetPrinter initialized");
+    }
+
+    @Override
+    public void getDeviceList(Promise promise) {
+        // Network printer discovery uses scan(), which emits events asynchronously.
+        // Resolve an empty array immediately; discovered printers arrive via events.
+        this.scan();
+        WritableArray array = Arguments.createArray();
+        promise.resolve(array);
+    }
+
+    private void scan() {
+        if (isRunning)
+            return;
+        new Thread(new Runnable() {
+            @RequiresApi(api = Build.VERSION_CODES.KITKAT)
+            @Override
+            public void run() {
+                try {
+                    isRunning = true;
+                    emitEvent(EVENT_SCANNER_RUNNING, isRunning);
+
+                    WifiManager wifiManager = (WifiManager) mContext.getApplicationContext()
+                            .getSystemService(Context.WIFI_SERVICE);
+                    String ipAddress = ipToString(wifiManager.getConnectionInfo().getIpAddress());
+                    WritableArray array = Arguments.createArray();
+
+                    String prefix = ipAddress.substring(0, ipAddress.lastIndexOf('.') + 1);
+                    int suffix = Integer
+                            .parseInt(ipAddress.substring(ipAddress.lastIndexOf('.') + 1, ipAddress.length()));
+
+                    for (int i = 0; i <= 255; i++) {
+                        if (i == suffix)
+                            continue;
+                        ArrayList<Integer> ports = getAvailablePorts(prefix + i);
+                        if (!ports.isEmpty()) {
+                            WritableMap payload = Arguments.createMap();
+                            payload.putString("host", prefix + i);
+                            payload.putInt("port", 9100);
+                            array.pushMap(payload);
+                        }
+                    }
+
+                    emitEvent(EVENT_SCANNER_RESOLVED, array);
+
+                } catch (NullPointerException ex) {
+                    Log.i(LOG_TAG, "No connection");
+                } finally {
+                    isRunning = false;
+                    emitEvent(EVENT_SCANNER_RUNNING, isRunning);
+                }
+            }
+        }).start();
+    }
+
+    private void emitEvent(String eventName, Object data) {
+        if (mContext != null) {
+            mContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class).emit(eventName, data);
+        }
+    }
+
+    @RequiresApi(api = Build.VERSION_CODES.KITKAT)
+    private ArrayList<Integer> getAvailablePorts(String address) {
+        ArrayList<Integer> ports = new ArrayList<>();
+        for (int port : PRINTER_ON_PORTS) {
+            if (crunchifyAddressReachable(address, port))
+                ports.add(port);
+        }
+        return ports;
+    }
+
+    @RequiresApi(api = Build.VERSION_CODES.KITKAT)
+    private static boolean crunchifyAddressReachable(String address, int port) {
+        try {
+            try (Socket crunchifySocket = new Socket()) {
+                crunchifySocket.connect(new InetSocketAddress(address, port), 100);
+            }
+            return true;
+        } catch (IOException exception) {
+            exception.printStackTrace();
+            return false;
+        }
+    }
+
+    private String ipToString(int ip) {
+        return (ip & 0xFF) + "." + ((ip >> 8) & 0xFF) + "." + ((ip >> 16) & 0xFF) + "." + ((ip >> 24) & 0xFF);
+    }
+
+    @Override
+    public void selectDevice(PrinterDeviceId printerDeviceId, Promise promise) {
+        NetPrinterDeviceId netPrinterDeviceId = (NetPrinterDeviceId) printerDeviceId;
+
+        if (this.mSocket != null && !this.mSocket.isClosed()
+                && mNetDevice.getPrinterDeviceId().equals(netPrinterDeviceId)) {
+            Log.i(LOG_TAG, "already selected device, do not need repeat to connect");
+            promise.resolve(this.mNetDevice.toRNWritableMap());
+            return;
+        }
+
+        try {
+            Socket socket = new Socket(netPrinterDeviceId.getHost(), netPrinterDeviceId.getPort());
+            if (socket.isConnected()) {
+                closeConnectionIfExists();
+                this.mSocket = socket;
+                this.mNetDevice = new NetPrinterDevice(netPrinterDeviceId.getHost(), netPrinterDeviceId.getPort());
+                promise.resolve(this.mNetDevice.toRNWritableMap());
+            } else {
+                promise.reject("ERR_CONNECT", "unable to build connection with host: "
+                        + netPrinterDeviceId.getHost() + ", port: " + netPrinterDeviceId.getPort());
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+            promise.reject("ERR_CONNECT", "failed to connect printer: " + e.getMessage());
+        }
+    }
+
+    @Override
+    public void closeConnectionIfExists() {
+        if (this.mSocket != null) {
+            if (!this.mSocket.isClosed()) {
+                try {
+                    this.mSocket.close();
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            this.mSocket = null;
+        }
+    }
+
+    @Override
+    public void printRawData(String rawBase64Data, Promise promise) {
+        if (this.mSocket == null) {
+            promise.reject("ERR_NO_CONN", "Connection is not built, may be you forgot to connectPrinter");
+            return;
+        }
+        final String rawData = rawBase64Data;
+        final Socket socket = this.mSocket;
+        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(final String imageUrl, Promise promise) {
+        final Bitmap bitmapImage = getBitmapFromURL(imageUrl);
+
+        if (bitmapImage == null) {
+            promise.reject("ERR_IMAGE", "image not found");
+            return;
+        }
+
+        if (this.mSocket == null) {
+            promise.reject("ERR_NO_CONN", "Connection is not built, may be you forgot to connectPrinter");
+            return;
+        }
+
+        final Socket socket = this.mSocket;
+
+        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.mSocket == null) {
+            promise.reject("ERR_NO_CONN", "Connection is not built, may be you forgot to connectPrinter");
+            return;
+        }
+
+        final Socket socket = this.mSocket;
+
+        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/NetPrinterDevice.java

@@ -0,0 +1,30 @@
+package com.pinmi.react.printer.adapter;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableMap;
+
+/**
+ * Created by xiesubin on 2017/9/21.
+ */
+
+public class NetPrinterDevice implements PrinterDevice {
+    private NetPrinterDeviceId mNetPrinterDeviceId;
+
+    public NetPrinterDevice(String host, Integer port) {
+        this.mNetPrinterDeviceId = NetPrinterDeviceId.valueOf(host, port);
+    }
+
+    @Override
+    public PrinterDeviceId getPrinterDeviceId() {
+        return this.mNetPrinterDeviceId;
+    }
+
+    @Override
+    public WritableMap toRNWritableMap() {
+        WritableMap deviceMap = Arguments.createMap();
+        deviceMap.putString("device_name", this.mNetPrinterDeviceId.getHost() + ":" + this.mNetPrinterDeviceId.getPort());
+        deviceMap.putString("host", this.mNetPrinterDeviceId.getHost());
+        deviceMap.putInt("port", this.mNetPrinterDeviceId.getPort());
+        return deviceMap;
+    }
+}

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

@@ -0,0 +1,48 @@
+package com.pinmi.react.printer.adapter;
+
+/**
+ * Created by xiesubin on 2017/9/21.
+ */
+
+public class NetPrinterDeviceId extends PrinterDeviceId {
+    private String host;
+    private Integer port;
+
+
+    public static NetPrinterDeviceId valueOf(String host, Integer port) {
+        return new NetPrinterDeviceId(host, port);
+    }
+
+    private NetPrinterDeviceId(String host, Integer port) {
+        this.host = host;
+        this.port = port;
+    }
+
+    public String getHost() {
+        return host;
+    }
+
+    public Integer getPort() {
+        return port;
+    }
+
+    @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;
+
+        NetPrinterDeviceId that = (NetPrinterDeviceId) o;
+
+        if (!host.equals(that.host)) return false;
+        return port.equals(that.port);
+
+    }
+
+    @Override
+    public int hashCode() {
+        int result = host.hashCode();
+        result = 31 * result + port.hashCode();
+        return result;
+    }
+}

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

@@ -0,0 +1,29 @@
+package com.pinmi.react.printer.adapter;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+
+import java.util.List;
+
+/**
+ * Adapter interface for thermal receipt printers.
+ * Migrated to Promise-based API for React Native New Architecture (TurboModules).
+ *
+ * @author Ordovez, Earl Romeo
+ */
+public interface PrinterAdapter {
+
+    void init(ReactApplicationContext reactContext, Promise promise);
+
+    void getDeviceList(Promise promise);
+
+    void selectDevice(PrinterDeviceId printerDeviceId, Promise promise);
+
+    void closeConnectionIfExists();
+
+    void printRawData(String rawBase64Data, Promise promise);
+
+    void printImageData(String imageUrl, Promise promise);
+
+    void printQrCode(String qrCode, Promise promise);
+}

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

@@ -0,0 +1,17 @@
+package com.pinmi.react.printer.adapter;
+
+import android.hardware.usb.UsbDevice;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableMap;
+
+/**
+ * Created by xiesubin on 2017/9/21.
+ */
+
+public interface PrinterDevice {
+
+    public PrinterDeviceId getPrinterDeviceId();
+    public WritableMap toRNWritableMap();
+
+}

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

@@ -0,0 +1,8 @@
+package com.pinmi.react.printer.adapter;
+
+/**
+ * Created by xiesubin on 2017/9/21.
+ */
+
+public class PrinterDeviceId {
+}