中控智慧身份证读卡器工具类

自定义一个身份证回调接口

import com.zkteco.android.biometric.module.idcard.meta.IDCardInfo;

/**
 * developer : xuyanyun
 * tel : 139159*****
 * createTime : 2018/8/14 16:36
 * viewName :
 * remark :
 * hasBug : unKnown
 */
public interface ReadCardInterface {
    /**
     * 获取身份证信息
     * @param info
     */
    void  getIdentityInfo(IDCardInfo info);

    /**
     * 获取身份证失败
     */
    void getIdentityInfoFailed();

    /**
     * 相同的身份证
     */
    void getSameIdentityInfo();

    /**
     * 身份证拿开
     */
    void leaveCard();
}

写一个工具类

import android.os.AsyncTask;

import com.hdd.lancity.pad.App;
import com.zkteco.android.biometric.core.device.ParameterHelper;
import com.zkteco.android.biometric.core.device.TransportType;
import com.zkteco.android.biometric.module.idcard.IDCardReader;
import com.zkteco.android.biometric.module.idcard.IDCardReaderFactory;
import com.zkteco.android.biometric.module.idcard.exception.IDCardReaderException;
import com.zkteco.android.biometric.module.idcard.meta.IDCardInfo;

import java.util.HashMap;
import java.util.Map;
import java.util.Timer;
import java.util.TimerTask;

/**
 * developer : xuyanyun
 * tel : 139159*****
 * createTime : 2018/9/29 22:33
 * viewName :
 * remark :
 * hasBug : unKnown
 */
public enum IDeviceControlUtil {
    INS;
    private final int VID = 1024;    //IDR VID
    private final int PID = 50010;     //IDR PID
    /**
     * 身份证读卡
     */
    private IDCardReader idCardReader = null;
    /**
     * 身份证读卡器是否打开
     */
    private boolean bopen;
    /**
     * 是否循环读取
     * false 单次   true 循环
     */
    private boolean isCircle = false;

    /**
     * 是否暂停读取
     * false 不暂停   true 暂停
     */
    private boolean isPause = false;
    private boolean isRunningTask = false;
    private ReadCardInterface readCardInterface;

    public void setReadCardInterface(ReadCardInterface readCardInterface) {
        this.readCardInterface = readCardInterface;
    }

    /**
     * 获取身份证读卡器对象
     * 第一步
     *
     * @return
     */
    public void initDevcie() {
            Map<String, Object> idrparams = new HashMap();
            idrparams.put(ParameterHelper.PARAM_KEY_VID, VID);
            idrparams.put(ParameterHelper.PARAM_KEY_PID, PID);
            idCardReader = IDCardReaderFactory.createIDCardReader(App.getIns(), TransportType.USB, idrparams);
    }
    private IDCardReader getReader(){
        if (null == idCardReader){
            initDevcie();
        }
        return idCardReader;
    }
//获取IDCardReader对象,然后打开设备,打开成功开始读取

    /**
     * 打开身份证读卡器
     * 第二步
     */
    public void openDevice() {
        try {
            if (bopen) return;
            getReader().open(0);
            getReader().getSAMID(0);
            bopen = true;
        } catch (IDCardReaderException e) {
            bopen = false;
//            Log.e("", "连接设备失败, 错误码：" + e.getErrorCode() + "\n错误信息：" + e.getMessage() + "\n 内部错误码=" + e.getInternalErrorCode());
        }
    }

    /**
     * 查找设备
     */
    private void findDevice() {
        try {
            getReader().findCard(0);
        } catch (IDCardReaderException e) {
        }
    }

    /**
     * 选择设备
     */
    private void selectDevice() {
        try {
            getReader().selectCard(0);
        } catch (IDCardReaderException e) {
        }
    }

    /**
     * 关闭设备
     */
    public void closeDevice() {
        try {
            if (bopen) {
                getReader().close(0);
                bopen = false;
            }
        } catch (IDCardReaderException e) {
//            Log.e("", "关闭设备失败, 错误码：" + e.getErrorCode() + "\n错误信息：" + e.getMessage() + "\n 内部错误码=" + e.getInternalErrorCode());
        }
    }
    /**
     * 销毁
     */
    public void destoryReader() {
        destoryTimer();
        if(null!=mAsyncTask){
            mAsyncTask.cancel(true);
        }
        IDCardReaderFactory.destroy(getReader());
        idCardReader = null ;
    }

    //读取身份证的现成
    private GetIDInfoTask mAsyncTask;
    //当身份证已经读取到后,在后面的都是同一个
    private long hasRead = 0l ;
    private class GetIDInfoTask extends AsyncTask<Void, Integer, IDCardInfo> {
        @Override
        protected void onPreExecute() {//before thread
            super.onPreExecute();
        }

        @Override
        protected IDCardInfo doInBackground(Void... arg0) {
            if (!bopen)
                return null;
            IDCardInfo idCardInfo = null;
            try {
                idCardInfo = new IDCardInfo();
                findDevice();
                selectDevice();
                boolean ret = getReader().readCard(0, 1, idCardInfo);
                if (ret) {
                    return idCardInfo;
                }
                return null;
            } catch (IDCardReaderException e) {
            }
            return null;
        }
        //        最终处理
        @Override
        protected void onPostExecute(IDCardInfo result) {
            super.onPostExecute(result);
            if (null != result) {
                if (0 == hasRead ){
                    readCardInterface.getIdentityInfo(result);
                }else{
                    readCardInterface.getSameIdentityInfo();
                }
                hasRead ++ ;
            } else {
                //只会调用一次
                if (hasRead!=0){
                    readCardInterface.leaveCard();
                }else{
                    readCardInterface.getIdentityInfoFailed();
                }
                hasRead = 0 ;
            }
            //不管读取成功失败都要判断是不是循环读取
            if (isCircle) {
                loopRead();
            }
        }
    }

    /**
     * 读取身份证
     */
    public void startRead() {
        mAsyncTask = new GetIDInfoTask();
        mAsyncTask.execute();
    }

    private Timer timer;
    private TimerTask task;

    //循环读取
    private void loopRead() {
        if (null == timer) {
            timer = new Timer();
        }
        if (null == task) {
            task = new TimerTask() {
                @Override
                public void run() {
                    if (!isPause) {
                        startRead();
                        return;
                    }
                }
            };
        }
        //2秒钟读取一次
        if (!isRunningTask) {
            isRunningTask = true;
            timer.schedule(task, 0, 1500);
        }
    }

    //销毁定时器
    public void destoryTimer() {
        if (null != timer) {
            timer.cancel();
            timer = null;
        }
        if (null != task) {
            task.cancel();
            task = null;
        }
    }

    /**
     * @param bb false 单次   true 循环
     */
    public void readTimes(boolean bb) {
        isCircle = bb;
    }

    /**
     * false 不暂停   true 暂停
     *
     * @param bb 这个主要是在onStop 和onResume里使用
     *           onStop true  onResume false
     */
    public void pauseRead(boolean bb) {
        isPause = bb;
    }
}

使用方法

1、在application里面初始化

IDeviceControlUtil.INS.initDevcie();

2、在使用的Activity里面做动作，一定要继承接口

//回调接口
IDeviceControlUtil.INS.setReadCardInterface(this);
//打开设备
IDeviceControlUtil.INS.openDevice();
//循环读取or单次读取
IDeviceControlUtil.INS.readTimes(true);
//开始
IDeviceControlUtil.INS.startRead();

3、必须要销毁了

IDeviceControlUtil.INS.closeDevice();
IDeviceControlUtil.INS.destoryReader();

中控智慧身份证读卡器工具类

猜你喜欢