笔者公司有做收集指纹的业务，用的是设备中心提供的一些so库和jar包，因为有很多地方有用到，为了不导致复制粘贴，就封装了一下代码，也想借此机会，来简单谈谈业务与操作代码分离的思想。

1、先定义借口类FingerprintOperationCallback ，主要是操作中供给核心业务调用的方法

public interface FingerprintOperationCallback {
    

    /**
     * 申请权限失败的回调
     * 
     */
    void onApplypermissionsFail();
    
    /**
     * 成功打开指纹模块的回调
     *
     * status = 1 成功， -1为失败
     */
//  void onOpenStatus(int status);

    /**
     * 打开指纹模块失敗的回调
     *
     */
    void onFailOpenFP();

    /**
     * 采集指纹的回调
     * 
     */
    void onReadResult(Bitmap bitmap);
}

2、操作封装类FingerprintUtil，主要是封装了第三方的一些基本用法，比如：打开指纹设备、申请权限、开始采集等等

public class FingerprintUtil {
    

    private static final String TAG = FingerprintUtil.class.getSimpleName();
    private static final int FLAG_APPLY_PERMISSIONS_SUCCESS  = 100;
    private static final int FLAG_APPLY_PERMISSIONS_FAIL  = 101;
    private static final int FLAG_OPEN_FP_SUCCESS  = 102;
    private static final int FLAG_OPEN_FP_FAIL = 103;
    private static final int FLAG_READ_FP_RESULT_SUCCESS = 104;
    
    private static volatile FingerprintUtil instance;
    
    private Bitmap mFingerprintImage;
    
    private boolean isOpen = false;
    
    private ExecutorService mExecutorService;
    private Handler mHandler;
    

    private FingerprintOperationCallback mOperationCallback;

    private FP mFp;
    private Context mContext;

    private boolean isReadSuccess;

    private int openStatus;

    private Object mLockObject = new Object( );

    public static FingerprintUtil getInstance( Context context) {
        if ( instance == null ) {
            synchronized ( FingerprintUtil.class ) {
                if ( instance == null ) {
                    instance = new FingerprintUtil(context);
                }
            }
        }
        return instance;
    }
    
    public FingerprintUtil( ) {

    }

    public FingerprintUtil(Context context) {
        this.mContext = context;
    }
    
    private void init( ) {
        LogUtil.d(TAG,"init====================");
        if ( mFp == null ) {
            mFp = new FP(mContext);
        }
        if ( mExecutorService == null ) {
            mExecutorService = Executors.newSingleThreadExecutor( );
        }
        if ( mHandler == null ) {
            mHandler = new Handler( mCallback );
        }
        registerUSBpermisson();
    }


    /**
     * 申请权限的广播
     */
    private final BroadcastReceiver mUsbReceiverPermission = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            if (FP.ACTION_USB_PERMISSION.equals(action)) {
                synchronized (this) {
                    UsbDevice usbDevice = (UsbDevice) intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
                    //用户允许权限申请true
                    if (usbDevice != null && intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false)) {
                        //用户同意 ;
                        //申请权限成功的回调
                        Message msg;
                        msg = mHandler.obtainMessage( FLAG_APPLY_PERMISSIONS_SUCCESS );
                        mHandler.sendMessage( msg );
                        LogUtil.d(TAG,"用户同意打开指纹模块");
                    } else {
                        //用户拒绝
                        //申请权限失败的回调
                        Message msg;
                        msg = mHandler.obtainMessage( FLAG_APPLY_PERMISSIONS_FAIL );
                        mHandler.sendMessage( msg );
                        Log.e("jp", "permission denied for device！！！");
                        ToastUtils.showLongMessage(mContext, R.string.err_no_permission);
                    }
                }
            } else if (UsbManager.ACTION_USB_DEVICE_DETACHED.equals(action)) {

            }
        }
    };

    /*注册USB权限*/
    public void registerUSBpermisson() {
        IntentFilter filter = new IntentFilter();
        filter.addAction(FP.ACTION_USB_PERMISSION);
        filter.addAction(UsbManager.ACTION_USB_DEVICE_DETACHED);//拔出USB
        mContext.registerReceiver(mUsbReceiverPermission, filter);
    }

    public void unregisterReceiver() {
        IntentFilter filter = new IntentFilter();
        filter.addAction(FP.ACTION_USB_PERMISSION);
        mContext.unregisterReceiver(mUsbReceiverPermission);
        isReadSuccess = true;
        LogUtil.d(TAG,"unregisterReceiver================");
    }

    /**
     * 申请权限
     */
    public void applypermissions(){
        mExecutorService.execute(mApplypermissions);
    }

    /**
     * 申请权限
     */
    private Runnable mApplypermissions = new Runnable() {
        @Override
        public void run() {
            registerUSBpermisson();
        }
    };

    /**
     * 权限注销
     */
    private Runnable mUnregisterReceiver = new Runnable() {
        @Override
        public void run() {
            unregisterReceiver();
        }
    };
    

    /**
     * 初始化设备
     */
    public void initFP( ) {
        init( );
    }

    /**
     * 打开指纹模块
     */
    public void openFP( ) {
        mExecutorService.execute(mOpenFP);
    }

    /**
     * 打开指纹模块
     */
    private Runnable mOpenFP = new Runnable() {
        @Override
        public void run() {
            if (mFp.findDevice()) {
                if (!mFp.isPermissed()) {
                    PendingIntent mPermissionIntent = PendingIntent.getBroadcast(mContext, 0, new Intent("FP_Request_USB_PERMISSION"), 0);
                    mFp.requestPermission(mPermissionIntent);
                    return;
                }
                openStatus = mFp.open();
                LogUtil.d(TAG,"openFp====openStatus===="+ openStatus);
                if (openStatus == 0){
                    Message msg;
                    msg = mHandler.obtainMessage( FLAG_OPEN_FP_SUCCESS );
                    mHandler.sendMessage( msg );
                }else if (openStatus == -1){
                    Message msg;
                    msg = mHandler.obtainMessage( FLAG_OPEN_FP_FAIL );
                    mHandler.sendMessage( msg );
                }
            }
        }
    };


    public void readFPResult(){
        mExecutorService.execute(mReadFPResult);
    }

    /**
     * 指纹采集
     */
    private Runnable mReadFPResult = new Runnable() {
        @Override
        public void run() {
            isReadSuccess = false;
            while (!isReadSuccess) {
                LogUtil.d(TAG,"等待指纹输入======");
                mFingerprintImage = mFp.read();
                if (mFingerprintImage != null) {
                    isReadSuccess = true;
                    Message msg;
                    msg = mHandler.obtainMessage( FLAG_READ_FP_RESULT_SUCCESS );
                    mHandler.sendMessage( msg );
                }
            }
        }
    };



    private Callback mCallback = new Callback( ) {

        @Override
        public boolean handleMessage( Message msg ) {
            // TODO Auto-generated method stub
            switch ( msg.what ) {
                case FLAG_APPLY_PERMISSIONS_SUCCESS :
                    openFP();
                    break;
                case FLAG_APPLY_PERMISSIONS_FAIL :
                    if ( mOperationCallback != null ) {
                        mOperationCallback.onApplypermissionsFail();
                    }
                    break;
                case FLAG_OPEN_FP_SUCCESS :
                    readFPResult();
                    break;
                case FLAG_OPEN_FP_FAIL :
                    if ( mOperationCallback != null ) {
                        mOperationCallback.onFailOpenFP();
                    }
                    break;
                case FLAG_READ_FP_RESULT_SUCCESS :
                    if ( mOperationCallback != null ) {
                        mOperationCallback.onReadResult(mFingerprintImage);
                    }
                    break;
                default :
                    break;
            }
            return false;
        }
    };


    public void setFingerprintOperationCallback( FingerprintOperationCallback operationCallback ) {
        this.mOperationCallback = operationCallback;
    }

    public void release( ) {
        synchronized ( mLockObject ) {
            mOperationCallback = null;
            if ( mHandler != null ) {
                mHandler.removeCallbacksAndMessages( null );
            }
            if ( mFingerprintImage != null && !mFingerprintImage.isRecycled( ) ) {
                mFingerprintImage.recycle( );
                mFingerprintImage = null;
            }
            unregisterReceiver();
        }
    }
    
}

3、操作封装类在自己核心业务中使用

  FingerprintUtil.getInstance(getActivity()).setFingerprintOperationCallback(mOperationCallback);
  FingerprintUtil.getInstance(getActivity()).initFP();
  FingerprintUtil.getInstance(getActivity()).openFP();

  @Override
    public void onDestroy() {
        super.onDestroy();
        FingerprintUtil.getInstance(getActivity()).release();
    }

    FingerprintOperationCallback mOperationCallback = new FingerprintOperationCallback() {
        @Override
        public void onApplypermissionsFail() {
            LogUtil.d(TAG,"onApplypermissionsFail==========");
            mHandler.sendEmptyMessage(3);
        }

        @Override
        public void onFailOpenFP() {
            LogUtil.d(TAG,"onFailOpenFP==========");
            mHandler.sendEmptyMessage(1);
        }

        @Override
        public void onReadResult(Bitmap bitmap) {
            LogUtil.d(TAG,"onReadResult==========");
            Message message = Message.obtain();
            message.obj = bitmap;
            message.what = 2;
            mHandler.sendMessage(message);
        }
    };