void initLicenseOnLine(final Context context, final String licenseKey, final AuthCallback callback)

 void initLicenseOffLine(final Context context, final Callback callback)

void initLicenseBatchLine(final Context context, final String licenseKey, final Callback callback)

void setActiveLog(BDFaceSDKCommon.BDFaceLogInfo logInfo, int isLog)

setCoreConfigure(BDFaceSDKCommon.BDFaceCoreRunMode runMode, int coreNum)

// 无参构造调用（执行默认创建的instance ）
public FaceDetect()
// 有参构造调用（执行自己创建的instance ）
public FaceDetect(BDFaceInstance thisBdFaceInstance)

void initModel(final Context context, final String visModel,final String nirModel,final String alignModel, final Callback callback)

public void initModel(final Context context,final String detectModel,final String alignModel,final BDFaceSDKCommon.DetectType detectType,final BDFaceSDKCommon.AlignType alignType,final Callback callback)

void initQuality(final Context context, final String blurModel, final String occlurModel, final Callback callback)

void initAttrbute(final Context context, final String atttibuteModel, final Callback callback)

void initFaceClose(final Context context,
 final String eyecloseModel,final String mouthcloseModel,final Callback callback)

void initBestImage(final Context context,final String bestModel,final Callback callback)

void loadConfig(BDFaceSDKConfig config)

FaceInfo[] detect(BDFaceSDKCommon.DetectType type,BDFaceImageInstance imageInstance)

FaceInfo[] detect(BDFaceSDKCommon.DetectType type,BDFaceSDKCommon.AlignType alignType, BDFaceImageInstance imageInstance,FaceInfo[] faceInfos,BDFaceDetectListConf bdFaceDetectListConfig)

FaceInfo[] track(DetectType detectType, BDFaceImageInstance imageInstance)

FaceInfo[] track(BDFaceSDKCommon.DetectType detectType, BDFaceSDKCommon.AlignType alignType,BDFaceImageInstance imageInstance)

public BDFaceImageInstance cropFace(BDFaceImageInstance imageInstance, float[] landmark)

BDFaceImageInstance

void uninitModel()

void initMouthMask(final Context context, final String mouthMaskModel, final Callback callback)

// 无参构造调用（执行默认创建的instance ）
public FaceLive()
// 有参构造调用（执行自己创建的instance ）
public FaceLive(BDFaceInstance thisBdFaceInstance)

void initModel(final Context context, final String visModel, final String vis2dmaskModel, final String visHandModel, final String visReflectionModel, final String nirModel, final String depthModel, final Callback callback)

public float silentLive(LiveType type, BDFaceImageInstance bdFaceImageInstance, float[] landmarks)

void uninitModel()

// 无参构造调用（执行默认创建的instance ）
public FaceFeature() 
// 有参构造调用（执行自己创建的instance ）
public FaceFeature(BDFaceInstance thisBdFaceInstance) 

initModel(final Context context,final String idPhotoModel,final String visModel,final String nirModel,final Callback callback)

initModel(final Context context,final String idPhotoModel,final String visModel,final String nirModel,final String rgbdModel, final Callback callback)

float feature(FeatureType featureType, BDFaceImageInstance imageInstance,float[] landmarks, byte[] feature) 

float featureRGBD(FeatureType featureType, BDFaceImageInstance imageInstance,BDFaceImageInstance imageInstance_depth, float[] landmarks, byte[] feature)

float compare(FeatureType featureType, byte[] feature1, byte[] feature2, boolean isPercent)

public int pushPersonById(int pointID, byte[] feature)

public List<? extends Feature> search(BDFaceSDKCommon.FeatureType featureType,
                                          float threshold,
                                          int topNum,
                                          byte[] feature,
                                          boolean isPercent)

void uninitModel()

BDFaceImageInstance(byte[] data, int height, int width,BDFaceSDKCommon.BDFaceImageType imageType, float angle, int isMbyteArrayror)

BDFaceImageInstance(Bitmap bitmap)

BDFaceImageInstance(byte[] data, int height, int width,BDFaceSDKCommon.BDFaceImageType imageType, float angle, int isMbyteArrayror)

BDFaceImageInstance(Bitmap bitmap)

BDFaceImageInstance getImage()

int destory();

// 无参构造调用（执行默认创建的instance ）
public FaceGaze() 
// 有参构造调用（执行自己创建的instance ）
public FaceGaze(BDFaceInstance thisBdFaceInstance) 

public void initModel(final Context context, final String gazeModel, final Callback callback)

public BDFaceGazeInfo gaze(BDFaceImageInstance imageInstance, float[] landmarks)

void uninitGazeModel()

// 无参构造调用（执行默认创建的instance ）
FaceDriverMonitor()
// 有参构造调用（执行自己创建的instance ）
FaceDriverMonitor(BDFaceInstance thisBdFaceInstance)

void initDriverMonitor(final Context context, final String driverMonitorModel, final Callback callback)

void uninitDriverMonitor()

public BDFaceDriverMonitorInfo driverMonitor(BDFaceImageInstance imageInstance,
                                         FaceInfo faceinfo)

// 无参构造调用（执行默认创建的instance ）
FaceCrop()
// 有参构造调用（执行自己创建的instance ）
FaceCrop(BDFaceInstance thisBdFaceInstance)

void initFaceCrop(final Callback callback) 

int uninitFaceCrop()

public static BDFaceImageInstance cropFaceByBox(BDFaceImageInstance imageInstance, FaceInfo faceinfo, float enlargeRatio, AtomicInteger isOutofBoundary)

public BDFaceImageInstance cropFaceByLandmark(BDFaceImageInstance imageInstance,
                                                  float[] landmark,
                                                  float enlargeRatio,
                                                  boolean correction,
                                                  AtomicInteger isOutofBoundary)

// 无参构造调用（执行默认创建的instance ）
public FaceMouthMask() 
// 有参构造调用（执行自己创建的instance ）
public FaceMouthMask(BDFaceInstance thisBdFaceInstance) 

int initModel(final Context context, final String mouthMaskModel, final Callback callback)

float[] checkMask(BDFaceImageInstance imageInstance, FaceInfo[] faceInfos)

int uninitModel()

int imageIllum(BDFaceImageInstance imageInstance, AtomicInteger illumScore)

public void initFaceDarkEnhance(final Context context, final String FaceDarkEnhanceModel, final Callback callback)

public BDFaceImageInstance faceDarkEnhance(BDFaceImageInstance imageInstance)

public int uninitFaceDarkEnhance()

public class FaceInfo {

    /**
     * ---------detect---------**
     * 人脸索引值，标记连续视频帧追踪中人脸ID
     */
    public int faceID;

    /**
     * 人脸中心点x坐标
     */
    public float centerX;

    /**
     * 人脸中心点y坐标
     */
    public float centerY;

    /**
     * 人脸宽度
     */
    public float width;

    /**
     * 人脸高度
     */
    public float height;

    /**
     * 人脸角度
     */
    public float angle;

    /**
     * 人脸置信度
     */
    public float score;

    /**
     * 人脸72个关键点数据（鼻子，眼镜，嘴巴，眉毛）
     */
    public float[] landmarks;

    /** -------- config head pose ture------**/

    /**
     * 人脸左右偏转角
     */
    public float yaw;

    /**
     * 人脸平行平面内的头部旋转角
     */
    public float roll;

    /**
     * 人脸上下偏转角
     */
    public float pitch;

    /** ---------config quality blur illum occluton ture---------**/

    /**
     * 人脸模糊度信息
     */
    public float bluriness;

    /**
     * 人脸光照信息
     */
    public int illum;

    /**
     * 人脸遮挡信息
     */
    public BDFaceOcclusion occlusion;

	/**---------config Attribute ture-------**/

    /**
     * 人脸年龄
     */
    public int age;
    /**
     * 人脸种族（黄，白，黑，印度）
     */
    public BDFaceSDKCommon.BDFaceRace race;
    /**
     * 人脸佩戴眼镜状态（无眼镜，有眼镜，墨镜）
     */
    public BDFaceSDKCommon.BDFaceGlasses glasses;
    /**
     * 人脸性别（男女）状态
     */
    public BDFaceSDKCommon.BDFaceGender gender;
    /**
     * 人脸3种情绪(中性，微笑，大笑)
     */
    public BDFaceSDKCommon.BDFaceEmotion emotionThree;
    /**---------config emotion ture-------**/
    /**
     * 人脸7种情绪（生气，恶心，害怕，开心，伤心，惊讶，无情绪）
     */
    public BDFaceSDKCommon.BDFaceEmotionEnum emotionSeven;
     /**---------config isMouthClose ture-------**/

    /**
     * 嘴巴闭合置信度
     */
    public float mouthclose;

    /**---------config isEyeClose ture-------**/

    /**
     * 左眼闭合的置信度
     */
    public float leftEyeclose;
    /**
     * 右眼闭合的置信度
     */
    public float rightEyeclose;
    /**
     * 最优人脸得分
     */
    public float bestImageScore;
   
}

public class BDFaceSDKCommon {

    public enum BDFaceImageType {
        BDFACE_IMAGE_TYPE_RGB,
        BDFACE_IMAGE_TYPE_BGR,
        BDFACE_IMAGE_TYPE_RGBA,
        BDFACE_IMAGE_TYPE_BGRA,
        BDFACE_IMAGE_TYPE_GRAY,
        BDFACE_IMAGE_TYPE_DEPTH,
        BDFACE_IMAGE_TYPE_YUV_NV21, //  YYYYVUVU
        BDFACE_IMAGE_TYPE_YUV_NV12, // YYYYUVUV
        BDFACE_IMAGE_TYPE_YUV_YV12, // YYYYVVUU
    }

    // 检测类型
    public enum DetectType {
        DETECT_VIS,  // 可见光图像
        DETECT_NIR   // 红外图像
    }
    
    //  人脸关键点类型枚举
    public enum AlignType {
        BDFACE_ALIGN_TYPE_RGB_ACCURATE,   // 精确RGB对齐
        BDFACE_ALIGN_TYPE_RGB_FAST,       // 快速RGB对齐
        BDFACE_ALIGN_TYPE_NIR_ACCURATE,   // 精确NIR对齐
    }

    /**
     * 图片检测类型，目前支持红外，深度图，可见光
     */
    public enum LiveType {
        BDFACE_SILENT_LIVE_TYPE_RGB,
        BDFACE_SILENT_LIVE_TYPE_NIR,
        BDFACE_SILENT_LIVE_TYPE_DEPTH,
    }

    /**
     * 特征提取图片类型，证件照，可见光，红外，RGBD
     */
    public enum FeatureType {
        BDFACE_FEATURE_TYPE_LIVE_PHOTO,     // 生活照特征提取
        BDFACE_FEATURE_TYPE_ID_PHOTO,       // 证件照特征提取
        BDFACE_FEATURE_TYPE_NIR,            // 近红外特征提取
        BDFACE_FEATURE_TYPE_RGBD,           // RGBD特征提取
    }

    // 质量检测类型
    public enum FaceQualityType {
        BLUR,         // 模糊
        OCCLUSION,    // 遮挡
        ILLUMINATION  // 光照
    }
    
     // 表情类型
    public enum BDFaceEmotion {
        BDFACE_EMOTION_FROWN,           // 皱眉
        BDFACE_EMOTION_SMILE,           // 笑
        BDFACE_EMOTION_CALM,            // 平静
    }
    
    // 情绪
    public enum BDFaceEmotionEnum {
        BDFACE_EMOTIONS_ANGRY,          // 生气
        BDFACE_EMOTIONS_DISGUST,        // 恶心
        BDFACE_EMOTIONS_FEAR,           // 害怕
        BDFACE_EMOTIONS_HAPPY,          // 开心
        BDFACE_EMOTIONS_SAD,            // 伤心
        BDFACE_EMOTIONS_SURPRISE,       // 惊讶
        BDFACE_EMOTIONS_NEUTRAL,        // 无情绪
    }

    // 人脸属性种族
    public enum BDFaceRace {
        BDFACE_RACE_YELLOW,       // 黄种人
        BDFACE_RACE_WHITE,        // 白种人
        BDFACE_RACE_BLACK,        // 黑种人
        BDFACE_RACE_INDIAN,       // 印度人
    }

    // 戴眼镜状态
    public enum BDFaceGlasses {
        BDFACE_NO_GLASSES,   // 无眼镜
        BDFACE_GLASSES,      // 有眼镜
        BDFACE_SUN_GLASSES,  // 墨镜
    }

    // 性别
    public enum BDFaceGender {
        BDFACE_GENDER_FEMALE, // 女性
        BDFACE_GENDER_MALE,   // 男性
    }

    // 凝视方向
    public enum BDFaceGazeDirection {
        BDFACE_GACE_DIRECTION_UP,           // 向上看
        BDFACE_GACE_DIRECTION_DOWN,         // 向下看
        BDFACE_GACE_DIRECTION_RIGHT,        // 向右看
        BDFACE_GACE_DIRECTION_LEFT,         // 向左看
        BDFACE_GACE_DIRECTION_FRONT,        // 向前看
        BDFACE_GACE_DIRECTION_EYE_CLOSE,    // 闭眼
    }
    
    public enum BDFaceActionLiveType {
        BDFace_ACTION_LIVE_BLINK,           // 眨眨眼
        BDFACE_ACTION_LIVE_OPEN_MOUTH,      // 张张嘴
        BDFACE_ACTION_LIVE_NOD,             // 点点头
        BDFACE_ACTION_LIVE_SHAKE_HEAD,      // 摇摇头
        BDFACE_ACTION_LIVE_LOOK_UP,         // 抬头
        BDFACE_ACTION_LIVE_TURN_LEFT,       // 向左转
        BDFACE_ACTION_LIVE_TURN_RIGHT,      // 向右转
    }

    /**
     * log种类枚举
     */
    public enum BDFaceLogInfo {
        BDFACE_LOG_ERROR_MESSAGE,   // 打印输出错误日志
        BDFACE_LOG_VALUE_MESSAGE,   // 打印输出值日志
        BDFACE_LOG_TYPE_PERF,   //打印输出性能日志
        BDFACE_LOG_TYPE_ALL,   //打印输出全部日志
        BDFACE_LOG_TYPE_DEBUG,    //打印输出debug日志
    }

    public enum BDFaceCoreRunMode {
        BDFACE_LITE_POWER_HIGH,      //大核运行模式
        BDFACE_LITE_POWER_LOW,       //  小核运行模式
        BDFACE_LITE_POWER_FULL,      // 大小核混用模式
        BDFACE_LITE_POWER_NO_BIND,   // 不绑核运行模式 （推荐）
        BDFACE_LITE_POWER_RAND_HIGH, // 轮流绑定大核模式
        BDFACE_LITE_POWER_RAND_LOW   // 轮流绑定小核模式
    }
}	

   public class BDFaceOcclusion {
    public float leftEye;    // 左眼遮挡置信度
    public float rightEye;   // 右眼遮挡置信度
    public float nose;        // 鼻子遮挡置信度
    public float mouth;       // 嘴巴遮挡置信度
    public float leftCheek;  // 左脸遮挡置信度
    public float rightCheek; // 右脸遮挡置信度
    public float chin;        // 下巴遮挡置信度
    } 

public class BDFaceSDKConfig {

    /**
     * 输入图像的缩放系数
     */
    public float scaleRatio = -1;

    /**
     * 需要检测的最大人脸数目
     */
    public int maxDetectNum = 10;

    /**
     * 需要检测的最小人脸大小
     */
    public int minFaceSize = 0;

    /**
     * 人脸置信度阈值（检测分值大于该阈值认为是人脸）
     * RGB
     */
    public float notRGBFaceThreshold = 0.5f;
    /**
     * 人脸置信度阈值（检测分值大于该阈值认为是人脸）
     * NIR
     */
    public float notNIRFaceThreshold = 0.5f;

    /**
     * 未跟踪到人脸前的检测时间间隔
     */
    public float detectInterval = 0;

    /**
     * 已跟踪到人脸后的检测时间间隔
     */
    public float trackInterval = 500;

    /**
     * 质量检测模糊，默认不做质量检测
     */
    public boolean isCheckBlur = false;

    /**
     * 质量检测遮挡，默认不做质量检测
     */
    public boolean isOcclusion = false;

    /**
     * 质量检测光照，默认不做质量检测
     */
    public boolean isIllumination = false;

    /**
     * 姿态角检测，获取yaw(左右偏转角)，roll(人脸平行平面内的头部旋转角)，pitch(上下偏转角),默认不检测
     */
    public boolean isHeadPose = false;

   /**
     * 属性检查，获取年龄，种族，是否戴眼镜等信息，默认不检测
     */
    public boolean isAttribute = false;

    /**
     * 7种情绪信息获取，默认不检测（3.2及以下版本不支持）
     */
    private boolean isEmotion = false;

    /**
     * 是否扣图，默认不扣图（3.2及以下版本不支持）
     */
    public boolean isCropFace = false;

    /**
     * 是否检测眼睛闭合，默认不检测
     */
    private boolean isEyeClose = false;

    /**
     * 是否检测嘴巴闭合，默认不检测
     */
    private boolean isMouthClose = false;
    
    /**
     * 是否检测最优人脸，默认不检测
     */
    public boolean isBestImage = false;

}

public class Feature {
    private int id;
    private String faceToken = "";
    private byte[] feature;
    private String userId = "";
    private String groupId = "";
    private long ctime;
    private long updateTime;
    private String imageName = "";
    private String userName = "";
    private String cropImageName = "";
    private boolean isChecked;
    private float score;
}

   public class BDFaceGazeInfo {
    public float leftEyeConf;                    // 左眼的置信度
    public float rightEyeConf;                   // 右眼的置信度
    public float softmaxEyeConf;                 
    public BDFaceGazeDirection leftEyeGaze;      // 左眼的注意力信息
    public BDFaceGazeDirection rightEyeGaze;     // 右眼的注意力信息
    public BDFaceGazeDirection softmaxEyeGaze;   
    } 

   public class BDFaceDetectListConf {
    /**
     * 检测（在track 精度不足时开启）默认不做检测
     */
    public boolean usingDetect = false;
    /**
     * 检测（在track 精度不足时开启）默认开启对齐
     */
    public boolean usingAlign = true;
    /**
     * 质量检测模糊，默认不做质量检测
     */
    public boolean usingQuality = false;
    /**
     * 姿态角检测，获取yaw(左右偏转角)，roll(人脸平行平面内的头部旋转角)，pitch(上下偏转角),默认不检测
     */
    public boolean usingHeadPose = false;
    /**
     * 属性检查，获取年龄，种族，是否戴眼镜等信息，默认不检测
     */
    public boolean usingAttribute = false;
    /**
     * 7种情绪信息获取，默认不检测
     */
    public boolean usingEmotion = false;
    /**
     * 是否检测眼睛闭合，默认不检测
     */
    public boolean usingEyeClose = false;
    /**
     * 是否检测嘴巴闭合，默认不检测
     */
    public boolean usingMouthClose = false;
    /**
     * 是否检测最优人脸，默认不检测
     */
    public boolean usingBestImage = false;
    /**
     * 是否检测戴口罩，默认不检测
     */
    public boolean usingMouthMask = false;
    } 

public class BDFaceDriverMonitorInfo {
    float normal = 0;    // 行为正常
    float calling = 0;   // 打电话
    float drinking = 0;  // 喝水
    float eating = 0;    // 吃东西
    float smoking = 0;   // 抽烟
}

public void init(final Context context, final SdkInitListener listener)

FaceSDKManager.getInstance().init(mContext, new SdkInitListener())

public void initModel(final Context context, BDFaceSDKConfig config, boolean isLog, final SdkInitListener listener)

 FaceSDKManager.getInstance().initModel(mContext, new SdkInitListener())

 public void initLicenseOnLine(final Context context, final String licenseID, final Callback callback) 

FaceAuth faceAuth = new FaceAuth();
faceAuth.initLicenseOnLine(context, licenseID, new callback)

 public void initLicenseOffLine(final Context context, final Callback callback)

FaceAuth faceAuth = new FaceAuth();
faceAuth.initLicenseOffLine(context, licenseID, new callback)

public void initLicenseBatchLine(final Context context, final String licenseKey, final Callback callback) 

FaceAuth faceAuth = new FaceAuth();
faceAuth.initLicenseBatchLine(context, licenseKey, new callback)

    private void faceDetect(byte[] data, final int width, final int height) {

        FaceSDKManager.getInstance().onDetectCheck(bdFaceImageConfig, null, null,
                bdFaceCheckConfig , new FaceDetectCallBack() {
                    @Override
                    public void onFaceDetectCallback(LivenessModel livenessModel) {
                        // 输出结果

                        checkFaceBound(livenessModel);
                    }

                    @Override
                    public void onTip(final int code, String msg) {
                        runOnUiThread(new Runnable() {
                            @Override
                            public void run() {
                                if (mFaceRoundProView == null) {
                                    return;
                                }
                                if (code == 0){
                                    mFaceRoundProView.setTipText("请保持面部在取景框内");
                                    mFaceRoundProView.setBitmapSource(R.mipmap.ic_loading_grey , false);
                                }else {
                                    mFaceRoundProView.setTipText("请保证人脸区域清晰无遮挡");
                                    mFaceRoundProView.setBitmapSource(R.mipmap.ic_loading_blue , true);
                                }
                            }
                        });
                    }

                    @Override
                    public void onFaceDetectDarwCallback(LivenessModel livenessModel) {
                        showFrame(livenessModel);
                    }
                });
    }

    private void checkLiveScore(LivenessModel livenessModel) {
        if (livenessModel == null || livenessModel.getFaceInfo() == null) {
            mFaceRoundProView.setTipText("请保持面部在取景框内");
            return;
        }

        // 获取活体类型
        int liveType = SingleBaseConfig.getBaseConfig().getType();
        // int liveType = 2;

        if (livenessModel.isQualityCheck()){
            mFaceRoundProView.setTipText("请保证人脸区域清晰无遮挡");
            mFaceRoundProView.setBitmapSource(R.mipmap.ic_loading_blue , true);
            return;
        } else if (bdLiveConfig == null) {         // 无活体
            getFeatures(livenessModel);
        } else { // RGB活体检测
            float rgbLivenessScore = livenessModel.getRgbLivenessScore();
            float liveThreadHold = SingleBaseConfig.getBaseConfig().getRgbLiveScore();
            // Log.e(TAG, "score = " + rgbLivenessScore);
            if (rgbLivenessScore < liveThreadHold) {
                mFaceRoundProView.setTipText("请保证采集对象为真人");
                mFaceRoundProView.setBitmapSource(R.mipmap.ic_loading_blue , true);
                return;
            }
            // 提取特征值
            getFeatures(livenessModel);
        }
    }

    private void displayCompareResult(float ret, byte[] faceFeature, LivenessModel model) {
        if (model == null) {
            mFaceRoundProView.setTipText("请保持面部在取景框内");
            mFaceRoundProView.setBitmapSource(R.mipmap.ic_loading_grey , false);
            return;
        }

        // 特征提取成功
        if (ret == 128) {
            // 抠图
            BDFaceImageInstance cropInstance =
                    FaceSDKManager.getInstance().getCopeFace(
                           BitmapUtils.getInstaceBmp(model.getBdFaceImageInstance()) ,
                            model.getLandmarks(),
                            0
                    ); ;
            if (cropInstance == null) {
                mFaceRoundProView.setTipText("抠图失败");
                mFaceRoundProView.setBitmapSource(R.mipmap.ic_loading_blue , true);
                return;
            }
            mCropBitmap = BitmapUtils.getInstaceBmp(cropInstance);
            // 获取头像
            if (mCropBitmap != null) {
                mCollectSuccess = true;
                mCircleHead.setImageBitmap(mCropBitmap);
            }
            cropInstance.destory();

            mRelativeCollectSuccess.setVisibility(View.VISIBLE);
            mRelativePreview.setVisibility(View.GONE);
            mFaceRoundProView.setTipText("");

            for (int i = 0; i < faceFeature.length; i++) {
                mFeatures[i] = faceFeature[i];
            }
        } else {
            mFaceRoundProView.setTipText("特征提取失败");
            mFaceRoundProView.setBitmapSource(R.mipmap.ic_loading_blue , true);
        }
    }

String userName = mEditName.getText().toString();
// 姓名过滤
String nameResult = FaceApi.getInstance().isValidName(userName);
if (!"0".equals(nameResult)) {
    ToastUtils.toast(getApplicationContext(), nameResult);
    return;
}
String imageName = userName + ".jpg";
// 注册到人脸库
boolean isSuccess = FaceApi.getInstance().registerUserIntoDBmanager(null,userName, imageName, null, mFeatures);
if (isSuccess) {
    // 保存人脸图片
    File faceDir = FileUtils.getBatchImportSuccessDirectory();
    File file = new File(faceDir, imageName);
    FileUtils.saveBitmap(file, mCropBitmap);
    // 数据变化，更新内存
    // FaceSDKManager.getInstance().initDatabases();
    // 更新UI
    mRelativeCollectSuccess.setVisibility(View.GONE);
    mRelativeRegisterSuccess.setVisibility(View.VISIBLE);
    mCircleRegSucHead.setImageBitmap(mCropBitmap);
} else {
    ToastUtils.toast(getApplicationContext(), "保存数据库失败，" +"可能是用户名格式不正确");
}

public void startPreview(GlMantleSurfacView textureView, int videoDirection ,int width, int height)  

// 设置相机的ID
if (SingleBaseConfig.getBaseConfig().getRBGCameraId() != -1) {
    CameraPreviewManager.getInstance().setCameraFacing(SingleBaseConfig.getBaseConfig().getRBGCameraId());
} else {
    CameraPreviewManager.getInstance().setCameraFacing(CameraPreviewManager.CAMERA_USB);
}
// 开启预览
CameraPreviewManager.getInstance().startPreview(glMantleSurfacView,
    SingleBaseConfig.getBaseConfig().getRgbVideoDirection() , PREFER_WIDTH, PERFER_HEIGH);

public void onDetectCheck(final BDFaceImageConfig bdFaceImageConfig, 
                  final BDFaceImageConfig bdNirFaceImageConfig,
                  final BDFaceImageConfig bdDepthFaceImageConfig, 
                  final BDFaceCheckConfig bdFaceCheckConfig,
                  final FaceDetectCallBack faceDetectCallBack)

FaceSDKManager.getInstance().onDetectCheck(data, null, null,height, width, mLiveTyenew, FaceDetectCallBack()

public void onDetectCheck(final byte[] rgbData,
                              final byte[] nirData,
                              final byte[] depthData,
                              final int srcHeight,
                              final int srcWidth,
                              final int liveCheckMode,
                              final FaceDetectCallBack faceDetectCallBack) 

FaceSDKManager.getInstance().onDetectCheck(rgbData, irData, null, PERFER_HEIGH, PREFER_WIDTH, 3, new FaceDetectCallBack())

public void onDetectCheck(final byte[] rgbData,
                              final byte[] nirData,
                              final byte[] depthData,
                              final int srcHeight,
                              final int srcWidth,
                              final int liveCheckMode,
                              final FaceDetectCallBack faceDetectCallBack) 

FaceSDKManager.getInstance().onDetectCheck(rgbData, null, depthData, RGB_HEIGHT, RGB_WIDTH, 4, new FaceDetectCallBack()

	// 走人脸SDK接口，通过人脸检测、特征提取拿到人脸特征值
    ret = FaceApi.getInstance().getFeature(bitmap, bytes, 
	   BDFaceSDKCommon.FeatureType.BDFACE_FEATURE_TYPE_LIVE_PHOTO);
    LogUtils.i(TAG, "live_photo = " + ret);

public void batchImport();

	// 获取导入目录 /sdcard/Face-Import
    File batchImportDir = FileUtils.getBatchImportDirectory();

	// 遍历该目录下的所有文件
     File[] picFiles = batchImportDir.listFiles();
     if (picFiles == null || picFiles.length == 0) {
        Log.i(TAG, "导入数据的文件夹没有数据");
        if (mImportListener != null) {
            mImportListener.showToastMessage("导入数据的文件夹没有数据");
            }
            return;
        }

判断Face.zip是否存在的相关代码：

	// 判断Face.zip是否存在
    File zipFile = FileUtils.isFileExist(batchFaceDir.getPath(),
           "Face.zip");
    if (zipFile == null) {
        LogUtils.i(TAG, "导入数据的文件夹没有Face.zip");
        if (mImportListener != null) {
            mImportListener.showToastMessage("搜索失败，
                请检查操作步骤并重试");
        }
        return;
    }

	// 获取图片名
    String picName = picFiles[i].getName();
    // 判断图片后缀
    if (!picName.endsWith(".jpg") && !picName.endsWith(".png")) {
	    LogUtils.i(TAG, "图片后缀不满足要求");
        mFinishCount++;
        mFailCount++;
        // 更新进度
        updateProgress(mFinishCount, mSuccessCount, mFailCount,
	        ((float) mFinishCount / (float) mTotalCount));
        continue;
    }

	// 获取不带后缀的图片名
    String picNameNoEx = FileUtils.getFileNameNoEx(picName);
    // 通过既定的图片名格式，按照“-”分割，获取组名和用户名
    String[] picNames = picNameNoEx.split("-");
    // 如果分割失败，则该图片命名不满足要求
    if (picNames.length != 2) {
	    LogUtils.e(TAG, "图片命名格式不符合要求");
        mFinishCount++;
        mFailCount++;
        continue;
    }

根据姓名查询数据库与文件中对应的姓名是否相等，如果相等，则直接过滤

	// 根据姓名查询数据库与文件中对应的姓名是否相等，如果相等，则直接过滤
    List<User> listUsers = FaceApi.getInstance()
	    .getUserListByUserName(groupName, userName);
    if (listUsers != null && listUsers.size() > 0) {
	    LogUtils.i(TAG, "与之前图片名称相同");
        mFinishCount++;
        mFailCount++;
        // 更新进度
        updateProgress(mFinishCount, mSuccessCount, mFailCount,
	        ((float) mFinishCount / (float) mTotalCount));
        continue;
    }

	public boolean userDelete(String userId);

public boolean userUpdate(String userName, String imageName, byte[] feature);

final Bitmap bitmap = BitmapFactory.decodeStream(getContentResolver().openInputStream(uri1));
if (bitmap != null) {
    byte[] secondFeature = new byte[512];
    // 提取特征值
    float ret = FaceSDKManager.getInstance().personDetect(bitmap, secondFeature,
            FaceUtils.getInstance().getBDFaceCheckConfig() , this);
    // 提取特征值
    // 上传图片有人脸显示
    hintShowIv.setVisibility(View.VISIBLE);
    testimonyShowImg.setVisibility(View.VISIBLE);
    hintShowIv.setImageBitmap(bitmap);
    testimonyShowImg.setImageBitmap(bitmap);
    if (ret != -1) {
        isFace = false;
        // 判断质量检测，针对模糊度、遮挡、角度
        if (ret == 128) {
            bdFaceCheckConfig.setSecondFeature(secondFeature);
            toast("图片特征抽取成功");
            hintShowRl.setVisibility(View.VISIBLE);
            testimonyShowRl.setVisibility(View.VISIBLE);
            testimonyAddIv.setVisibility(View.GONE);
            testimonyUploadFilesTv.setVisibility(View.GONE);
            developmentAddRl.setVisibility(View.GONE);
        } else {
            ToastUtils.toast(mContext, "图片特征抽取失败");
        }
    } else {
        isFace = true;
        // 上传图片无人脸隐藏
        hintShowIv.setVisibility(View.GONE);
        testimonyShowImg.setVisibility(View.GONE);
        hintShowRl.setVisibility(View.VISIBLE);
        testimonyShowRl.setVisibility(View.VISIBLE);
        testimonyAddIv.setVisibility(View.GONE);
        testimonyUploadFilesTv.setVisibility(View.GONE);
        developmentAddRl.setVisibility(View.GONE);
    }
}

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);
    }
}

     isConfigExit = ConfigUtils.isConfigExit();
     isInitConfig = ConfigUtils.initConfig();
     if (isInitConfig && isConfigExit) {
        Toast.makeText(MainActivity.this, "初始配置加载成功", Toast.LENGTH_SHORT).show();
     } else {
        Toast.makeText(MainActivity.this, "初始配置失败,将重置文件内容为默认配置", Toast.LENGTH_SHORT).show();
        ConfigUtils.modityJson();
    		  }

ConfigUtils.modityJson();