1、SDK示例工程说明	
    1.1 识别流程图
    1.2 工程及接口说明
        1.2.1 工程目录图
        1.2.2 faceLibrary核心库
        1.2.3 app model
            SDK激活接口：
            •	离线激活
            •	在线激活
            •	批量激活
        1.2.4 dataLibrary 数据库 mode
        1.2.5 9个功能页面
        1.2.6 face-sdk-library high-level api 算法接口封装
        1.2.7 人脸识别Android SDK接入前置基础配置
            1.2.7.1 官网sdk示例使用
            1.2.7.2 解压下载官方示例
    1.3 1:n 识别功能-简单集成方法使用说明：(以闸机模式为例)
        激活说明
        •	在线激活
        •	离线激活
        •	批量激活（属于在线激活）
        1.3.1 新建项目
        1.3.2 导入faceLibrary库
            1.3.2.1 FaecLibrary放入app.build中
            1.3.2.2 添加ndk
        1.3.3 导入dataLibrary 数据库（同上）
        1.3.4 将闸机模式部分封装代码放入项目中
        1.3.5 创建activity以及layout
            添加权限
        1.3.6 开启摄像头
        1.3.7 添加sdk激活接口（以离线激活为例）
        1.3.8 添加模型初始化
        1.3.9 添加检测识别接口和人脸框绘制
            1.3.9.1 绘制人脸
            1.3.9.2 设置人脸展示角度与识别角度
        1.3.10 注册人脸（以图片注册且导入+识别双线程举例）
            1.3.10.1 添加初始化数据库
            1.3.10.2 添加注册模型以及检测方法
            1.3.10.3 添加注册模型初始化
            1.3.10.4 注册方法添加
            1.3.10.5 添加注册逻辑
                1.3.10.5.1 添加结果展示和注册按钮
                1.3.10.5.2 添加注册方法
        1.3.11 nir活体摄像头添加（仅限于含有rgb+nir双目摄像头设备）
    1.4 1:1 识别功能-简单集成方法使用说明：（同上方1：n识别demo继续）
        1.4.1 创建1：1 activity 功能与1：n同理（1：1不需要数据库）
        1.4.2 调整FaceSDKManager类为只进行特征提取不进行1：n比较(且去掉3.10.5.2 部分的isPush判断)
        1.4.3 提取图片人脸特征
        1.4.4 添加1：1比较接口
    1.5 驾驶行为模块使用说明
    1.6 金融活检模块使用说明
    1.7 注意力模式使用说明
    1.8 属性模式说明
    1.9 注册人脸库模块说明
        1.9.1视频流检测人脸并注册
            1.9.1.1人脸注册
            1.9.1.2检测部分
            1.9.1.3人脸范围、质量、活体判断
            1.9.1.4提取完毕的特征人脸信息，注册到本地数据库
        1.9.2 图片bitmap人脸注册（也可也以参考上方3.10进行图片注册）
    1.10 支付模块UI二次开发指引
    1.11 识别流程方法和阈值说明
        1.11.1 模型初始化
        1.11.2 将人脸注册数据放进sdk内存
        1.11.3 识别流程调用
    1.12 人脸识别SDK 主页面UI布局修改指引
    1.13 升级指导
        1.13.1 3.v – 4.v
        1.13.2 4.v – 5.v、5.v – 6.v、6.v – 7.v
        1.13.3 7.v – 8.v
2、接口说明
	2.1 FaceAuth 鉴权接口
		2.1.1 鉴权-在线鉴权
		2.1.2 鉴权-离线授权
        2.1.3 鉴权-在线按应用批量授权
		2.1.4 开启底层Log输出
		2.1.5 设置核数
		2.1.6 Code返回值
	2.2 FaceDetect 检测接口
		2.2.1 可见光检测对齐模型加载
        2.2.2 检测对齐模型加载
		2.2.3 质量检测模型加载
        2.2.4 属性情绪模型加载
        2.2.5 眼睛闭合，嘴巴闭合模型加载
        2.2.6 最优人脸模型加载
		2.2.7 配置信息加载
		2.2.8 人脸框检测 
		2.2.9 人脸跟踪-多人脸检测（接口只支持RGB追踪）
        2.2.10 人脸跟踪-多人脸检测
		2.2.11 人脸抠图
		2.2.12 检测模型卸载
	2.3 FaceLive 活体接口
		2.3.1 活体模型加载
		2.3.2 人脸静默活体检测
		2.3.3 活体模型卸载
	2.4 FaceFeature 特征抽取接口
		2.4.1 特征模型加载
		2.4.2 特征提取
		2.4.3 特征比对
		2.4.4 1:N特征设置
		2.4.5 1:N特征比对
		2.4.6 卸载特征模型
	2.5 BDFaceImageInstance 图片接口
		2.5.1 图片构造
        2.5.2 图片构造
        2.5.3 图像句柄创建（YUV,DEPTH图像数据流）
		2.5.4 图像句柄创建（Bitmap 图像信息）
		2.5.5 图片信息获取（送检）
		2.5.6 图片销毁
    2.6 FaceGaze 注意力检测接口
        2.6.1 注意力模型加载
        2.6.2 注意力状态获取
        2.6.3 注意力模型卸载 
    2.7 FaceDriverMonitor 驾驶行为监测
        2.7.1 驾驶行为监测能力加载
        2.7.2 驾驶行为监测能力能力卸载
        2.7.3 驾驶行为监测检测
    2.8 FaceCrop 抠图能力接口
		2.8.1 intFaceCrop 抠图能力加载
		2.8.2 unintFaceCrop 抠图能力加载
		2.8.3 cropFaceByBox 使用人脸框进行人脸抠图
		2.8.4 cropFaceByLandmark 使用人脸关键点进行人脸抠图
    2.9 FaceMouthMask 口罩检测接口
		2.9.1 口罩检测模型加载
		2.9.2 口罩检测结果获取
		2.9.3 口罩检测模型卸载
    2.10 ImageIllum 图片光照检测接口
    2.11 FaceDarkEnhance暗光恢复检测
        2.11.1 模型加载
        2.11.2 暗光检测
        2.11.3 能力卸载
    2.12 实体类说明
		2.12.1 FaceInfo 实体类
		2.12.2 BDFaceSDKCommon 枚举类
		2.12.3 BDFaceOcclusion 实体类
		2.12.4 BDFaceSDKConfig 配置实体类 
		2.12.5 Feature 实体类
        2.12.6 BDFaceGazeInfo 配置实体类 
		2.12.7 BDFaceDetectListConf 实体类
        2.12.8 BDFaceDriverMonitorInfo 驾驶检测结果信息
3、示例参考
	3.1 功能介绍
	3.2 代码结构
		3.2.1 核心库介绍
		3.2.2 示例代码结构
	3.3 开始集成
		3.3.1 鉴权
		3.3.2 人脸注册
		3.3.3 1：N识别
		3.3.4 人脸库管理
		3.3.5 人证比对
		3.3.6 功能设置
	3.4 核心类说明

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(BDFaceLogInfo logInfo)

setAnakinConfigure(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 String emotionModel,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()

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

void initModel(final Context context,final String visModel,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 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_VALUE_MESSAGE,   // 打印输出值日志
        BDFACE_LOG_ERROR_MESSAGE,   // 打印输出错误日志
        BDFACE_LOG_ALL_MESSAGE,     // 打印所有日志
    }

    public enum BDFaceAnakinRunMode {
        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 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 BDFaceGazeDirection leftEyeGaze;  // 左眼的注意力信息
    public BDFaceGazeDirection rightEyeGaze; // 右眼的注意力信息
    } 

   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 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, 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) {
        // 摄像头预览数据进行人脸检测
        int liveType = SingleBaseConfig.getBaseConfig().getType();
        if (liveType == 1) { // 无活体检测
            FaceTrackManager.getInstance().setAliving(false);
        } else if (Integer.valueOf(liveType) == 2) { // 活体检测
            FaceTrackManager.getInstance().setAliving(true);
        }
        FaceTrackManager.getInstance().faceTrack(data, width, height, new FaceDetectCallBack() {
            @Override
            public void onFaceDetectCallback(LivenessModel livenessModel) {
                checkResult(livenessModel);
            }
        });
    }

    int liveType = SingleBaseConfig.getBaseConfig().getType();
        // 无活体
        if (Integer.valueOf(liveType) == 1) {
            displayResult(model, null);
            // 注册
            register(model);
        } else if (Integer.valueOf(liveType) == 2) { // RGB活体检测
            displayResult(model, "livess");
            boolean livenessSuccess = false;
            float rgbLiveThreshold = SingleBaseConfig.getBaseConfig().getRgbLiveScore();
            livenessSuccess = (model.getRgbLivenessScore() > rgbLiveThreshold) ? true : false;
            if (livenessSuccess) {
                // 注册
                register(model);
            }
        }

    // 获取选择的特征抽取模型
        int modelType = SingleBaseConfig.getBaseConfig().getActiveModel();
        if (modelType == 1) {
            // 生活照
            FaceSDKManager.getInstance().onFeatureCheck(model.getBdFaceImageInstance(), model.getLandmarks(),
                    BDFaceSDKCommon.FeatureType.BDFACE_FEATURE_TYPE_LIVE_PHOTO, new FaceFeatureCallBack() {
                        @Override
                        public void onFaceFeatureCallBack(float featureSize, byte[] feature) {
                            displayCompareResult(featureSize, feature);
                            Log.e("qing", String.valueOf(feature.length));
                        }

                    });

        } else if (Integer.valueOf(modelType) == 2) {
            // 证件照
            FaceSDKManager.getInstance().onFeatureCheck(model.getBdFaceImageInstance(), model.getLandmarks(),
                    BDFaceSDKCommon.FeatureType.BDFACE_FEATURE_TYPE_ID_PHOTO, new FaceFeatureCallBack() {
                        @Override
                        public void onFaceFeatureCallBack(float featureSize, byte[] feature) {
                            displayCompareResult(featureSize, feature);
                        }
                    });
        }

     // 根据特征抽取的结果 注册人脸
     private void displayCompareResult(float ret, byte[] faceFeature) {
        // 特征提取成功
        if (ret == 128) {
            String imageName = groupId + "-" + username + ".jpg";
            // 注册到人脸库
            boolean isSuccess = FaceApi.getInstance().registerUserIntoDBmanager(groupId, username, imageName,
                    userInfo, faceFeature);
            if (isSuccess) {
                // 关闭摄像头
                CameraPreviewManager.getInstance().stopPreview();
                Log.e("qing", "注册成功");
                // 数据变化，更新内存
                FaceApi.getInstance().initDatabases(true);
                // 防止重复注册
                username = null;
                groupId = null;
            }else {
                // 注册失败
            }
        } else if (ret == -1) {
            displayTip("特征提取失败");
        } else {
          // 特征提取失败
        }
    }

public void startPreview(Context context, AutoTexturePreviewView textureView, int width,int height, CameraDataCallback cameraDataCallback) 

// 设置相机的ID
CameraPreviewManager.getInstance().setCameraFacing(CameraPreviewManager.CAMERA_USB);
// 开启预览
CameraPreviewManager.getInstance().startPreview(this, mAutoCameraPreviewView,
                PREFER_WIDTH, PERFER_HEIGH, new CameraDataCallback())

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(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 batchFaceDir = FileUtils.getBatchImportDirectory();

	// 遍历该目录下的所有文件
    String[] files = batchFaceDir.list();
    if (files == null || files.length == 0) {
        LogUtils.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 void deleteUserGroupListInfo(List<Group> list, 
		UserInfoListener listener, int selectCount);

	public void getUserListInfoByGroupId(String userName, 
		String groupId, UserInfoListener listener)

	public void deleteUserListInfo(List<User> list, 
		UserInfoListener listener, int selectCount);

	public void deleteUserInfo(String userId, String groupId, 
		final UserInfoListener listener);

	// 获取根路径
    File root = Environment.getExternalStorageDirectory();
    // 保存的图片文件
    mImageFile = new File(root, "test.jpg");
    Uri uri = Uri.fromFile(mImageFile);
    Intent intent = new 
	    Intent(android.provider.MediaStore.ACTION_IMAGE_CAPTURE);
    intent.putExtra(android.provider.MediaStore.EXTRA_OUTPUT, uri);
    startActivityForResult(intent, requestCode);

	Intent intent = new Intent(Intent.ACTION_PICK,
    MediaStore.Images.Media.EXTERNAL_CONTENT_URI);
    startActivityForResult(intent, REQUEST_LOAD_IMAGE);    

public void updateImage(Bitmap bitmap, String groupId, 
String userName, String imageName, UserInfoListener listener);

    private void syncFeature(final Bitmap bitmap, final byte[] feature, final int index, boolean isFromPhotoLibrary) {
        float ret = -1;
        BDFaceImageInstance rgbInstance = new BDFaceImageInstance(bitmap);
        FaceInfo[] faceInfos = FaceSDKManager.getInstance().getFaceDetect()
                .detect(BDFaceSDKCommon.DetectType.DETECT_VIS, rgbInstance);
        // 检测结果判断
        if (faceInfos != null && faceInfos.length > 0) {

            // 判断质量检测，针对模糊度、遮挡、角度
            if (qualityCheck(faceInfos[0], isFromPhotoLibrary)) {
                ret = FaceSDKManager.getInstance().getFaceFeature().feature(BDFaceSDKCommon.FeatureType.
                        BDFACE_FEATURE_TYPE_ID_PHOTO, rgbInstance, faceInfos[0].landmarks, feature);
                Log.i("qing", "ret:" + ret);
                if (ret == 128 && index == 1) {
                    firstFeatureFinished = true;
                } else if (ret == 128 && index == 2) {
                    secondFeatureFinished = true;
                }
                if (ret == 128) {
                    toast("图片" + index + "特征抽取成功");
                } else if (ret == -100) {
                    toast("未完成人脸比对，可能原因，图片1为空");
                } else if (ret == -101) {
                    toast("未完成人脸比对，可能原因，图片2为空");
                } else if (ret == -102) {
                    toast("未完成人脸比对，可能原因，图片1未检测到人脸");
                } else if (ret == -103) {
                    toast("未完成人脸比对，可能原因，图片2未检测到人脸");
                } else {
                    toast("未完成人脸比对，可能原因，"
                            + "人脸太小（小于sdk初始化设置的最小检测人脸）"
                            + "人脸不是朝上，sdk不能检测出人脸");
                }
            }

        } else {
            toast("未检测到人脸,可能原因人脸太小");
        }

    }

     private void match() {
        if (!firstFeatureFinished) {
            toast("图片一特征抽取失败");
            return;
        }
        if (!secondFeatureFinished) {
            toast("图片二特征抽取失败");
            return;
        }
        int idFeatureValue = SingleBaseConfig.getBaseConfig().getThreshold();
        float score = 0;
        //  比较两个人脸
        score = FaceSDKManager.getInstance().getFaceFeature().featureCompare(
                BDFaceSDKCommon.FeatureType.BDFACE_FEATURE_TYPE_ID_PHOTO,
                firstFeature, secondFeature, true);
        if (score > idFeatureValue) {
            tvState.setTextColor(getResources().getColor(R.color.buttonBg));
            tvState.setText("核验通过");
        } else {
            tvState.setTextColor(getResources().getColor(R.color.red));
            tvState.setText("核验不通过");
        }
    }

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