NF5501扫描与打印二次开发记要

package com.jarwen.scanner.scanner;

import android.app.Activity;
import android.content.Context;
import android.graphics.Bitmap;
import android.media.MediaPlayer;
import android.os.CountDownTimer;
import android.zyapi.CommonApi;

import com.jarwen.scanner.MainActivity;
import com.jarwen.scanner.R;
import com.jarwen.scanner.data.model.PrintInfo;
import com.jarwen.scanner.util.Logger;

import com.jarwen.scanner.util.ToastManager;

public class NF5501 extends Scanner implements MainActivity.OnScanKeyListener {

    private static final String TAG = "NF5501";

    private static final int PIN = 84; // no why.
    private final int comFd;

    private boolean canRead;

    private OnScanResultCallback callback;
    private CommonApi commonApi;
    private MediaPlayer beeper;

    NF5501(Context context, ToastManager tm){
        super(context, tm);
        Logger.i(TAG, "new NF5501()");

        commonApi = new CommonApi();
        commonApi.setGpioDir(PIN, 0);
        commonApi.getGpioIn(PIN);
        new CountDownTimer(1000, 1000){

            @Override
            public void onTick(long millisUntilFinished) {
                // do nothing.
            }

            @Override
            public void onFinish() {
                Logger.i(TAG, "1s count down onFinish()");
                commonApi.setGpioDir(PIN, 1);
                commonApi.setGpioOut(PIN, 1);
            }
        }.start();
        comFd = commonApi.openCom("/dev/ttyMT1", 115200, 8, ‘N‘, 1);
        Logger.i(TAG, "scanner serial port fd:" + comFd);

        new CountDownTimer(2000, 1000){

            @Override
            public void onTick(long millisUntilFinished) {
                // do nothing.
            }

            @Override
            public void onFinish() {
                Logger.i(TAG, "2s scanner serial port onFinish()");
                if (comFd > 0) {
                    canRead = true;
                    write(new byte[] {0x1B, 0x23, 0x23, 0x35, 0x36, 0x55, 0x50});
                    readCom.start();
                    // 默认开启黑标
                    write(new byte[] {0x1F, 0x1B, 0x1F, (byte) 0x80, 0x04, 0x05, 0x06, 0x66});
                }else{
                    canRead = false;
                }

                notifyScannerReady();
            } // onFinish() -- end
        }.start();
    }// NF5501() -- end

    @Override
    public void prepare(Activity activity) {
        beeper = MediaPlayer.create(activity.getApplicationContext(), R.raw.beep);
        ((MainActivity)activity).setOnScanKeyListener(this);
    }

    @Override
    public void resume(OnScanResultCallback callback) {
        Logger.v(TAG, "resume()");
        this.callback = callback;
    }

    @Override
    public void pause() {
        Logger.v(TAG, "pause()");
        callback = null;
    }

    @Override
    public void destroy(Activity activity) {
        Logger.v(TAG, "destroy(), comFd:" + comFd);
        canRead = false;
        if (comFd > 0) {
            commonApi.setGpioMode(84, 0);
            commonApi.setGpioDir(84, 0);
            commonApi.setGpioOut(84, 0);
            commonApi.closeCom(comFd);
        }
    }

    @Override
    public void scan() {
        Logger.v(TAG, "scan()");

        write(new byte[] {0x1B, 0x23, 0x23, 0x35, 0x35, 0x44, 0x4E});
        commonApi.setGpioDir(74, 1);
        commonApi.setGpioOut(74, 0);
        commonApi.setGpioDir(75, 1);
        commonApi.setGpioOut(75, 0);
        new CountDownTimer(50, 50){

            @Override
            public void onTick(long millisUntilFinished) {
                // do nothing.
            }

            @Override
            public void onFinish() {
                commonApi.setGpioDir(74, 1);
                commonApi.setGpioOut(74, 1);
                commonApi.setGpioDir(75, 1);
                commonApi.setGpioOut(75, 1);
            }
        }.start();
    }

    private void write(byte[] data){
        if (comFd > 0) {
            commonApi.writeCom(comFd, data, data.length);
        }
    }

    @Override
    public void onScanKeyClicked() {
        Logger.v(TAG, "onScanKeyClicked(),canRead:" + canRead + ",callback null?" + (callback == null));
        if(canRead && callback != null) {
            scan();
        }
    }

    @Override
    public void print(PrintInfo pi) {
        Logger.v(TAG, "print(),order number:" + pi.getOrderNo());

        Bitmap bitmap = makePrintImage(pi);
        if(bitmap != null) {
            write(new byte[] {0x1b, 0x61, 0x00});
            byte[] bm = draw2PxPoint(bitmap);
            write(bm);
        }else{
            Logger.e(TAG, "Cannot print cause ‘bitmap‘ is null.");
        }

        Logger.i(TAG, "print end.");
    } // print() -- end.

    /*************************************************************************
     * 假设一个240*240的图片，分辨率设为24, 共分10行打印 每一行,是一个 240*24 的点阵, 每一列有24个点,存储在3个byte里面。
     * 每个byte存储8个像素点信息。因为只有黑白两色，所以对应为1的位是黑色，对应为0的位是白色。
     * ------
     * 把一张Bitmap图片转化为打印机可以打印的字节流
     */
    private byte[] draw2PxPoint(Bitmap bmp) {
        // 用来存储转换后的 bitmap 数据。为什么要再加1000，这是为了应对当图片高度无法
        // 整除24时的情况。比如bitmap 分辨率为 240 * 250，占用 7500 byte，
        // 但是实际上要存储11行数据，每一行需要 24 * 240 / 8 =720byte 的空间。再加上一些指令存储的开销，
        // 所以多申请 1000byte 的空间是稳妥的，不然运行时会抛出数组访问越界的异常。
        int size = bmp.getWidth() * bmp.getHeight() / 8 + 1200;
        Logger.i(TAG, "size1:" + size + ",bitmap size:" + bmp.getByteCount());
        byte[] data = new byte[size];
        int k = 0;
        // 设置行距为0的指令
        data[k++] = 0x1B;
        data[k++] = 0x33;
        data[k++] = 0x00;
        // 逐行打印
        for (int j = 0; j < bmp.getHeight() / 24f; j++) {
            // 打印图片的指令
            data[k++] = 0x1B;
            data[k++] = 0x2A;
            data[k++] = 33;
            data[k++] = (byte) (bmp.getWidth() % 256); // nL
            data[k++] = (byte) (bmp.getWidth() / 256); // nH
            // 对于每一行，逐列打印
            for (int i = 0; i < bmp.getWidth(); i++) {
                // 每一列24个像素点，分为3个字节存储
                for (int m = 0; m < 3; m++) {
                    // 每个字节表示8个像素点，0表示白色，1表示黑色
                    for (int n = 0; n < 8; n++) {
                        byte b = px2Byte(i, j * 24 + m * 8 + n, bmp);
                        if (k < size) {
                            data[k] += data[k] + b;
                        }
                        // data[k] = (byte) (data[k]+ data[k] + b);
                    }
                    k++;
                }
            }
            if (k < size) {
                data[k++] = 10;// 换行
            }
        }
        return data;
    }

    /**
     * 灰度图片黑白化，黑色是1，白色是0
     *
     * @param x
     *            横坐标
     * @param y
     *            纵坐标
     * @param bit
     *            位图
     */
    private byte px2Byte(int x, int y, Bitmap bit) {
        if (x < bit.getWidth() && y < bit.getHeight()) {
            byte b;
            int pixel = bit.getPixel(x, y);
            int red = (pixel & 0x00ff0000) >> 16; // 取高两位
            int green = (pixel & 0x0000ff00) >> 8; // 取中两位
            int blue = pixel & 0x000000ff; // 取低两位
            int gray = RGB2Gray(red, green, blue);
            if (gray < 128) {
                b = 1;
            } else {
                b = 0;
            }
            return b;
        }
        return 0;
    }

    /**
     * 图片灰度的转化
     */
    private int RGB2Gray(int r, int g, int b) {
        return (int) (0.29900 * r + 0.58700 * g + 0.11400 * b); // 灰度转化公式
    }

    private Thread readCom = new Thread(){

        private static final int MAX_RECV_BUF_SIZE = 1023;

        private int ret;

        private String code;

        @Override
        public void run() {
            byte[] buf = new byte[MAX_RECV_BUF_SIZE + 1];
            while (canRead) {
                ret = commonApi.readComEx(comFd, buf, MAX_RECV_BUF_SIZE, 0, 0);

                if (ret <= 0) {
                    Logger.w(TAG, "read failed!!!! ret:" + ret);
                    if(callback != null) {
                        callback.onScanResult(null);
                    }
                    try {
                        sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    continue;
                }

                byte[] recv = new byte[ret];
                System.arraycopy(buf, 0, recv, 0, ret);

                code = new String(recv, 0, ret).trim();
                Logger.i(TAG, "code scan:" + code);

                if (!code.contains("") && !code.contains("##55") && !code.contains("##56") && !code.equals("start") && code.length() > 0) {
                    beeper.start();
                }else{
                    code = null;
                }

                if(callback != null) {
                    callback.onScanResult(code);
                }

//                StringBuilder sb = new StringBuilder();
//                for (int i = 0; i < recv.length; i++) {
//                    if (recv[i] == 0x0D) {
//                        sb.append("\n");
//                    } else {
//                        sb.append((char) recv[i]);
//                    }
//                }
//                Logger.d(TAG, "sb:" + sb.toString());
                String str = byteToString(buf, ret);
                Logger.i(TAG, "hex data:" + str);
                if (str.contains("1C 00 0C 0F")) {
//                    Logger.i(TAG, "no paper");
//                    Intent mIntent = new Intent("NOPAPER");
//                    instance.sendBroadcast(mIntent);
//                    isCanprint = false;
                    return;
                } else {
//                    Logger.i(TAG, "can print");
                }
            }// while -- end
        }// run() -- end

        private String byteToString(byte[] b, int size) {
            byte high, low;
            byte maskHigh = (byte) 0xf0;
            byte maskLow = 0x0f;

            StringBuilder buf = new StringBuilder();

            for (int i = 0; i < size; i++) {
                high = (byte) ((b[i] & maskHigh) >> 4);
                low = (byte) (b[i] & maskLow);
                buf.append(findHex(high));
                buf.append(findHex(low));
                buf.append(" ");
            }

            return buf.toString();
        }

        private char findHex(byte b) {
            int t = Byte.valueOf(b).intValue();
            t = t < 0 ? t + 16 : t;
            if ((0 <= t) && (t <= 9)) {
                return (char) (t + ‘0‘);
            }

            return (char) (t - 10 + ‘A‘);
        }
    };
}