1FaceAuth faceAuth = new FaceAuth();
2faceAuth.initLicenseOnLine(this, key, new AuthCallback() {
3            @Override
4            public void onResponse(final int code, final String response, String licenseKey) {
5                if (code == 0) {
6                    // 如果激活成功
7                    // 初始化模型
8                    FaceSDKManager.getInstance().initModel(mContext);
9                    // 初始化数据库
10                    DBManager.getInstance().init(getApplicationContext());
11                    finish();
12                } else {
13                    ToastUtils.toast(mContext, code + "  " + response);
14                }
15            }
16        });

1public void initModel(final Context context) {
2	// 加载人脸检测模型
3    faceDetector.initModel(context, "enc_detect_vgg_anakin.lite.bin",
4            "small_detect.model",
5            "enc_net_deploy_stageI.anakin.bin", new FaceCallback() {
6                @Override
7                public void onResponse(int code, String response) {
8                    ToastUtils.toast(context, code + "  " + response);
9                }
10            });
11	// 设定人脸检测配置参数，该方法采取默认参数
12    faceDetector.loadConfig(getFaceEnvironmentConfig());
13	// 加载特征提取模型
14    faceFeature.initModel(context, "enc_sphere_resnet34_128_580_pytorch_anakin.bin",
15            "enc_fsp_fc128_160_pytorch_anakin.bin",
16            "", new FaceCallback() {
17                @Override
18                public void onResponse(int code, String response) {
19                    ToastUtils.toast(context, code + "  " + response);
20                    ;
21                }
22            });
23	// 加载活体检测模型
24    faceLiveness.initModel(context, "enc_model_rgb_145_anakin.bin",
25            "enc_nir_anakin.lite.bin",
26            "enc_depth_anakin.lite.bin", new FaceCallback() {
27                @Override
28                public void onResponse(int code, String response) {
29                    ToastUtils.toast(context, code + "  " + response);
30                }
31            });
32}

1FaceEnvironment	faceEnvironment = new FaceEnvironment();
2faceEnvironment.setMinFaceSize(50);
3faceEnvironment.setMaxFaceSize(-1);
4faceEnvironment.setDetectInterval(200);      
5faceEnvironment.setTrackInterval(500);
6faceEnvironment.setNoFaceSize(0.5f);
7faceEnvironment.setPitch(30);
8faceEnvironment.setYaw(30);
9faceEnvironment.setRoll(30);
10faceEnvironment.setCheckBlur(true);
11faceEnvironment.setOcclusion(true);
12faceEnvironment.setIllumination(true);
13faceEnvironment.setDetectMethodType(FaceDetect.DetectType.DETECT_VIS);

1faceAuth.initLicenseOffLine(this, new AuthCallback() {
2            @Override
3            public void onResponse(final int code, final String response, String licenseKey) {
4                if (code == 0) {
5                    GlobalSet.FACE_AUTH_STATUS = 0;
6                    // 初始化人脸
7                    FaceSDKManager.getInstance().initModel(mContext);
8                    // 初始化数据库
9                    DBManager.getInstance().init(getApplicationContext());
10                    finish();
11                } else {
12                    ToastUtils.toast(mContext, code + "  " + response);
13                }
14            }
15        });

1FaceInfo[] faceInfos = null;
2    if (mRgbArray != null) {
3		// 进行人脸检测
4        faceInfos = FaceSDKManager.getInstance().getFaceDetector().trackMaxFace(mRgbArray, width, height);
5    }
6	// 保存相关图片信息
7    LivenessModel livenessModel = new LivenessModel();
8    livenessModel.setRgbDetectDuration(System.currentTimeMillis() - startTime);
9    livenessModel.getImageFrame().setArgb(mRgbArray);
10    livenessModel.getImageFrame().setWidth(width);
11    livenessModel.getImageFrame().setHeight(height);
12    livenessModel.setLiveType(type);
13
14    if (faceInfos != null && faceInfos.length > 0) {
15        livenessModel.setTrackFaceInfo(faceInfos);
16        FaceInfo faceInfo = faceInfos[0];
17        livenessModel.setFaceInfo(faceInfo);
18        livenessModel.setLandmarks(faceInfo.landmarks);
19
20        // 返回检测到人脸的信息，用于画人脸框
21        if (faceDetectCallBack != null) {
22            faceDetectCallBack.onFaceDetectCallback(true, (int) faceInfo.mWidth,
23                    (int) faceInfo.mWidth, (int) faceInfo.mCenter_x, (int) faceInfo.mCenter_y,
24                    width, height);
25        }
26
27        if (livenessCallBack != null) {
28            livenessCallBack.onTip(1, "活体判断中");
29        }
30
31        Log.e("lth_id",""+curFaceID+"   "+livenessModel.getFaceInfo().face_id);
32
33		// 活体检测，获取活体分值
34        float rgbScore = 0;
35        if ((type & MASK_RGB) == MASK_RGB) {
36            startTime = System.currentTimeMillis();
37            rgbScore = rgbLiveness(mRgbArray, width, height, faceInfos[0].landmarks);
38            livenessModel.setRgbLivenessScore(rgbScore);
39            livenessModel.setRgbLivenessDuration(System.currentTimeMillis() - startTime);
40        }
41        ......
42    }

1public void registFace(LivenessModel livenessModel) {
2	// 人脸特征提取
3    byte[] bytes = new byte[512];
4    float length = FaceSDKManager.getInstance().getFaceFeature().extractFeature(
5            livenessModel.getImageFrame().getArgb(),
6            livenessModel.getImageFrame().getHeight(),
7            livenessModel.getImageFrame().getWidth(),
8            bytes,
9            livenessModel.getLandmarks());
10	// 如果特征值提取正常
11    if (length == 128) {
12        Feature feature = new Feature();
13        feature.setCtime(System.currentTimeMillis());
14        feature.setFeature(bytes);
15        feature.setUserName(registNickName);
16        final String uid = UUID.randomUUID().toString();
17        feature.setUserId(uid);
18        feature.setGroupId("0");
19        
20        int imgWidth = livenessModel.getImageFrame().getWidth();
21        int imgHeight = livenessModel.getImageFrame().getHeight();
22        Bitmap registBmp = registBmp = Bitmap.createBitmap(imgWidth,
23                imgHeight, Bitmap.Config.ARGB_8888);
24        registBmp.setPixels(livenessModel.getImageFrame().getArgb(), 0, imgWidth, 0, 0, imgWidth, imgHeight);
25        
26        // 保存图片到新目录中
27        File facePicDir = FileUtils.getFacePicDirectory();
28        // 保存抠图图片到新目录中
29        File faceCropDir = FileUtils.getFaceCropPicDirectory();
30        String picFile = "regist_" + uid + "_rgb.png";
31
32        if (facePicDir != null) {
33            File savePicPath = new File(facePicDir, picFile);
34            if (FileUtils.saveFile(savePicPath, registBmp)) {
35                Log.i(TAG, "图片保存成功");
36                feature.setImageName(picFile);
37            }
38        }
39
40        Bitmap cropBitmap = null;
41        String cropImgName = null;
42        // 人脸抠图
43        FaceInfo faceInfo = livenessModel.getFaceInfo();
44        if (faceInfo != null) {
45            cropBitmap = ImageUtils.noBlackBoundImgCrop(faceInfo.landmarks,
46                    livenessModel.getImageFrame().getHeight(), livenessModel.getImageFrame().getWidth(),
47                    livenessModel.getImageFrame().getArgb());
48
49            if (cropBitmap == null) {
50                cropBitmap = registBmp;
51            }
52
53            cropImgName = "crop_" + picFile;
54        }
55        if (faceCropDir != null && cropBitmap != null) {
56            File saveCropPath = new File(faceCropDir, cropImgName);
57            if (FileUtils.saveFile(saveCropPath, cropBitmap)) {
58                Log.i(TAG, "抠图图片保存成功");
59                feature.setCropImageName(cropImgName);
60            }
61        }
62
63		// 将人脸信息保存数据库
64        if (FaceApi.getInstance().featureAdd(feature)) {
65			// 注册成功，返回结果
66            returnRegistResult(0, livenessModel, cropBitmap);
67        }
68        return;
69    }
70}

1// 如果是NIR摄像头，则用BinocularView加载
2if (GlobalSet.getLiveStatusValue() == GlobalSet.LIVE_STATUS.RGN_NIR) {
3        mBinocularView = new BinocularView(mContext);
4        mBinocularView.setImageView(mImageTrack);
5        mBinocularView.setLivenessCallBack(this);
6        mCameraView.addView(mBinocularView, layoutParams);
7} else {  // 如果是RGB摄像头，则用MonocularView加载
8        mMonocularView = new MonocularView(mContext);
9        mMonocularView.setImageView(mImageTrack);
10        mMonocularView.setLivenessCallBack(this);
11        mCameraView.addView(mMonocularView, layoutParams);
12}

1// 开始调用人脸相关接口
2private synchronized void checkData() {
3    if (rgbData != null) {
4        FaceSDKManager.getInstance().getFaceLiveness().setNirRgbInt(null);
5        FaceSDKManager.getInstance().getFaceLiveness().setRgbInt(rgbData);
6        FaceSDKManager.getInstance().getFaceLiveness().setIrData(null);
7        FaceSDKManager.getInstance().getFaceLiveness().livenessCheck(mTrackImageWidth, mTrackImageHeight,
8                GlobalSet.getLiveStatusValue() == GlobalSet.LIVE_STATUS.RGB ? 0X0001 : 0X0000);
9        rgbData = null;
10    }
11}
12
13// 实现人脸检测、活体检测
14private boolean onLivenessCheck(int width, int height, int type) {
15    boolean isLiveness = false;
16
17    long startTime = System.currentTimeMillis();
18    FaceInfo[] faceInfos = null;
19    if (mRgbArray != null) {
20		// 人脸检测，获取人脸信息
21        faceInfos = FaceSDKManager.getInstance().getFaceDetector().trackMaxFace(mRgbArray, width, height);
22    }
23    LivenessModel livenessModel = new LivenessModel();
24    livenessModel.setRgbDetectDuration(System.currentTimeMillis() - startTime);
25    livenessModel.getImageFrame().setArgb(mRgbArray);
26    livenessModel.getImageFrame().setWidth(width);
27    livenessModel.getImageFrame().setHeight(height);
28    livenessModel.setLiveType(type);
29
30    if (faceInfos != null && faceInfos.length > 0
31            && faceInfos[0].mConf >= GlobalSet.getDetectConfValue()) {
32        livenessModel.setTrackFaceInfo(faceInfos);
33        FaceInfo faceInfo = faceInfos[0];
34        livenessModel.setFaceInfo(faceInfo);
35        livenessModel.setLandmarks(faceInfo.landmarks);
36
37        // 返回检测到人脸的事件
38        if (faceDetectCallBack != null) {
39            faceDetectCallBack.onFaceDetectCallback(true, (int) faceInfo.mWidth,
40                    (int) faceInfo.mWidth, (int) faceInfo.mCenter_x, (int) faceInfo.mCenter_y,
41                    width, height);
42        }
43
44        if (livenessCallBack != null) {
45            livenessCallBack.onTip(1, "活体判断中");
46        }
47
48        if (currentTaskType == TASK_TYPE_ONETON && livenessModel.getFaceInfo().face_id == curFaceID) {
49            return true;
50        }
51
52        float rgbScore = 0;
53        if ((type & MASK_RGB) == MASK_RGB) {
54            startTime = System.currentTimeMillis();
55			// 活体检测
56            rgbScore = rgbLiveness(mRgbArray, width, height, faceInfos[0].landmarks);
57            livenessModel.setRgbLivenessScore(rgbScore);
58            livenessModel.setRgbLivenessDuration(System.currentTimeMillis() - startTime);
59        }
60        
61        if (livenessCallBack != null) {
62            switch (currentTaskType) {
63                case TASK_TYPE_ONETON:
64                    filterFeature(livenessModel);
65                    break;
66                default:
67                    break;
68            }
69
70        }
71    } else {
72        // 返回检测到人脸的事件
73        if (faceDetectCallBack != null) {
74            faceDetectCallBack.onFaceDetectCallback(false, 0,
75                    0, 0, 0, 0, 0);
76        }
77        if (livenessCallBack != null) {
78            livenessCallBack.onCallback(1, null);
79            livenessCallBack.onTip(1, "未检测到人脸");
80        }
81    }
82    livenessModel.setTrackFaceInfo(faceInfos);
83    if (livenessCallBack != null) {
84        livenessCallBack.onCanvasRectCallback(livenessModel);
85    }
86    return isLiveness;
87}
88
89// 特征值提取
90public boolean onFeatureCheck(LivenessModel livenessModel) {
91    if ((GlobalSet.getLiveStatusValue() == GlobalSet.LIVE_STATUS.NO) ||
92            (GlobalSet.getLiveStatusValue() == GlobalSet.LIVE_STATUS.RGB
93                    && livenessModel.getRgbLivenessScore() > GlobalSet.getLiveRgbValue())) {
94        byte[] visFeature = new byte[512];
95        long sTime = System.currentTimeMillis();
96		// 特征值提取
97        float length = FaceSDKManager.getInstance().getFaceFeature().extractFeature(
98                livenessModel.getImageFrame().getArgb(),
99                livenessModel.getImageFrame().getHeight(),
100                livenessModel.getImageFrame().getWidth(),
101                visFeature,
102                livenessModel.getLandmarks());
103        livenessModel.setFeatureDuration(System.currentTimeMillis() - sTime);
104        if (length == 128) {
105            livenessModel.setFeatureByte(visFeature);
106            return true;
107        }
108    }
109    return false;
110}

1// 将拿到的特征进行比对，并将结果返回
2public void filterFeature(LivenessModel livenessModel) {
3    if (onFeatureCheck(livenessModel)) {
4        long sTime = System.currentTimeMillis();
5		// 方法内部实现比对，并将结果存入数据库
6        Feature feature = FaceSDKManager.getInstance().getFeature(
7                FaceFeature.FeatureType.FEATURE_VIS, livenessModel.getFeatureByte(), livenessModel);
8        livenessModel.setCheckDuration(System.currentTimeMillis() - sTime);
9        Log.e("lth_sc", "" + livenessModel.getCheckDuration());
10        if (feature != null) {
11            curFaceID = livenessModel.getFaceInfo().face_id;
12            livenessModel.setFeature(feature);
13            livenessCallBack.onCallback(0, livenessModel);
14            return;
15        }
16    }
17    livenessCallBack.onCallback(1, livenessModel);
18}

1public void onResume() {
2    if (mCameraNum == 0) {
3        Toast.makeText(context, "未检测到摄像头", Toast.LENGTH_LONG).show();
4        return;
5	} else {
6        try {
7            Camera.CameraInfo info = new Camera.CameraInfo();
8            int numCameras = Camera.getNumberOfCameras();
9            for (int i = 0; i < numCameras; i++) {
10				// 获取摄像头信息，判断是前置摄像头还是后置摄像头
11                Camera.getCameraInfo(i, info);
12                if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
13                    mCamera = Camera.open(i);
14                    break;
15                }
16            }
17            // 如果没有前置摄像头，则打开默认的后置摄像头
18            if (mCamera == null) {
19                mCamera = Camera.open(0);
20            }
21            // 没有摄像头时，抛出异常
22            if (mCamera == null) {
23                throw new RuntimeException("Unable to open camera");
24            }
25			
26			// 设置摄像头预览角度
27            mCamera.setDisplayOrientation(previewAngle);
28            mPreview.setCamera(mCamera, PREFER_WIDTH, PERFER_HEIGH);
29            mCamera.setPreviewCallback(new Camera.PreviewCallback() {
30                @Override
31                public void onPreviewFrame(byte[] data, Camera camera) {
32                    dealRgb(data);
33                }
34            });
35        } catch (RuntimeException e) {
36            // Log.e(TAG, e.getMessage());
37        }
38    }
39
40    if (mTextureViewOne != null) {
41        mTextureViewOne.setOpaque(false);
42    }
43}

1// 搜索按钮
2if (v == mImageSearch) {
3    String searchContent = mEditContent.getText().toString().trim();
4    // 根据关键字查找人脸库
5    UserInfoManager.getInstance().getFeatureInfo(searchContent, mUserInfoListener);
6}

1// 检测人脸，提取人脸特征值
2ret = FaceApi.getInstance().getFeature(argbImg, bytes,
3        FaceFeature.FeatureType.FEATURE_VIS, environment, faceInfos);
4FaceInfo faceInfo = faceInfos[0];
5Log.e(TAG, "live_photo = " + ret);

1// 获取导入图片目录 /sdcard/Import Faces/FacePictures
2File batchPicDir = FileUtils.getBatchFacePicDirectory();
3String[] picFiles = batchPicDir.list();
4if (picFiles == null || picFiles.length == 0) {
5    if (mImportListener != null) {
6        mImportListener.showToastMessage("导入图片的文件夹没有图片");
7    }
8    return;
9}

1// 根据姓名查询数据库与文件中对应的姓名是否相等，如果相等，则直接过滤
2List<Feature> listFeatures = DBManager.getInstance().queryFeatureByName(userName);
3if (listFeatures != null && listFeatures.size() > 0) {
4    String msg = "与之前图片对应的姓名相同";
5    // 保存失败信息
6    logBuilder.append(userName + "\t" + picFile + "\t"
7            + "失败" + "\t" + msg + "\n");

1Log.e(TAG, picFile + "未检测到人脸，可能原因：人脸太小");
2String msg = "未检测到人脸，可能原因：人脸太小"
3        + "（必须大于最小检测人脸minFaceSize），"
4        + "或者人脸角度太大，人脸不是朝上";
5logBuilder.append(userName + "\t" + picFile + "\t"
6        + "失败" + "\t" + msg + "\n");

1// 从数据库中删除
2UserInfoManager.getInstance().batchRemoveFeatureInfo(mListFeatureInfo, mUserInfoListener,
3        mSelectCount);

1// 复制数据库到内存
2public void copyDBFileToData() {
3    String sqlPath = "/sdcard/bdface/import/bdface.db";
4    String newPath = "/data/data/com.baidu.idl.face.demo/databases/bdface.db";
5    if (FileUtils.copyFile(sqlPath, newPath)){
6        if (mDBFileListener != null) {
7            mDBFileListener.importDBSuccess();
8        }
9    } else {
10        if (mDBFileListener != null) {
11            mDBFileListener.showErrMsg();
12        }
13    }
14}

1// 复制数据库到SD卡
2public void copyDBFileToSDCard() {
3    String sqlPath = "/data/data/com.baidu.idl.face.demo/databases/bdface.db";
4    String newPath = "/sdcard/bdface/output/bdface.db";
5    if (FileUtils.copyFile(sqlPath, newPath)){
6        if (mDBFileListener != null) {
7            mDBFileListener.outputDBSuccess();
8        }
9    } else {
10        if (mDBFileListener != null) {
11            mDBFileListener.showErrMsg();
12        }
13    }
14}

1// 质量参数阈值类型
2public static final String TYPE_BLURR_THRESHOLD = "TYPE_BLURR_THRESHOLD";
3public static final String TYPE_OCCLUSION_THRESHOLD = "TYPE_OCCLUSION_THRESHOLD";
4public static final String TYPE_ILLUMINATION_THRESHOLD = "TYPE_ILLUMINATION_THRESHOLD";

1if (GlobalSet.getStructuredLightValue() == GlobalSet.STRUCTURED_LIGHT.OBI_ASTRA_PRO) {
2    intent = new Intent(this, OrbbecProPassActivity.class);
3} else if (GlobalSet.getStructuredLightValue() == GlobalSet.STRUCTURED_LIGHT.OBI_ASTRA_MINI) {
4    intent = new Intent(this, OrbbecMiniPassActivity.class);
5} else if (GlobalSet.getStructuredLightValue() == GlobalSet.STRUCTURED_LIGHT.HUAJIE_AMY_MINI) {
6    intent = new Intent(this, IminectPassActivity.class);
7}