package com.example.datalibrary.manager;

import static com.example.datalibrary.model.GlobalSet.FEATURE_SIZE;

import android.content.Context;
import android.graphics.Bitmap;
import android.os.Debug;
import android.text.TextUtils;
import android.util.Log;

import com.baidu.idl.main.facesdk.FaceAuth;
import com.baidu.idl.main.facesdk.FaceCrop;
import com.baidu.idl.main.facesdk.FaceDetect;
import com.baidu.idl.main.facesdk.FaceFeature;
import com.baidu.idl.main.facesdk.FaceInfo;
import com.baidu.idl.main.facesdk.FaceMouthMask;
import com.baidu.idl.main.facesdk.ImageIllum;
import com.baidu.idl.main.facesdk.model.BDFaceDetectListConf;
import com.baidu.idl.main.facesdk.model.BDFaceImageInstance;
import com.baidu.idl.main.facesdk.model.BDFaceOcclusion;
import com.baidu.idl.main.facesdk.model.BDFaceSDKCommon;
import com.baidu.idl.main.facesdk.model.BDFaceSDKConfig;
import com.baidu.idl.main.facesdk.model.Feature;
import com.example.datalibrary.api.FaceApi;
import com.example.datalibrary.callback.FaceDetectCallBack;
import com.example.datalibrary.callback.FaceQualityBack;
import com.example.datalibrary.db.DBManager;
import com.example.datalibrary.listener.DetectListener;
import com.example.datalibrary.listener.QualityListener;
import com.example.datalibrary.listener.SdkInitListener;
import com.example.datalibrary.model.BDFaceCheckConfig;
import com.example.datalibrary.model.BDFaceImageConfig;
import com.example.datalibrary.model.BDLiveConfig;
import com.example.datalibrary.model.BDQualityConfig;
import com.example.datalibrary.model.LivenessModel;
import com.example.datalibrary.model.User;
import com.example.datalibrary.utils.ToastUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.atomic.AtomicInteger;

public class FaceSDKManager {

    public static final int SDK_MODEL_LOAD_SUCCESS = 0;
    public static final int SDK_UNACTIVATION = 1;
    private static final String TAG = "FaceSDKManager";

    private List<Boolean> mRgbLiveList = new ArrayList<>();
    private List<Boolean> mNirLiveList = new ArrayList<>();
    private int mLastFaceId;

    private float threholdScore;

    public static volatile int initStatus = SDK_UNACTIVATION;
    public static volatile boolean initModelSuccess = false;
    private FaceAuth faceAuth;

    private ExecutorService es = Executors.newSingleThreadExecutor();
    private Future future;
    private ExecutorService es2 = Executors.newSingleThreadExecutor();
    private Future future2;
    private ExecutorService es3 = Executors.newSingleThreadExecutor();
    private Future future3;

    private float[] scores;
    private ImageIllum imageIllum;
    private long startInitModelTime;

    private static int failNumber = 0;
    private static int faceId = 0;
    private static int lastFaceId = 0;
    private static LivenessModel faceAdoptModel;
    private boolean isFail = false;
    private long trackTime;
    private FaceModel faceModel;

    private boolean checkMouthMask = false;
    private boolean isMultiIdentify = false;

    private FaceSDKManager() {
        faceAuth = new FaceAuth();
        faceAuth.setCoreConfigure(BDFaceSDKCommon.BDFaceCoreRunMode.BDFACE_LITE_POWER_NO_BIND, 2);
    }

    public void setActiveLog(boolean isLog) {
        if (faceAuth != null) {
            if (isLog) {
                faceAuth.setActiveLog(BDFaceSDKCommon.BDFaceLogInfo.BDFACE_LOG_TYPE_ALL, 1);
            } else {
                faceAuth.setActiveLog(BDFaceSDKCommon.BDFaceLogInfo.BDFACE_LOG_TYPE_ALL, 0);
            }
        }
    }

    public void setCheckMouthMask(boolean checkMouthMask) {
        this.checkMouthMask = checkMouthMask;
    }

    public void setMultiIdentify(boolean isMultiFaceIdentify) {
        this.isMultiIdentify = isMultiFaceIdentify;
    }

    private static class HolderClass {
        private static final FaceSDKManager INSTANCE = new FaceSDKManager();
    }

    public static FaceSDKManager getInstance() {
        return HolderClass.INSTANCE;
    }

    public ImageIllum getImageIllum() {
        return imageIllum;
    }

    public void initModel(
        final Context context, BDFaceSDKConfig config, boolean isLog, final SdkInitListener listener) {
        setActiveLog(isLog);
        initModel(context, config, listener);
    }

    /**
     * 初始化模型，目前包含检查，活体，识别模型；因为初始化是顺序执行，可以在最好初始化回掉中返回状态结果
     *
     * @param context
     */
    public void initModel(final Context context, BDFaceSDKConfig config, final SdkInitListener listener) {
        // 曝光
        if (imageIllum == null) {
            imageIllum = new ImageIllum();
        }
        // 其他模型初始化
        if (faceModel == null) {
            faceModel = new FaceModel(checkMouthMask);
        }
        faceModel.setListener(listener);

        faceModel.init(config, context);

        startInitModelTime = System.currentTimeMillis();
    }

    public void destroy(){
        if(rgbInstance!=null){
            rgbInstance = null;
        }
    }

    public FaceCrop getFaceCrop() {
        return faceModel.getFaceCrop();
    }

    public FaceDetect getFaceDetectPerson() {
        return faceModel.getFaceDetectPerson();
    }

    public FaceFeature getFacePersonFeature() {
        return faceModel.getFacePersonFeature();
    }

    public FaceMouthMask getFaceMouthMask() {
        return faceModel.getFaceMoutMask();
    }

    public void initDataBases(Context context) {
        if (FaceApi.getInstance().getmUserNum() != 0) {
            //ToastUtils.toast(context, "人脸库加载中");
        }
        emptyFrame();
        // 初始化数据库
        DBManager.getInstance().init(context);
        // 数据变化，更新内存
        initPush(context);
    }

    /**
     * 数据库发现变化时候，重新把数据库中的人脸信息添加到内存中，id+feature
     */
    public void initPush(final Context context) {

        if (future3 != null && !future3.isDone()) {
            future3.cancel(true);
        }

        future3 =
            es3.submit(
                new Runnable() {
                    @Override
                    public void run() {
                        faceModel.getFaceSearch().featureClear();
                        synchronized (faceModel.getFaceSearch()) {
                            List<User> users = FaceApi.getInstance().getAllUserList();
                            for (int i = 0; i < users.size(); i++) {
                                User user = users.get(i);
                                faceModel.getFaceSearch().pushPersonById(user.getId(), user.getFeature());
                            }
                            if (FaceApi.getInstance().getmUserNum() != 0) {
                                //ToastUtils.toast(context, "人脸库加载成功");
                            }
                        }
                    }
                });
    }

    private void setFail(LivenessModel livenessModel) {
        Log.e("faceId", livenessModel.getFaceInfo().faceID + "");
        if (failNumber >= 2) {
            faceId = livenessModel.getFaceInfo().faceID;
            faceAdoptModel = livenessModel;
            trackTime = System.currentTimeMillis();
            isFail = false;
            faceAdoptModel.setMultiFrame(true);
        } else {
            failNumber += 1;
            faceId = 0;
            faceAdoptModel = null;
            isFail = true;
            livenessModel.setMultiFrame(true);
        }
    }

    public void emptyFrame() {
        failNumber = 0;
        faceId = 0;
        isFail = false;
        trackTime = 0;
        faceAdoptModel = null;
    }

    private FaceInfo[] getTrackCheck(BDFaceImageInstance rgbInstance) {

        // 快速检测获取人脸信息，仅用于绘制人脸框，详细人脸数据后续获取
        FaceInfo[] faceInfos =
            faceModel
                .getFaceTrack()
                .track(
                    BDFaceSDKCommon.DetectType.DETECT_VIS,
                    BDFaceSDKCommon.AlignType.BDFACE_ALIGN_TYPE_RGB_FAST,
                    rgbInstance);
        return faceInfos;
    }


    private FaceInfo[] getDetectCheck(BDFaceImageInstance rgbInstance) {

        // 快速检测获取人脸信息，仅用于绘制人脸框，详细人脸数据后续获取
        FaceInfo[] faceInfos = faceModel.getFaceDetect().detect(BDFaceSDKCommon.DetectType.DETECT_VIS, rgbInstance);
        return faceInfos;
    }

    private BDFaceImageInstance getBdImage(BDFaceImageConfig bdFaceImageConfig, boolean darkEnhance) {
        BDFaceImageInstance rgbInstance =
            new BDFaceImageInstance(
                bdFaceImageConfig.data,
                bdFaceImageConfig.srcHeight,
                bdFaceImageConfig.srcWidth,
                bdFaceImageConfig.bdFaceImageType,
                bdFaceImageConfig.direction,
                bdFaceImageConfig.mirror);
        BDFaceImageInstance rgbInstanceOne;
        // 判断暗光恢复
        if (darkEnhance) {
            rgbInstanceOne = faceModel.getDark().faceDarkEnhance(rgbInstance);

        } else {
            rgbInstanceOne = rgbInstance;
        }
        return rgbInstanceOne;
    }

    private boolean frameSelect(FaceInfo faceInfo) {
        if (lastFaceId != faceInfo.faceID) {
            lastFaceId = faceInfo.faceID;
        }

        if (System.currentTimeMillis() - trackTime < 0 && faceId == faceInfo.faceID) {
            faceAdoptModel.setMultiFrame(true);

            return false;
        }
        if (faceAdoptModel != null) {
            faceAdoptModel.setMultiFrame(false);
        }
        faceId = 0;
        faceAdoptModel = null;
        if (!isFail /*&& failNumber != 0*/) {
            failNumber = 0;
        }
        return true;
    }

    public BDFaceImageInstance getCopeFace(Bitmap bitmap, float[] landmarks, int initialValue) {
        if (faceModel == null || faceModel.getFaceCrop() == null) {
            return null;
        }
        BDFaceImageInstance imageInstance = new BDFaceImageInstance(bitmap);
        if (!bitmap.isRecycled()) {
            bitmap.recycle();
        }
        AtomicInteger isOutoBoundary = new AtomicInteger();
        BDFaceImageInstance cropInstance =
            faceModel.getFaceCrop().cropFaceByLandmark(imageInstance, landmarks, 2.0f, false, isOutoBoundary);
        return cropInstance;
    }

    private static BDFaceImageInstance rgbInstance =null;
    /**
     * 检测-活体-特征-人脸检索流程
     *
     * @param bdFaceImageConfig      可见光YUV 数据流
     * @param bdNirFaceImageConfig   红外YUV 数据流
     * @param bdDepthFaceImageConfig 深度depth 数据流
     * @param bdFaceCheckConfig      识别参数
     * @param faceDetectCallBack
     */
    public void onDetectCheck(
            String groupId,
        final BDFaceImageConfig bdFaceImageConfig,
        final BDFaceImageConfig bdNirFaceImageConfig,
        final BDFaceImageConfig bdDepthFaceImageConfig,
        final BDFaceCheckConfig bdFaceCheckConfig,
        final FaceDetectCallBack faceDetectCallBack) {
        if (!FaceSDKManager.initModelSuccess) {
            return;
        }
        long startTime = System.currentTimeMillis();
        // 创建检测结果存储数据
        LivenessModel livenessModel = new LivenessModel();
        livenessModel.setGroupId(groupId);
        // 创建检测对象，如果原始数据YUV，转为算法检测的图片BGR
        // TODO: 用户调整旋转角度和是否镜像，手机和开发版需要动态适配
        //System.out.println("==rgbInstance==>初始化");
        if(rgbInstance!=null){
            rgbInstance.destory();
        }
        rgbInstance = getBdImage(bdFaceImageConfig, bdFaceCheckConfig.darkEnhance);
        livenessModel.setTestBDFaceImageInstanceDuration(System.currentTimeMillis() - startTime);
        onTrack(
            rgbInstance,
            livenessModel,
            new DetectListener() {
                @Override
                public void onDetectSuccess(FaceInfo[] faceInfos, BDFaceImageInstance rgbInstance) {
                    // 多帧判断
                    if (!frameSelect(faceInfos[0])) {
                        livenessModel.setBdFaceImageInstance(rgbInstance.getImage());
                        if (faceDetectCallBack != null && faceAdoptModel != null) {
                            //System.out.println("==isOk==>多帧判断");
                            faceDetectCallBack.onFaceDetectDarwCallback(livenessModel);
                            faceDetectCallBack.onFaceDetectCallback(faceAdoptModel);
                        }

                        return;
                    }
                    // 保存人脸特征点
                    livenessModel.setLandmarks(faceInfos[0].landmarks);
                    // 保存人脸图片
                    livenessModel.setBdFaceImageInstance(rgbInstance.getImage());
                    // 口罩检测数据
                    if (checkMouthMask) {
                        FaceMouthMask mouthMask = getFaceMouthMask();
                        if (mouthMask != null) {
                            float[] maskScores = mouthMask.checkMask(rgbInstance, faceInfos);
                            if (maskScores != null && maskScores.length > 0) {
                                float maskResult = maskScores[0];
                                Log.d("mouth_mask", "mask_score:" + maskResult);
                                if (livenessModel != null) {
                                    livenessModel.setMouthMaskArray(maskScores);
                                }
                            }
                        }
                    }

                    // 调用绘制人脸框接口
                    if (faceDetectCallBack != null) {
                        faceDetectCallBack.onFaceDetectDarwCallback(livenessModel);
                    }

                    // 送检识别
                    onLivenessCheck(
                        rgbInstance,
                        bdNirFaceImageConfig,
                        bdDepthFaceImageConfig,
                        bdFaceCheckConfig,
                        livenessModel,
                        startTime,
                        faceDetectCallBack,
                        faceInfos);
                }

                @Override
                public void onDetectFail() {

                    emptyFrame();
                    // 流程结束销毁图片，开始下一帧图片检测，否着内存泄露
                    if (faceDetectCallBack != null) {
                        faceDetectCallBack.onFaceDetectCallback(null);
                        livenessModel.setBdFaceImageInstance(rgbInstance.getImage());
                        //System.out.println("==isOk==>流程结束");
//                        SaveImageManager.getInstance().saveImage(livenessModel, bdFaceCheckConfig.bdLiveConfig);
                        faceDetectCallBack.onFaceDetectDarwCallback(livenessModel);
                        faceDetectCallBack.onTip(0, "未检测到人脸");
                    }
                }
            });
    }

    private float silentLive(
        BDFaceImageInstance rgbInstance,
        BDFaceSDKCommon.LiveType type,
        float[] landmarks,
        List<Boolean> list,
        float liveScore) {
        float score = 0;
        if (landmarks != null) {
            synchronized (faceModel.getFaceLive()) {
                Log.e("test_camera", rgbInstance.getImage().data.length + "开始");
                score = faceModel.getFaceLive().silentLive(type, rgbInstance, landmarks, liveScore);
                Log.e("test_camera", "活体结束");
            }
            list.add(score > liveScore);
        }
        while (list.size() > 6) {
            list.remove(0);
        }
        if (list.size() > 2) {
            int rgbSum = 0;
            for (Boolean b : list) {
                if (b) {
                    rgbSum++;
                }
            }
            if (1.0 * rgbSum / list.size() > 0.6) {
                if (score < liveScore) {
                    score = liveScore + (1 - liveScore) * new Random().nextFloat();
                }
            } else {
                if (score > liveScore) {
                    score = new Random().nextFloat() * liveScore;
                }
            }
        }
        return score;
    }

    /**
     *  活体检测
     * @param rgbInstance
     * @param type
     * @param faceInfos
     * @param list
     * @param liveScore
     * @return
     */
    private float[] silentLives(
        BDFaceImageInstance rgbInstance,
        BDFaceSDKCommon.LiveType type,
        FaceInfo[] faceInfos,
        List<Boolean> list,
        float liveScore) {
        float[] scores = {0, 0, 0}; // 最多检测3个人脸
        if (faceInfos != null) {
            synchronized (faceModel.getFaceLive()) {
                Log.e("test_camera", rgbInstance.getImage().data.length + "开始");
                int size = faceInfos.length;

                for (int i = 0; i < size; i++) {
                    scores[i] =
                        faceModel.getFaceLive().silentLive(type, rgbInstance, faceInfos[i].landmarks, liveScore);
                }
            }
        }
        return scores;
    }

    private void onDetect(
        BDFaceCheckConfig bdFaceCheckConfig,
        BDFaceImageInstance rgbInstance,
        FaceInfo[] fastFaceInfos,
        LivenessModel livenessModel,
        DetectListener detectListener) {

        long accurateTime = System.currentTimeMillis();
        FaceInfo[] faceInfos;

        if (bdFaceCheckConfig != null) {
            bdFaceCheckConfig.bdFaceDetectListConfig.usingQuality = true;
            faceInfos =
                faceModel
                    .getFaceDetect()
                    .detect(
                        BDFaceSDKCommon.DetectType.DETECT_VIS,
                        BDFaceSDKCommon.AlignType.BDFACE_ALIGN_TYPE_RGB_ACCURATE,
                        rgbInstance,
                        fastFaceInfos,
                        bdFaceCheckConfig.bdFaceDetectListConfig);

        } else {
            faceInfos = faceModel.getFaceDetect().detect(BDFaceSDKCommon.DetectType.DETECT_VIS, rgbInstance);
        }

        livenessModel.setAccurateTime(System.currentTimeMillis() - accurateTime);

        if (faceInfos == null || faceInfos.length <= 0) {

            detectListener.onDetectFail();
            return;
        }

        // 重新赋予详细人脸信息
        if (livenessModel.getFaceInfo() != null) {
            faceInfos[0].faceID = livenessModel.getFaceInfo().faceID;
        }

        livenessModel.setFaceInfos(faceInfos);
        livenessModel.setFaceInfo(faceInfos[0]);
        livenessModel.setTrackStatus(2);
        // 保存人脸关键点
        livenessModel.setLandmarks(faceInfos[0].landmarks);
        detectListener.onDetectSuccess(faceInfos, rgbInstance);
    }

    /**
     * 活体-特征-人脸检索全流程
     *
     * @param rgbInstance            可见光底层送检对象
     * @param nirBDFaceImageConfig   红外YUV 数据流
     * @param depthBDFaceImageConfig 深度depth 数据流
     * @param livenessModel          检测结果数据集合
     * @param startTime              开始检测时间
     * @param faceDetectCallBack
     */
    public void onLivenessCheck(
        final BDFaceImageInstance rgbInstance,
        final BDFaceImageConfig nirBDFaceImageConfig,
        final BDFaceImageConfig depthBDFaceImageConfig,
        final BDFaceCheckConfig bdFaceCheckConfig,
        final LivenessModel livenessModel,
        final long startTime,
        final FaceDetectCallBack faceDetectCallBack,
        final FaceInfo[] fastFaceInfos) {
        if (future2 != null && !future2.isDone()) {
            // 流程结束销毁图片，开始下一帧图片检测，否着内存泄露
            //future2.cancel(true);

            //System.out.println("==isOk==>之前没结束");
            return;
        }

        future2 =
            es2.submit(
                new Runnable() {

                    @Override
                    public void run() {

                        // 获取BDFaceCheckConfig配置信息
                        if (bdFaceCheckConfig == null) {

                            return;
                        }
                        onDetect(
                            bdFaceCheckConfig,
                            rgbInstance,
                            fastFaceInfos,
                            livenessModel,
                            new DetectListener() {

                                @Override
                                public void onDetectSuccess(FaceInfo[] faceInfos, BDFaceImageInstance rgbInstance) {

                                    // 人脸id赋值
                                    if (mLastFaceId != fastFaceInfos[0].faceID) {
                                        mLastFaceId = fastFaceInfos[0].faceID;
                                        mRgbLiveList.clear();
                                        mNirLiveList.clear();
                                    }

                                    if (bdFaceCheckConfig == null) {

                                        livenessModel.clearIdentifyResults();
                                        if (faceDetectCallBack != null) {
                                            faceDetectCallBack.onFaceDetectCallback(livenessModel);
                                        }
                                        return;
                                    }

                                    // 最优人脸控制
                                    if (!onBestImageCheck(livenessModel, bdFaceCheckConfig, faceDetectCallBack)) {
                                        livenessModel.setQualityCheck(true);
                                        livenessModel.clearIdentifyResults();

                                        if (faceDetectCallBack != null) {
                                            faceDetectCallBack.onFaceDetectCallback(livenessModel);
                                        }
                                        return;
                                    }

                                    // 质量检测未通过,销毁BDFaceImageInstance，结束函数

                                    if (!onQualityCheck(
                                            faceInfos, bdFaceCheckConfig.bdQualityConfig, faceDetectCallBack)) {
                                        livenessModel.setQualityCheck(true);
                                        livenessModel.clearIdentifyResults();

                                        if (faceDetectCallBack != null) {
                                            faceDetectCallBack.onFaceDetectCallback(livenessModel);
                                        }
                                        return;
                                    }

                                    livenessModel.setQualityCheck(false);
                                    // 获取LivenessConfig liveCheckMode 配置选项：【不使用活体：0】；【RGB活体：1】；【RGB+NIR活体：2】；【RGB+Depth活体：3】；【RGB+NIR+Depth活体：4】
                                    // TODO 活体检测
                                    float[] rgbScores = {-1};
                                    BDLiveConfig bdLiveConfig = bdFaceCheckConfig.bdLiveConfig;
                                    boolean isLiveCheck = bdFaceCheckConfig.bdLiveConfig != null;

                                    if (isLiveCheck) {
                                        long startRgbTime = System.currentTimeMillis();
                                        rgbScores =
                                            silentLives(
                                                rgbInstance,
                                                BDFaceSDKCommon.LiveType.BDFACE_SILENT_LIVE_TYPE_RGB,
                                                faceInfos,
                                                mRgbLiveList,
                                                bdLiveConfig.rgbLiveScore);
                                        /* if (rgbScores != null){
                                            int size = rgbScores.length;
                                            Log.d("Attend", "score size:" + size);
                                            for (int i = 0; i < size; i++) {
                                                Log.d("Attend", "score:" + rgbScores[i]);
                                            }
                                        } */

                                        if (faceInfos.length == 1) {
                                            livenessModel.setRgbLivenessScore(rgbScores[0]);
                                        }
                                        livenessModel.setRgbLivenessScores(rgbScores);
                                        livenessModel.setRgbLivenessDuration(System.currentTimeMillis() - startRgbTime);
                                    }

                                    // TODO nir活体检测
                                    float nirScore = -1;
                                    FaceInfo[] faceInfosIr = null;
                                    BDFaceImageInstance nirInstance = null;
                                    boolean isHaveNirImage = nirBDFaceImageConfig != null && isLiveCheck;
                                    if (isHaveNirImage) {
                                        // 创建检测对象，如果原始数据YUV-IR，转为算法检测的图片BGR
                                        // TODO: 用户调整旋转角度和是否镜像，手机和开发版需要动态适配
                                        long nirInstanceTime = System.currentTimeMillis();
                                        nirInstance = getBdImage(nirBDFaceImageConfig, false);

                                        livenessModel.setBdNirFaceImageInstance(nirInstance.getImage());
                                        livenessModel.setNirInstanceTime(System.currentTimeMillis() - nirInstanceTime);

                                        // 避免RGB检测关键点在IR对齐活体稳定，增加红外检测
                                        long startIrDetectTime = System.currentTimeMillis();
                                        BDFaceDetectListConf bdFaceDetectListConf = new BDFaceDetectListConf();
                                        bdFaceDetectListConf.usingDetect = true;
                                        faceInfosIr =
                                            faceModel
                                                .getFaceNirDetect()
                                                .detect(
                                                    BDFaceSDKCommon.DetectType.DETECT_NIR,
                                                    BDFaceSDKCommon.AlignType.BDFACE_ALIGN_TYPE_NIR_ACCURATE,
                                                    nirInstance,
                                                    null,
                                                    bdFaceDetectListConf);
                                        livenessModel.setIrLivenessDuration(
                                            System.currentTimeMillis() - startIrDetectTime);
                                        //                    LogUtils.e(TIME_TAG, "detect ir time = " + livenessModel.getIrLivenessDuration());
                                        if (faceInfosIr != null && faceInfosIr.length > 0) {
                                            FaceInfo faceInfoIr = faceInfosIr[0];
                                            nirScore =
                                                silentLive(
                                                    nirInstance,
                                                    BDFaceSDKCommon.LiveType.BDFACE_SILENT_LIVE_TYPE_NIR,
                                                    faceInfoIr.landmarks,
                                                    mNirLiveList,
                                                    bdLiveConfig.nirLiveScore);
                                            livenessModel.setIrLivenessScore(nirScore);
                                            //                        LogUtils.e(TIME_TAG, "live ir time = " + livenessModel.getIrLivenessDuration());
                                        }
                                    }

                                    // TODO depth活体检测
                                    float depthScore = -1;
                                    boolean isHaveDepthImage = depthBDFaceImageConfig != null && isLiveCheck;
                                    if (depthBDFaceImageConfig != null) {
                                        // TODO: 用户调整旋转角度和是否镜像，适配Atlas 镜头，目前宽和高400*640，其他摄像头需要动态调整,人脸72 个关键点x 坐标向左移动80个像素点
                                        float[] depthLandmark = new float[faceInfos[0].landmarks.length];
                                        BDFaceImageInstance depthInstance;
                                        if (bdFaceCheckConfig.cameraType == 1) {
                                            System.arraycopy(
                                                faceInfos[0].landmarks,
                                                0,
                                                depthLandmark,
                                                0,
                                                faceInfos[0].landmarks.length);
                                            for (int i = 0; i < 144; i = i + 2) {
                                                depthLandmark[i] -= 80;
                                            }
                                        } else {
                                            depthLandmark = faceInfos[0].landmarks;
                                        }
                                        depthInstance = getBdImage(depthBDFaceImageConfig, false);
                                        livenessModel.setBdDepthFaceImageInstance(depthInstance.getImage());
                                        // 创建检测对象，如果原始数据Depth
                                        long startDepthTime = System.currentTimeMillis();
                                        depthScore =
                                            faceModel
                                                .getFaceLive()
                                                .silentLive(
                                                    BDFaceSDKCommon.LiveType.BDFACE_SILENT_LIVE_TYPE_DEPTH,
                                                    depthInstance,
                                                    depthLandmark);
                                        livenessModel.setDepthLivenessScore(depthScore);
                                        livenessModel.setDepthtLivenessDuration(
                                            System.currentTimeMillis() - startDepthTime);
                                        //                    LogUtils.e(TIME_TAG, "live depth time = " + livenessModel.getDepthtLivenessDuration());
                                        depthInstance.destory();
                                    }

                                    boolean isRgbScoreCheck = false;
                                    boolean isNirScoreCheck = false;
                                    boolean isDepthScoreCheck = false;
                                    if (isLiveCheck) {
                                        int size = rgbScores.length;
                                        for (int i = 0; i < size; i++) {
                                            if (rgbScores[i] > bdLiveConfig.rgbLiveScore) {
                                                isRgbScoreCheck = true;
                                            }
                                        }
                                        // isRgbScoreCheck = true; // liujinhui for test
                                        //   isRgbScoreCheck = (rgbScores[0] > bdLiveConfig.rgbLiveScore);
                                        isNirScoreCheck =
                                            (isHaveNirImage ? nirScore > bdLiveConfig.nirLiveScore : true);
                                        isDepthScoreCheck =
                                            (isHaveDepthImage ? depthScore > bdLiveConfig.depthLiveScore : true);
                                    }

                                    // 如果设置为不进行活体检测
                                    int liveCheckMode = livenessModel.getLiveType();
                                    if (liveCheckMode == 0){
                                        isRgbScoreCheck = true;
                                    }
                                    // TODO 特征提取+人脸检索
                                    if (!isLiveCheck || (isRgbScoreCheck && isNirScoreCheck && isDepthScoreCheck)) {
                                        if (livenessModel != null) {
                                            livenessModel.clearIdentifyResults();
                                            livenessModel.setUser(null);
                                        }

                                        synchronized (faceModel.getFaceSearch()) {
                                            if (faceInfos != null) {
                                                int size = faceInfos.length;

                                                for (int i = 0; i < size; i++) {
                                                    // 特征提取
                                                    // 模糊结果过滤,戴口罩时候，不进行过滤
                                                    if (!checkMouthMask) {
                                                        float blur = faceInfos[i].bluriness;
                                                        BDFaceOcclusion occlusion = faceInfos[i].occlusion;
                                                        float leftEye = occlusion.leftEye;
                                                        // "左眼遮挡"
                                                        float rightEye = occlusion.rightEye;
                                                        // "右眼遮挡"
                                                        float nose = occlusion.nose;
                                                        // "鼻子遮挡置信度"
                                                        float mouth = occlusion.mouth;
                                                        // "嘴巴遮挡置信度"
                                                        float leftCheek = occlusion.leftCheek;
                                                        // "左脸遮挡"
                                                        float rightCheek = occlusion.rightCheek;
                                                        // "右脸遮挡"
                                                        float chin = occlusion.chin;
                                                        // 动态底库限制
                                                        faceModel
                                                                .getFaceSearch()
                                                                .setNeedJoinDB(
                                                                        selectQuality(
                                                                                blur,
                                                                                leftEye,
                                                                                rightEye,
                                                                                nose,
                                                                                mouth,
                                                                                leftCheek,
                                                                                rightCheek,
                                                                                chin));
                                                    }

                                                    if (bdLiveConfig != null){
                                                        onFeatureChecks(
                                                                i,
                                                                rgbInstance,
                                                                bdFaceCheckConfig,
                                                                faceInfos,
                                                                faceInfosIr,
                                                                nirInstance,
                                                                livenessModel,
                                                                bdFaceCheckConfig.secondFeature,
                                                                bdFaceCheckConfig.featureCheckMode,
                                                                bdFaceCheckConfig.activeModel,
                                                                rgbScores,
                                                                bdLiveConfig.rgbLiveScore);
                                                    } else{
                                                        onFeatureChecks(
                                                                i,
                                                                rgbInstance,
                                                                bdFaceCheckConfig,
                                                                faceInfos,
                                                                faceInfosIr,
                                                                nirInstance,
                                                                livenessModel,
                                                                bdFaceCheckConfig.secondFeature,
                                                                bdFaceCheckConfig.featureCheckMode,
                                                                bdFaceCheckConfig.activeModel,
                                                                rgbScores,
                                                                -1);
                                                    }

                                                }
                                            }
                                        }
                                    }

                                    // 流程结束,记录最终时间
                                    livenessModel.setAllDetectDuration(System.currentTimeMillis() - startTime);
                                    //                LogUtils.e(TIME_TAG, "all process time = " + livenessModel.getAllDetectDuration());
                                    // 流程结束销毁图片，开始下一帧图片检测，否着内存泄露

                                    if (nirInstance != null) {
                                        nirInstance.destory();
                                    }
                                    // 显示最终结果提示
                                    if (faceDetectCallBack != null) {
                                        faceDetectCallBack.onFaceDetectCallback(livenessModel);
                                    }
                                }

                                @Override
                                public void onDetectFail() {

                                    if (faceDetectCallBack != null) {
                                        faceDetectCallBack.onFaceDetectCallback(livenessModel);
                                    }
                                }
                            });
                    }
                });
    }

    /**
     * 最优人脸控制
     *
     * @param livenessModel
     * @param faceDetectCallBack
     * @return
     */
    public boolean onBestImageCheck(
        LivenessModel livenessModel, BDFaceCheckConfig bdFaceCheckConfig, FaceDetectCallBack faceDetectCallBack) {
        boolean isBestImageCheck = false;
        if (livenessModel != null && livenessModel.getFaceInfos() != null) {
            FaceInfo[] faceInfos = livenessModel.getFaceInfos();
            int size = faceInfos.length;
            for (int i = 0; i < size; i++) {
                float bestImageScore = faceInfos[i].bestImageScore;
                if (bestImageScore > 0.5) {
                    isBestImageCheck = true;
                }
            }
        }
        return isBestImageCheck;
    }

    /**
     * 特征提取-人脸识别比对
     *
     * @param rgbInstance      可见光底层送检对象
     * @param landmark         检测眼睛，嘴巴，鼻子，72个关键点
     * @param faceInfos        nir人脸数据
     * @param nirInstance      nir 图像句柄
     * @param livenessModel    检测结果数据集合
     * @param featureCheckMode 特征抽取模式【不提取特征：1】；【提取特征：2】；【提取特征+1：N检索：3】；
     * @param featureType      特征抽取模态执行 【生活照：1】；【证件照：2】；【混合模态：3】；
     */
    private void onFeatureCheck(
        BDFaceImageInstance rgbInstance,
        BDFaceCheckConfig bdFaceCheckConfig,
        float[] landmark,
        FaceInfo[] faceInfos,
        BDFaceImageInstance nirInstance,
        LivenessModel livenessModel,
        byte[] secondFeature,
        final int featureCheckMode,
        final int featureType) {
        // 如果不抽取特征，直接返回
        if (featureCheckMode == 1) {
            return;
        }
        byte[] feature = new byte[512];
        if (featureType == 3) {
            // todo: 混合模态使用方式是根据图片的曝光来选择需要使用的type，光照的取值范围为：0~1之间
            AtomicInteger atomicInteger = new AtomicInteger();
            FaceSDKManager.getInstance().getImageIllum().imageIllum(rgbInstance, atomicInteger);
            int illumScore = atomicInteger.get();
            BDQualityConfig bdQualityConfig = bdFaceCheckConfig.bdQualityConfig;
            boolean isIllum = bdQualityConfig != null ? illumScore < bdQualityConfig.illum : false;
            BDFaceSDKCommon.FeatureType type =
                isIllum
                    ? BDFaceSDKCommon.FeatureType.BDFACE_FEATURE_TYPE_NIR
                    : BDFaceSDKCommon.FeatureType.BDFACE_FEATURE_TYPE_LIVE_PHOTO;
            BDFaceImageInstance bdFaceImageInstance = isIllum ? nirInstance : rgbInstance;
            float[] landmarks = isIllum ? faceInfos[0].landmarks : landmark;

            long startFeatureTime = System.currentTimeMillis();
            float featureSize = faceModel.getFaceFeature().feature(type, bdFaceImageInstance, landmarks, feature);
            livenessModel.setFeatureDuration(System.currentTimeMillis() - startFeatureTime);
            livenessModel.setFeature(feature);
            // 人脸检索
            featureSearch(
                featureCheckMode,
                livenessModel,
                bdFaceCheckConfig,
                feature,
                secondFeature,
                featureSize,
                BDFaceSDKCommon.FeatureType.BDFACE_FEATURE_TYPE_LIVE_PHOTO);
        } else {
            // 生活照检索
            long startFeatureTime = System.currentTimeMillis();
            float featureSize =
                faceModel
                    .getFaceFeature()
                    .feature(
                        BDFaceSDKCommon.FeatureType.BDFACE_FEATURE_TYPE_LIVE_PHOTO, rgbInstance, landmark, feature);
            livenessModel.setFeatureDuration(System.currentTimeMillis() - startFeatureTime);
            livenessModel.setFeature(feature);
            livenessModel.setFeatureDuration(System.currentTimeMillis() - startFeatureTime);
            // 人脸检索
            featureSearch(
                featureCheckMode,
                livenessModel,
                bdFaceCheckConfig,
                feature,
                secondFeature,
                featureSize,
                BDFaceSDKCommon.FeatureType.BDFACE_FEATURE_TYPE_LIVE_PHOTO);
        }
    }

    /**
     * 特征提取-人脸识别比对
     *
     * @param rgbInstance      可见光底层送检对象
     * @param rgbFaceInfos     rgb人脸数据
     * @param faceInfos        nir人脸数据
     * @param nirInstance      nir 图像句柄
     * @param livenessModel    检测结果数据集合
     * @param featureCheckMode 特征抽取模式【不提取特征：1】；【提取特征：2】；【提取特征+1：N检索：3】；
     * @param featureType      特征抽取模态执行 【生活照：1】；【证件照：2】；【混合模态：3】；
     * @param rgbScores 可见光得分
     * @param liveScore 可见光活体阈值
     */
    private void onFeatureChecks(
        int index,
        BDFaceImageInstance rgbInstance,
        BDFaceCheckConfig bdFaceCheckConfig,
        FaceInfo[] rgbFaceInfos,
        FaceInfo[] faceInfos,
        BDFaceImageInstance nirInstance,
        LivenessModel livenessModel,
        byte[] secondFeature,
        final int featureCheckMode,
        final int featureType,
        float[] rgbScores,
        float liveScore) {
        // 如果不抽取特征，直接返回

        if (featureCheckMode == 1) {
            return;
        }
        byte[] feature = new byte[512];

        if (featureType == 3) {
            // todo: 混合模态使用方式是根据图片的曝光来选择需要使用的type，光照的取值范围为：0~1之间
            AtomicInteger atomicInteger = new AtomicInteger();
            FaceSDKManager.getInstance().getImageIllum().imageIllum(rgbInstance, atomicInteger);
            int illumScore = atomicInteger.get();
            BDQualityConfig bdQualityConfig = bdFaceCheckConfig.bdQualityConfig;
            boolean isIllum = bdQualityConfig != null ? illumScore < bdQualityConfig.illum : false;
            BDFaceSDKCommon.FeatureType type =
                isIllum
                    ? BDFaceSDKCommon.FeatureType.BDFACE_FEATURE_TYPE_NIR
                    : BDFaceSDKCommon.FeatureType.BDFACE_FEATURE_TYPE_LIVE_PHOTO;
            BDFaceImageInstance bdFaceImageInstance = isIllum ? nirInstance : rgbInstance;

            if (rgbFaceInfos == null) {
                return;
            }
            int size = faceInfos.length;

            if (rgbFaceInfos[index].landmarks == null) {
                return;
            }

            if (rgbScores != null) {
                float score = rgbScores[index];
                if (score < liveScore) {
                    return;
                }
            }

            float[] landmarks = rgbFaceInfos[index].landmarks;

            long startFeatureTime = System.currentTimeMillis();
            float featureSize = faceModel.getFaceFeature().feature(type, bdFaceImageInstance, landmarks, feature);
            livenessModel.setFeatureDuration(System.currentTimeMillis() - startFeatureTime);
            livenessModel.setFeature(feature);
            // 人脸检索
            featureSearchs(
                index,
                featureCheckMode,
                livenessModel,
                bdFaceCheckConfig,
                feature,
                secondFeature,
                featureSize,
                BDFaceSDKCommon.FeatureType.BDFACE_FEATURE_TYPE_LIVE_PHOTO);

        } else {
            // 生活照检索
            long startFeatureTime = System.currentTimeMillis();
            if (rgbFaceInfos == null) {
                return;
            }

            int size = rgbFaceInfos.length;

            if (rgbFaceInfos[index].landmarks == null) {
                return;
            }

            if (rgbScores != null) {
                float score = rgbScores[index];
                if (score < liveScore) {
                    return;
                }
            }

            float featureSize =
                faceModel
                    .getFaceFeature()
                    .feature(
                        BDFaceSDKCommon.FeatureType.BDFACE_FEATURE_TYPE_LIVE_PHOTO,
                        rgbInstance,
                        rgbFaceInfos[index].landmarks,
                        feature);

            livenessModel.setFeatureDuration(System.currentTimeMillis() - startFeatureTime);
            livenessModel.setFeature(feature);
            livenessModel.setFeatureDuration(System.currentTimeMillis() - startFeatureTime);
            // 人脸检索
            featureSearchs(
                index,
                featureCheckMode,
                livenessModel,
                bdFaceCheckConfig,
                feature,
                secondFeature,
                featureSize,
                BDFaceSDKCommon.FeatureType.BDFACE_FEATURE_TYPE_LIVE_PHOTO);
        }
    }

    /**
     * 人脸库检索
     *
     * @param featureCheckMode 特征抽取模式【不提取特征：1】；【提取特征：2】；【提取特征+1：N检索：3】；
     * @param livenessModel    检测结果数据集合
     * @param feature          特征点
     * @param secondFeature    1:1 特征点
     * @param featureSize      特征点的size
     * @param type             特征提取类型
     */
    private void featureSearch(
        final int featureCheckMode,
        LivenessModel livenessModel,
        BDFaceCheckConfig bdFaceCheckConfig,
        byte[] feature,
        byte[] secondFeature,
        float featureSize,
        BDFaceSDKCommon.FeatureType type) {

        // 如果只提去特征，不做检索，此处返回
        if (featureCheckMode == 2) {
            livenessModel.setFeatureCode(featureSize);
            return;
        }
        // 如果提取特征+检索，调用search 方法
        if (featureSize == FEATURE_SIZE / 4) {
            long startFeature = System.currentTimeMillis();
            // 特征提取成功
            // TODO 阈值可以根据不同模型调整
            if (featureCheckMode == 3) {
                List<? extends Feature> featureResult =
                    faceModel.getFaceSearch().search(type, bdFaceCheckConfig.scoreThreshold, 1, feature, false);

                // TODO 返回top num = 1 个数据集合，此处可以任意设置，会返回比对从大到小排序的num 个数据集合
                if (featureResult != null && featureResult.size() > 0) {

                    // 获取第一个数据
                    Feature topFeature = featureResult.get(0);
                    // 判断第一个阈值是否大于设定阈值，如果大于，检索成功
                    threholdScore = bdFaceCheckConfig.scoreThreshold;
                    if (topFeature != null && topFeature.getScore() > threholdScore) {
                        // 当前featureEntity 只有id+feature 索引，在数据库中查到完整信息
                        User user = FaceApi.getInstance().getUserListById(topFeature.getId());
                        if (user != null) {
                            livenessModel.setUser(user);
                            livenessModel.setFeatureScore(topFeature.getScore());
                            /*faceId = livenessModel.getFaceInfo().faceID;
                            trackTime = System.currentTimeMillis();
                            faceAdoptModel = livenessModel;
                            failNumber = 0;
                            isFail = false;*/
                            setFail(livenessModel);
                        } else {
                            setFail(livenessModel);
                        }
                    } else {
                        setFail(livenessModel);
                    }
                } else {
                    setFail(livenessModel);
                }
            } else if (featureCheckMode == 4) {
                // 目前仅支持
                float score =
                    faceModel
                        .getFaceSearch()
                        .compare(
                            BDFaceSDKCommon.FeatureType.BDFACE_FEATURE_TYPE_ID_PHOTO,
                            livenessModel.getFeature(),
                            secondFeature,
                            true);
                livenessModel.setScore(score);
                if (score > threholdScore) {
                    /*faceId = livenessModel.getFaceInfo().faceID;
                    trackTime = System.currentTimeMillis();
                    faceAdoptModel = livenessModel;
                    failNumber = 0;
                    isFail = false;*/
                    setFail(livenessModel);
                } else {
                    setFail(livenessModel);
                }
            }
            livenessModel.setCheckDuration(System.currentTimeMillis() - startFeature);
        }
    }

    /**
     * 人脸库检索
     *
     * @param featureCheckMode 特征抽取模式【不提取特征：1】；【提取特征：2】；【提取特征+1：N检索：3】；
     * @param livenessModel    检测结果数据集合
     * @param feature          特征点
     * @param secondFeature    1:1 特征点
     * @param featureSize      特征点的size
     * @param type             特征提取类型
     */
    private void featureSearchs(
        final int index,
        final int featureCheckMode,
        LivenessModel livenessModel,
        BDFaceCheckConfig bdFaceCheckConfig,
        byte[] feature,
        byte[] secondFeature,
        float featureSize,
        BDFaceSDKCommon.FeatureType type) {

        // 如果只提去特征，不做检索，此处返回

        if (featureCheckMode == 2) {
            livenessModel.setFeatureCode(featureSize);
            return;
        }
        // 如果提取特征+检索，调用search 方法
        if (featureSize == FEATURE_SIZE / 4) {
            long startFeature = System.currentTimeMillis();
            // 特征提取成功
            // TODO 阈值可以根据不同模型调整
            if (featureCheckMode == 3) {
                //System.out.println("==isOk==>44");
                List<? extends Feature> featureResult =
                    faceModel.getFaceSearch().search(type, bdFaceCheckConfig.scoreThreshold, 5, feature, false);
                //System.out.println("==isOk==>45");
                // TODO 返回top num = 1 个数据集合，此处可以任意设置，会返回比对从大到小排序的num 个数据集合
                if (featureResult != null && featureResult.size() > 0) {
                    //System.out.println("==isOk==>匹配到数量"+featureResult.size());
                    User user = null;
                    Feature topFeature = null;
                    if(TextUtils.isEmpty(livenessModel.getGroupId())){
                        //为空，需要排序，优先取会员
                        for(Feature feat:featureResult) {
                            threholdScore = bdFaceCheckConfig.scoreThreshold;
                            if (feat != null && feat.getScore() > threholdScore) {
                                User userOld = FaceApi.getInstance().getUserListById(feat.getId());
                                //System.out.println("==isOk==>匹配到类型:"+userOld.getUserName());
                                if("0".equals(userOld.getGroupId())){
                                    user = userOld;
                                    topFeature = feat;
                                    break;
                                }else if(user==null){
                                    user = userOld;
                                    topFeature = feat;
                                }
                            }
                        }
                    }else {
                        //只取该类型用户
                        for(Feature feat:featureResult) {
                            // 获取数据
                            // 判断阈值是否大于设定阈值，如果大于，检索成功
                            threholdScore = bdFaceCheckConfig.scoreThreshold;
                            if (feat != null && feat.getScore() > threholdScore) {
                                //System.out.println("==isOk==>50");
                                // 当前featureEntity 只有id+feature 索引，在数据库中查到完整信息
                                User userOld = FaceApi.getInstance().getUserListById(feat.getId());
                                if(livenessModel.getGroupId().equals(userOld.getGroupId())){
                                    user = userOld;
                                    topFeature = feat;
                                    break;
                                }
                            }
                        }
                    }
                    if (user != null) {
                        //System.out.println("==isOk==>匹配到");
                        IdentifyResult idResult = new IdentifyResult(user, index, topFeature.getScore());
                        livenessModel.addIdentifyResult(idResult);
                        livenessModel.setUser(user);
                        livenessModel.setFeatureScore(topFeature.getScore());
                        setFail(livenessModel);
                    } else {
                        //IdentifyResult idResult = new IdentifyResult(user, index, topFeature.getScore());
                        setFail(livenessModel);
                    }
                } else {
                    setFail(livenessModel);
                }
            } else if (featureCheckMode == 4) {
                // 目前仅支持
                float score =
                    faceModel
                        .getFaceSearch()
                        .compare(
                            BDFaceSDKCommon.FeatureType.BDFACE_FEATURE_TYPE_ID_PHOTO,
                            livenessModel.getFeature(),
                            secondFeature,
                            true);
                livenessModel.setScore(score);
                if (score > threholdScore) {
                    /*faceId = livenessModel.getFaceInfo().faceID;
                    trackTime = System.currentTimeMillis();
                    faceAdoptModel = livenessModel;
                    failNumber = 0;
                    isFail = false;*/
                    setFail(livenessModel);
                } else {
                    setFail(livenessModel);
                }
            }
            livenessModel.setCheckDuration(System.currentTimeMillis() - startFeature);
        }
    }

    /**
     * 金融活检-检测-活体
     *
     * @param bdFaceImageConfig      可见光YUV 数据流
     * @param bdNirFaceImageConfig   红外YUV 数据流
     * @param bdDepthFaceImageConfig 深度depth 数据流
     * @param bdFaceCheckConfig      识别参数
     * @param faceDetectCallBack
     */
    public void onDetectSilentLiveCheck(
        final BDFaceImageConfig bdFaceImageConfig,
        final BDFaceImageConfig bdNirFaceImageConfig,
        final BDFaceImageConfig bdDepthFaceImageConfig,
        final BDFaceCheckConfig bdFaceCheckConfig,
        final FaceDetectCallBack faceDetectCallBack) {
        long startTime = System.currentTimeMillis();
        // 创建检测结果存储数据
        LivenessModel livenessModel = new LivenessModel();
        // 创建检测对象，如果原始数据YUV，转为算法检测的图片BGR
        // TODO: 用户调整旋转角度和是否镜像，手机和开发版需要动态适配
        BDFaceImageInstance rgbInstance = getBdImage(bdFaceImageConfig, bdFaceCheckConfig.darkEnhance);
        livenessModel.setTestBDFaceImageInstanceDuration(System.currentTimeMillis() - startTime);
        onTrack(
            rgbInstance,
            livenessModel,
            new DetectListener() {
                @Override
                public void onDetectSuccess(FaceInfo[] faceInfos, BDFaceImageInstance rgbInstance) {

                    // 保存人脸特征点
                    livenessModel.setLandmarks(faceInfos[0].landmarks);
                    // 保存人脸图片
                    livenessModel.setBdFaceImageInstance(rgbInstance.getImage());
                    // 调用绘制人脸框接口
                    if (faceDetectCallBack != null) {
                        faceDetectCallBack.onFaceDetectDarwCallback(livenessModel);
                    }
                    // 送检识别
                    onSilentLivenessCheck(
                        rgbInstance,
                        bdNirFaceImageConfig,
                        bdDepthFaceImageConfig,
                        bdFaceCheckConfig,
                        livenessModel,
                        startTime,
                        faceDetectCallBack,
                        faceInfos);
                }

                @Override
                public void onDetectFail() {
                    // 流程结束销毁图片，开始下一帧图片检测，否着内存泄露
                    if (faceDetectCallBack != null) {
                        faceDetectCallBack.onFaceDetectCallback(null);
                        livenessModel.setBdFaceImageInstance(rgbInstance.getImage());
                        faceDetectCallBack.onFaceDetectDarwCallback(livenessModel);
                        faceDetectCallBack.onTip(0, "未检测到人脸");
                    }

                }
            });
    }

    /**
     * 金融活检-活体
     *
     * @param rgbInstance            可见光底层送检对象
     * @param nirBDFaceImageConfig   红外YUV 数据流
     * @param depthBDFaceImageConfig 深度depth 数据流
     * @param livenessModel          检测结果数据集合
     * @param startTime              开始检测时间
     * @param faceDetectCallBack
     */
    public void onSilentLivenessCheck(
        final BDFaceImageInstance rgbInstance,
        final BDFaceImageConfig nirBDFaceImageConfig,
        final BDFaceImageConfig depthBDFaceImageConfig,
        final BDFaceCheckConfig bdFaceCheckConfig,
        final LivenessModel livenessModel,
        final long startTime,
        final FaceDetectCallBack faceDetectCallBack,
        final FaceInfo[] fastFaceInfos) {

        if (future2 != null && !future2.isDone()) {
            // 流程结束销毁图片，开始下一帧图片检测，否着内存泄露

            return;
        }

        future2 =
            es2.submit(
                new Runnable() {

                    @Override
                    public void run() {
                        onDetect(
                            bdFaceCheckConfig,
                            rgbInstance,
                            fastFaceInfos,
                            livenessModel,
                            new DetectListener() {
                                @Override
                                public void onDetectSuccess(FaceInfo[] faceInfos, BDFaceImageInstance rgbInstance) {
                                    // 人脸id赋值
                                    if (mLastFaceId != fastFaceInfos[0].faceID) {
                                        mLastFaceId = fastFaceInfos[0].faceID;
                                        mRgbLiveList.clear();
                                        mNirLiveList.clear();
                                    }
                                    if (bdFaceCheckConfig == null) {

                                        if (faceDetectCallBack != null) {
                                            faceDetectCallBack.onFaceDetectCallback(livenessModel);
                                        }
                                        return;
                                    }
                                    // 最优人脸控制
                                    if (!onBestImageCheck(livenessModel, bdFaceCheckConfig, faceDetectCallBack)) {
                                        livenessModel.setQualityCheck(true);

                                        if (faceDetectCallBack != null) {
                                            faceDetectCallBack.onFaceDetectCallback(livenessModel);
                                        }
                                        return;
                                    }
                                    onQualityCheck(
                                        faceInfos,
                                        bdFaceCheckConfig.bdQualityConfig,
                                        faceDetectCallBack,
                                        new QualityListener() {
                                            @Override
                                            public void onQualitySuccess() {
                                                livenessModel.setQualityCheck(false);
                                                // 获取LivenessConfig liveCheckMode 配置选项：【不使用活体：0】；【RGB活体：1】；【RGB+NIR活体：2】；【RGB+Depth活体：3】；【RGB+NIR+Depth活体：4】
                                                // TODO 活体检测
                                                BDLiveConfig bdLiveConfig = bdFaceCheckConfig.bdLiveConfig;
                                                boolean isLiveCheck = bdFaceCheckConfig.bdLiveConfig != null;
                                                if (isLiveCheck) {
                                                    long startRgbTime = System.currentTimeMillis();
                                                    boolean rgbLiveStatus =
                                                        faceModel
                                                            .getFaceLive()
                                                            .strategySilentLive(
                                                                BDFaceSDKCommon.LiveType.BDFACE_SILENT_LIVE_TYPE_RGB,
                                                                rgbInstance,
                                                                faceInfos[0],
                                                                bdLiveConfig.framesThreshold,
                                                                bdLiveConfig.rgbLiveScore);
                                                    livenessModel.setRGBLiveStatus(rgbLiveStatus);
                                                    livenessModel.setRgbLivenessDuration(
                                                        System.currentTimeMillis() - startRgbTime);
                                                }
                                                // TODO nir活体检测
                                                BDFaceImageInstance nirInstance = null;
                                                boolean isHaveNirImage = nirBDFaceImageConfig != null && isLiveCheck;
                                                if (isHaveNirImage) {

                                                    // 创建检测对象，如果原始数据YUV-IR，转为算法检测的图片BGR
                                                    // TODO: 用户调整旋转角度和是否镜像，手机和开发版需要动态适配
                                                    nirInstance = getBdImage(nirBDFaceImageConfig, false);
                                                    livenessModel.setBdNirFaceImageInstance(nirInstance.getImage());

                                                    // 避免RGB检测关键点在IR对齐活体稳定，增加红外检测
                                                    long startIrDetectTime = System.currentTimeMillis();
                                                    BDFaceDetectListConf bdFaceDetectListConf =
                                                        new BDFaceDetectListConf();
                                                    bdFaceDetectListConf.usingDetect = true;
                                                    FaceInfo[] faceInfosIr =
                                                        faceModel
                                                            .getFaceNirDetect()
                                                            .detect(
                                                                BDFaceSDKCommon.DetectType.DETECT_NIR,
                                                                BDFaceSDKCommon.AlignType
                                                                    .BDFACE_ALIGN_TYPE_NIR_ACCURATE,
                                                                nirInstance,
                                                                null,
                                                                bdFaceDetectListConf);
                                                    bdFaceDetectListConf.usingDetect = false;
                                                    livenessModel.setIrLivenessDuration(
                                                        System.currentTimeMillis() - startIrDetectTime);
                                                    //                    LogUtils.e(TIME_TAG, "detect ir time = " + livenessModel.getIrLivenessDuration());

                                                    if (faceInfosIr != null && faceInfosIr.length > 0) {
                                                        FaceInfo faceInfoIr = faceInfosIr[0];
                                                        long startNirTime = System.currentTimeMillis();
                                                        boolean nirLiveStatus =
                                                            faceModel
                                                                .getFaceLive()
                                                                .strategySilentLive(
                                                                    BDFaceSDKCommon.LiveType
                                                                        .BDFACE_SILENT_LIVE_TYPE_NIR,
                                                                    nirInstance,
                                                                    faceInfoIr,
                                                                    bdLiveConfig.framesThreshold,
                                                                    bdLiveConfig.nirLiveScore);
                                                        livenessModel.setNIRLiveStatus(nirLiveStatus);
                                                        livenessModel.setIrLivenessDuration(
                                                            System.currentTimeMillis() - startNirTime);
                                                    }

                                                    nirInstance.destory();
                                                }
                                                // TODO depth活体检测
                                                if (depthBDFaceImageConfig != null) {
                                                    fastFaceInfos[0].landmarks = faceInfos[0].landmarks;
                                                    // TODO: 用户调整旋转角度和是否镜像，适配Atlas 镜头，目前宽和高400*640，其他摄像头需要动态调整,人脸72 个关键点x 坐标向左移动80个像素点
                                                    float[] depthLandmark = new float[faceInfos[0].landmarks.length];
                                                    BDFaceImageInstance depthInstance;
                                                    if (bdFaceCheckConfig.cameraType == 1) {
                                                        System.arraycopy(
                                                            faceInfos[0].landmarks,
                                                            0,
                                                            depthLandmark,
                                                            0,
                                                            faceInfos[0].landmarks.length);
                                                        for (int i = 0; i < 144; i = i + 2) {
                                                            depthLandmark[i] -= 80;
                                                        }
                                                        fastFaceInfos[0].landmarks = depthLandmark;
                                                    }

                                                    depthInstance = getBdImage(depthBDFaceImageConfig, false);
                                                    livenessModel.setBdDepthFaceImageInstance(depthInstance.getImage());
                                                    // 创建检测对象，如果原始数据Depth
                                                    long startDepthTime = System.currentTimeMillis();
                                                    boolean depthLiveStatus =
                                                        faceModel
                                                            .getFaceLive()
                                                            .strategySilentLive(
                                                                BDFaceSDKCommon.LiveType.BDFACE_SILENT_LIVE_TYPE_DEPTH,
                                                                depthInstance,
                                                                fastFaceInfos[0],
                                                                bdLiveConfig.framesThreshold,
                                                                bdLiveConfig.nirLiveScore);
                                                    livenessModel.setDepthLiveStatus(depthLiveStatus);
                                                    livenessModel.setDepthtLivenessDuration(
                                                        System.currentTimeMillis() - startDepthTime);
                                                    depthInstance.destory();
                                                }
                                                // 流程结束,记录最终时间
                                                livenessModel.setAllDetectDuration(
                                                    System.currentTimeMillis() - startTime);
                                                //                LogUtils.e(TIME_TAG, "all process time = " + livenessModel.getAllDetectDuration());
                                                // 流程结束销毁图片，开始下一帧图片检测，否着内存泄露

                                                // 显示最终结果提示
                                                if (faceDetectCallBack != null) {
                                                    faceDetectCallBack.onFaceDetectCallback(livenessModel);
                                                }
                                            }

                                            @Override
                                            public void onQualityFail(String detectFail, String occlusionFail) {
                                                livenessModel.setQualityOcclusion(occlusionFail);
                                                livenessModel.setQualityDetect(detectFail);
                                                livenessModel.setQualityCheck(true);

                                                if (faceDetectCallBack != null) {
                                                    faceDetectCallBack.onFaceDetectCallback(livenessModel);
                                                }
                                            }
                                        });
                                }

                                @Override
                                public void onDetectFail() {

                                    if (faceDetectCallBack != null) {
                                        faceDetectCallBack.onFaceDetectCallback(livenessModel);
                                    }
                                }
                            });
                    }
                });
    }

    private void onTrack(BDFaceImageInstance rgbInstance, LivenessModel livenessModel, DetectListener detectListener) {

        long startDetectTime = System.currentTimeMillis();

        livenessModel.setRgbDetectDuration(System.currentTimeMillis() - startDetectTime);
        // track
        FaceInfo[] faceInfos = null;
        // 多人采用检测，不能跟踪
        if (isMultiIdentify){
            faceInfos = getDetectCheck(rgbInstance);
        }
        else{
            faceInfos = getTrackCheck(rgbInstance);
        }

        // 检测结果判断
        if (faceInfos == null || faceInfos.length == 0) {
            detectListener.onDetectFail();
            return;
        }
        livenessModel.setTrackFaceInfo(faceInfos);
        //  livenessModel.setFaceInfo(faceInfos[0]);
        // 修改为返回多人脸框
        //  livenessModel.setFaceInfos(faceInfos);
        livenessModel.setFaceInfos(faceInfos);
        livenessModel.setTrackLandmarks(faceInfos[0].landmarks);

        livenessModel.setTrackStatus(1);

        //  detectListener.onDetectSuccess(faceInfos, rgbInstance);
        detectListener.onDetectSuccess(faceInfos, rgbInstance);

        /*  if (size > 0) {
            byte[] featureArr1 = new byte[512];
            byte[] featureArr2 = new byte[512];

            float featureSize = faceModel.getFaceFeature().feature(
                    BDFaceSDKCommon.FeatureType.BDFACE_FEATURE_TYPE_LIVE_PHOTO, rgbInstance, new_faceInfos[0].landmarks, featureArr1);

            Log.d("Attend", "compare_score1111:" + featureSize);
            featureSize = faceModel.getFaceFeature().feature(
                    BDFaceSDKCommon.FeatureType.BDFACE_FEATURE_TYPE_LIVE_PHOTO, rgbInstance, new_faceInfos[0].landmarks, featureArr1);

            Log.d("Attend", "compare_score2222:" + featureSize);
            FaceSearch faceSearch = new FaceSearch();
            float featureScore = faceSearch.compare(
                    BDFaceSDKCommon.FeatureType.BDFACE_FEATURE_TYPE_LIVE_PHOTO,
                    featureArr1,
                    featureArr2,
                    true);
            Log.d("Attend", "compare_score:" + featureScore);
        } */

    }

    /**
     * 质量检测结果过滤，如果需要质量检测，
     * 需要调用 SingleBaseConfig.getBaseConfig().setQualityControl(true);设置为true，
     * 再调用  FaceSDKManager.getInstance().initConfig() 加载到底层配置项中
     *
     * @param faceInfos
     * @param faceInfos
     * @param faceDetectCallBack
     * @return
     */
    public void onQualityCheck(
        final FaceInfo[] faceInfos,
        final BDQualityConfig bdQualityConfig,
        final FaceDetectCallBack faceDetectCallBack,
        final QualityListener qualityListener) {

        if (bdQualityConfig == null) {
            qualityListener.onQualitySuccess();
            return;
        }
        // 检测结果过滤
        // 角度过滤

        boolean checkQualityOk = true;
        String detectFail = "";
        String occlusionFail = "";
        if (faceInfos != null) {
            int size = faceInfos.length;

            for (int i = 0; i < size; i++) {
                StringBuffer stringBufferDetected = new StringBuffer();
                StringBuffer stringBufferOcclusion = new StringBuffer();

                FaceInfo faceInfo = faceInfos[i];

                // 角度过滤
                if (Math.abs(faceInfo.yaw) > bdQualityConfig.gesture) {
                    faceDetectCallBack.onTip(-1, "人脸左右偏转角超出限制");
                    stringBufferDetected.append("人脸左右偏转角超出限制");
                } else if (Math.abs(faceInfo.roll) > bdQualityConfig.gesture) {
                    faceDetectCallBack.onTip(-1, "人脸平行平面内的头部旋转角超出限制");
                    stringBufferDetected.append("人脸平行平面内的头部旋转角超出限制");
                } else if (Math.abs(faceInfo.pitch) > bdQualityConfig.gesture) {
                    faceDetectCallBack.onTip(-1, "人脸上下偏转角超出限制");
                    stringBufferDetected.append("人脸上下偏转角超出限制");
                }

                // 模糊结果过滤
                float blur = faceInfo.bluriness;
                if (blur > bdQualityConfig.blur) {
                    faceDetectCallBack.onTip(-1, "图片模糊");
                    stringBufferDetected.append("图片模糊");
                }

                // 光照结果过滤
                float illum = faceInfo.illum;
                Log.e("illum", "illum = " + illum);
                if (illum < bdQualityConfig.illum) {
                    faceDetectCallBack.onTip(-1, "图片光照不通过");
                    stringBufferDetected.append("图片光照不通过");
                }

                if (!checkMouthMask) {
                    // 遮挡结果过滤
                    if (faceInfo.occlusion != null) {
                        BDFaceOcclusion occlusion = faceInfo.occlusion;

                        if (occlusion.leftEye > bdQualityConfig.leftEye) {
                            // 左眼遮挡置信度
                            faceDetectCallBack.onTip(-1, "左眼遮挡");
                            stringBufferOcclusion.append("左眼遮挡");
                        } else if (occlusion.rightEye > bdQualityConfig.rightEye) {
                            // 右眼遮挡置信度
                            faceDetectCallBack.onTip(-1, "右眼遮挡");
                            stringBufferOcclusion.append("右眼遮挡");
                        } else if (occlusion.nose > bdQualityConfig.nose) {
                            // 鼻子遮挡置信度
                            faceDetectCallBack.onTip(-1, "鼻子遮挡");
                            stringBufferOcclusion.append("鼻子遮挡");
                        } else if (occlusion.mouth > bdQualityConfig.mouth) {
                            // 嘴巴遮挡置信度
                            faceDetectCallBack.onTip(-1, "嘴巴遮挡");
                            stringBufferOcclusion.append("嘴巴遮挡");
                        } else if (occlusion.leftCheek > bdQualityConfig.leftCheek) {
                            // 左脸遮挡置信度
                            faceDetectCallBack.onTip(-1, "左脸遮挡");
                            stringBufferOcclusion.append("左脸遮挡");
                        } else if (occlusion.rightCheek > bdQualityConfig.rightCheek) {
                            // 右脸遮挡置信度
                            faceDetectCallBack.onTip(-1, "右脸遮挡");
                            stringBufferOcclusion.append("右脸遮挡");
                        } else if (occlusion.chin > bdQualityConfig.chinContour) {
                            // 下巴遮挡置信度
                            faceDetectCallBack.onTip(-1, "下巴遮挡");
                            stringBufferOcclusion.append("下巴遮挡");
                        }
                    }
                }
                if (!TextUtils.isEmpty(stringBufferDetected.toString())
                    || !TextUtils.isEmpty(stringBufferOcclusion.toString())) {
                    if (!TextUtils.isEmpty(stringBufferDetected.toString())) {
                        detectFail = stringBufferDetected.toString();
                    }
                    if (!TextUtils.isEmpty(stringBufferOcclusion.toString())) {
                        occlusionFail = stringBufferOcclusion.toString();
                    }
                    checkQualityOk = false;
                }
            }
        }
        if (checkQualityOk) {
            qualityListener.onQualitySuccess();
            return;
        }
        qualityListener.onQualityFail(detectFail, occlusionFail);
    }
    /**
     * 质量检测结果过滤，如果需要质量检测，
     * 需要调用 SingleBaseConfig.getBaseConfig().setQualityControl(true);设置为true，
     * 再调用  FaceSDKManager.getInstance().initConfig() 加载到底层配置项中
     *
     * @param faceInfos
     * @param faceInfos
     * @param faceDetectCallBack
     * @return
     */
    public boolean onQualityCheck(
        final FaceInfo[] faceInfos,
        final BDQualityConfig bdQualityConfig,
        final FaceDetectCallBack faceDetectCallBack) {

        if (bdQualityConfig == null) {
            return true;
        }
        boolean qualityCheck = false;
        if (faceInfos != null) {
            int size = faceInfos.length;
            for (int i = 0; i < size; ++i) {
                FaceInfo faceInfo = faceInfos[i];
                boolean checkItem = true;
                // 角度过滤
                if (Math.abs(faceInfo.yaw) > bdQualityConfig.gesture) {
                    faceDetectCallBack.onTip(-1, "人脸左右偏转角超出限制");
                    checkItem = false;
                } else if (Math.abs(faceInfo.roll) > bdQualityConfig.gesture) {
                    faceDetectCallBack.onTip(-1, "人脸平行平面内的头部旋转角超出限制");
                    checkItem = false;
                } else if (Math.abs(faceInfo.pitch) > bdQualityConfig.gesture) {
                    faceDetectCallBack.onTip(-1, "人脸上下偏转角超出限制");
                    checkItem = false;
                }

                // 模糊结果过滤
                float blur = faceInfo.bluriness;
                if (blur > bdQualityConfig.blur) {
                    faceDetectCallBack.onTip(-1, "图片模糊");
                    checkItem = false;
                }

                // 光照结果过滤
                float illum = faceInfo.illum;
                Log.e("illum", "illum = " + illum);
                if (illum < bdQualityConfig.illum) {
                    faceDetectCallBack.onTip(-1, "图片光照不通过");
                    checkItem = false;
                }

                // 口罩识别不进行质量判断
                if (!checkMouthMask) {
                    // 遮挡结果过滤
                    if (faceInfo.occlusion != null) {
                        BDFaceOcclusion occlusion = faceInfo.occlusion;

                        if (occlusion.leftEye > bdQualityConfig.leftEye) {
                            // 左眼遮挡置信度
                            faceDetectCallBack.onTip(-1, "左眼遮挡");
                            checkItem = false;
                        } else if (occlusion.rightEye > bdQualityConfig.rightEye) {
                            // 右眼遮挡置信度
                            faceDetectCallBack.onTip(-1, "右眼遮挡");
                            checkItem = false;
                        } else if (occlusion.nose > bdQualityConfig.nose) {
                            // 鼻子遮挡置信度
                            faceDetectCallBack.onTip(-1, "鼻子遮挡");
                            checkItem = false;
                        } else if (occlusion.mouth > bdQualityConfig.mouth) {
                            // 嘴巴遮挡置信度
                            faceDetectCallBack.onTip(-1, "嘴巴遮挡");
                            checkItem = false;
                        } else if (occlusion.leftCheek > bdQualityConfig.leftCheek) {
                            // 左脸遮挡置信度
                            faceDetectCallBack.onTip(-1, "左脸遮挡");
                            checkItem = false;
                        } else if (occlusion.rightCheek > bdQualityConfig.rightCheek) {
                            // 右脸遮挡置信度
                            faceDetectCallBack.onTip(-1, "右脸遮挡");
                            checkItem = false;
                        } else if (occlusion.chin > bdQualityConfig.chinContour) {
                            // 下巴遮挡置信度
                            faceDetectCallBack.onTip(-1, "下巴遮挡");
                        }
                    }
                }
                else{
                    return true;
                }

                if (checkItem) {
                    qualityCheck = true;
                    return qualityCheck;
                }
            }
        }
        return qualityCheck;
    }

    /**
     * 质量检测结果过滤，如果需要质量检测，
     * 需要调用 SingleBaseConfig.getBaseConfig().setQualityControl(true);设置为true，
     * 再调用  FaceSDKManager.getInstance().initConfig() 加载到底层配置项中
     *
     * @param faceInfo
     * @param faceInfo
     * @param faceDetectCallBack
     * @return
     */
    public boolean onPersonQualityCheck(
        final FaceInfo faceInfo, final BDQualityConfig bdQualityConfig, final FaceDetectCallBack faceDetectCallBack) {

        if (bdQualityConfig == null) {
            return true;
        }

        if (faceInfo != null) {

            // 角度过滤
            if (Math.abs(faceInfo.yaw) > bdQualityConfig.gesture) {
                faceDetectCallBack.onTip(-1, "人脸左右偏转角超出限制");
                return false;
            } else if (Math.abs(faceInfo.roll) > bdQualityConfig.gesture) {
                faceDetectCallBack.onTip(-1, "人脸平行平面内的头部旋转角超出限制");
                return false;
            } else if (Math.abs(faceInfo.pitch) > bdQualityConfig.gesture) {
                faceDetectCallBack.onTip(-1, "人脸上下偏转角超出限制");
                return false;
            }

            // 模糊结果过滤
            float blur = faceInfo.bluriness;
            if (blur > bdQualityConfig.blur) {
                faceDetectCallBack.onTip(-1, "图片模糊");
                return false;
            }

            // 光照结果过滤
            float illum = faceInfo.illum;
            Log.e("illum", "illum = " + illum);
            if (illum < bdQualityConfig.illum) {
                faceDetectCallBack.onTip(-1, "图片光照不通过");
                return false;
            }

            // 口罩识别不进行质量判断
            if (!checkMouthMask) {
                // 遮挡结果过滤
                if (faceInfo.occlusion != null) {
                    BDFaceOcclusion occlusion = faceInfo.occlusion;

                    if (occlusion.leftEye > bdQualityConfig.leftEye) {
                        // 左眼遮挡置信度
                        faceDetectCallBack.onTip(-1, "左眼遮挡");
                    } else if (occlusion.rightEye > bdQualityConfig.rightEye) {
                        // 右眼遮挡置信度
                        faceDetectCallBack.onTip(-1, "右眼遮挡");
                    } else if (occlusion.nose > bdQualityConfig.nose) {
                        // 鼻子遮挡置信度
                        faceDetectCallBack.onTip(-1, "鼻子遮挡");
                    } else if (occlusion.mouth > bdQualityConfig.mouth) {
                        // 嘴巴遮挡置信度
                        faceDetectCallBack.onTip(-1, "嘴巴遮挡");
                    } else if (occlusion.leftCheek > bdQualityConfig.leftCheek) {
                        // 左脸遮挡置信度
                        faceDetectCallBack.onTip(-1, "左脸遮挡");
                    } else if (occlusion.rightCheek > bdQualityConfig.rightCheek) {
                        // 右脸遮挡置信度
                        faceDetectCallBack.onTip(-1, "右脸遮挡");
                    } else if (occlusion.chin > bdQualityConfig.chinContour) {
                        // 下巴遮挡置信度
                        faceDetectCallBack.onTip(-1, "下巴遮挡");
                    } else {
                        return true;
                    }
                }
            }
        }
        return false;
    }

    /**
     * 检测-活体-特征- 全流程
     * bluriness 模糊得分
     * leftEye  左眼遮擋得分
     * rightEye 右眼遮擋得分
     * nose     鼻子遮擋得分
     * mouth    嘴巴遮擋得分
     * leftCheek 左臉眼遮擋得分
     * rightCheek 右臉遮擋得分
     */
    private boolean selectQuality(
        float bluriness,
        float leftEye,
        float rightEye,
        float nose,
        float mouth,
        float leftCheek,
        float rightCheek,
        float chin) {

        return bluriness < 0.5
            && leftEye < 0.75
            && rightEye < 0.75
            && nose < 0.75
            && mouth < 0.75
            && leftCheek < 0.75
            && rightCheek < 0.75
            && chin < 0.7;
    }

    // 人证核验特征提取
    public float personDetect(
        final Bitmap bitmap, final byte[] feature, final BDFaceCheckConfig bdFaceCheckConfig, Context context) {
        if(bitmap==null||bitmap.isRecycled()){
            return -1;
        }
        BDFaceImageInstance rgbInstance = new BDFaceImageInstance(bitmap);
        float ret = -1;
        FaceInfo[] faceInfos;
        BDQualityConfig bdQualityConfig = bdFaceCheckConfig == null ? null : bdFaceCheckConfig.bdQualityConfig;
        if (bdFaceCheckConfig != null) {
            bdFaceCheckConfig.bdFaceDetectListConfig.usingDetect = true;
            faceInfos =
                faceModel
                    .getFaceDetectPerson()
                    .detect(
                        BDFaceSDKCommon.DetectType.DETECT_VIS,
                        BDFaceSDKCommon.AlignType.BDFACE_ALIGN_TYPE_RGB_ACCURATE,
                        rgbInstance,
                        null,
                        bdFaceCheckConfig.bdFaceDetectListConfig);
        } else {
            faceInfos = faceModel.getFaceDetectPerson().detect(BDFaceSDKCommon.DetectType.DETECT_VIS, rgbInstance);
        }
        if (faceInfos != null && faceInfos.length > 0) {
            // 判断质量检测，针对模糊度、遮挡、角度
            if (onPersonQualityCheck(faceInfos[0], bdQualityConfig, new FaceQualityBack(context))) {
                ret =
                    faceModel
                        .getFacePersonFeature()
                        .feature(
                            BDFaceSDKCommon.FeatureType.BDFACE_FEATURE_TYPE_LIVE_PHOTO,
                            rgbInstance,
                            faceInfos[0].landmarks,
                            feature);
            }
        } else {

            return -1;
        }

        return ret;
    }
}