1、FaceAuth-鉴权接口
   1.1 鉴权-在线授权
   1.2 鉴权-SDK 压缩文件，本地鉴权
   1.3 开启底层Log输出
   1.4 设置Anakin核数
2、FaceDetect-检测接口
   2.1 检测对齐模型加载
   2.2 质量检测模型加载
   2.3 配置信息加载
   2.4 YUV图片转换ARGB
   2.5 人脸框检测
   2.6 人脸跟踪-最大人脸接口
   2.7 人脸跟踪-第一个人脸接口
   2.8 人脸跟踪-多人脸检测
   2.9 人脸图像质量检测
   2.10 检测方法类型设置
   2.11 人脸图片信息清理
3、FaceLive-活体接口
   3.1 活体模型加载
   3.2 人脸静默活体检测-RGB可见光
   3.3 人脸静默活体检测-NIR近红外或Depth深度图
4、FaceFeature-特征接口
   4.1 特征模型加载
   4.2 人脸特征提取
   4.3 人脸特征比对
5、FaceAttributes-属性接口
   5.1 属性情绪模型加载
   5.2 人脸属性检测
   5.3 人脸表情检测
6、人脸信息实体类
   6.1 基础信息实体类
   6.2 扩展信息实体类

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

void initLicenseOffLine(final Context context, final AuthCallback callback)

void setActiveLog(BDFaceLogInfo logInfo)

void setAnakinThreadsConfigure(int flagsThreads ,int flagsCluster)

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

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

void loadConfig(BDFaceSDKConfig config)

int getDataFromYUVimg(byte[] dataYUV, int[] imageData, int width, int height, int angle, int flip)

FaceInfo[] detect(int[] imageData, int height, int width,int minFaceSize)

	           if (faceDetect == null) {
                    Toast.makeText(mContext,
                            "未初始化检测模型", Toast.LENGTH_SHORT).show();
                    return;
                }
                faceDetect.setDetectMethodType(FaceDetect.DetectType.DETECT_VIS);
                FaceInfo[] faceInfos = faceDetect.detect(
                        liveVisImg.data, liveVisImg.height, liveVisImg.width, 50);
                if (faceInfos != null && faceInfos.length > 0) {
                    FaceInfo faceInfo = faceInfos[0];
                    StringBuilder info = new StringBuilder();
                    info.append("face info length:").append(faceInfos.length)
                            .append(" face_id:").append(faceInfo.face_id)
                            .append(" width:").append(faceInfo.mWidth)
                            .append(" score:").append(faceInfo.mConf);
                    Toast.makeText(mContext,
                            info,
                            Toast.LENGTH_SHORT).show();
                    Log.e("handler", info.toString());
                } else {
                    String info = " face info length 0";
                    Toast.makeText(mContext,
                            info, Toast.LENGTH_SHORT).show();
                    Log.e("handler", info);
                }

FaceInfo[] trackMaxFace(int[] imageData, int height, int width)

                if (faceDetect == null) {
                    Toast.makeText(mContext,
                            "未初始化检测模型", Toast.LENGTH_SHORT).show();
                    return;
                }
                faceDetect.setDetectMethodType(FaceDetect.DetectType.DETECT_VIS);
                FaceInfo[] faceInfos = faceDetect.trackMaxFace(
                        liveVisImg.data, liveVisImg.height, liveVisImg.width
                );
                if (faceInfos != null && faceInfos.length > 0) {
                    FaceInfo faceInfo = faceInfos[0];
                    StringBuilder info = new StringBuilder();
                    info.append("face info length:").append(faceInfos.length)
                            .append(" face_id:").append(faceInfo.face_id)
                            .append(" width:").append(faceInfo.mWidth)
                            .append(" score:").append(faceInfo.mConf);
                    if (faceInfo.occlu != null && faceInfo.occlu.length == 7) {
                        info.append("face occlusion: ")
                                .append(" L eye:").append(faceInfo.occlu[0])
                                .append(" R eye:").append(faceInfo.occlu[1])
                                .append(" nose:").append(faceInfo.occlu[2])
                                .append(" mouth:").append(faceInfo.occlu[3])
                                .append(" L contour:").append(faceInfo.occlu[4])
                                .append(" R contour:").append(faceInfo.occlu[5])
                                .append(" chin contour:").append(faceInfo.occlu[6]);
                        info.append("face blur: ").append(faceInfo.blur);
                        info.append("face illum: ").append(faceInfo.illum);
                    }
                    Toast.makeText(mContext,
                            info,
                            Toast.LENGTH_SHORT).show();
                    Log.e("handler", info.toString());
                } else {
                    String info = " face info length 0";
                    Toast.makeText(mContext,
                            info, Toast.LENGTH_SHORT).show();
                    Log.e("handler", info);
                }
                faceDetect.clearTrackedFaces();

FaceInfo[] trackFirstFace(int[] imageData, int height, int width) 

FaceInfo[] track(int[] imageData, int height, int width, int num)

int imgQuality(int[] imageData, int height, int width, int[] landmarks,float[] bluriness, int[] illum, float[] occlusion, int[] nOccluPart)

                if (faceDetect == null) {
                    Toast.makeText(mContext,
                            "未初始化检测模型", Toast.LENGTH_SHORT).show();
                    return;
                }
                faceDetect.setDetectMethodType(FaceDetect.DetectType.DETECT_VIS);
                FaceInfo[] faceInfos = faceDetect.trackMaxFace(
                        liveVisImg.data, liveVisImg.height, liveVisImg.width);
                if (faceInfos != null && faceInfos.length > 0) {
                    FaceInfo faceInfo = faceInfos[0];
                    // 质量检测通过加入人脸列表
                    float[] bluriness = new float[1];
                    int[] illum = new int[1];
                    float[] occlusion = new float[7];
                    int[] nOccluPart = new int[1];
                    faceDetect.imgQuality(liveVisImg.data, liveVisImg.height,
                            liveVisImg.width, faceInfo.landmarks, bluriness, illum, occlusion, nOccluPart);
                    StringBuilder info = new StringBuilder();
                    info.append("face occlusion: ")
                            .append(" L eye:").append(occlusion[0])
                            .append(" R eye:").append(occlusion[1])
                            .append(" nose:").append(occlusion[2])
                            .append(" mouth:").append(occlusion[3])
                            .append(" L contour:").append(occlusion[4])
                            .append(" R contour:").append(occlusion[5])
                            .append(" chin contour:").append(occlusion[6]);
                    info.append("face blur: ").append(bluriness[0]);
                    info.append("face illum: ").append(illum[0]);
                    Toast.makeText(mContext,
                            info,
                            Toast.LENGTH_SHORT).show();
                    Log.e("handler", info.toString());
                } else {
                    String info = " face info length 0";
                    Toast.makeText(mContext,
                            info, Toast.LENGTH_SHORT).show();
                    Log.e("handler", info);
                }
                faceDetect.clearTrackedFaces();

void setDetectMethodType(DetectType detectMethodType)

void clearTrackedFaces()

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

float silentLive(LiveType liveType, int[] imageData, int height, int width, int[] landmarks)

                if (faceDetect == null) {
                    Toast.makeText(mContext,
                            "未初始化检测模型", Toast.LENGTH_SHORT).show();
                    return;
                }

                if (faceLive == null) {
                    Toast.makeText(mContext,
                            "未初始化活体模型", Toast.LENGTH_SHORT).show();
                    return;
                }
                faceDetect.setDetectMethodType(FaceDetect.DetectType.DETECT_VIS);

                FaceInfo[] faceInfos = faceDetect.trackMaxFace(
                        liveVisImg.data, liveVisImg.height, liveVisImg.width
                );

                if (faceInfos != null && faceInfos.length > 0) {
                    FaceInfo faceInfo = faceInfos[0];

                    float visScore = faceLive.silentLive(FaceLive.LiveType.LIVEID_VIS,
                            liveVisImg.data, liveVisImg.height, liveVisImg.width,
                            faceInfo.landmarks);
                    float nirScore = faceLive.silentLive(FaceLive.LiveType.LIVEID_NIR,
                            liveVisImg.dataByte, liveVisImg.height, liveVisImg.width,
                            faceInfo.landmarks);
                    float depthScore = faceLive.silentLive(FaceLive.LiveType.LIVEID_DEPTH,
                            liveDepthImg.dataByte, liveVisImg.height, liveVisImg.width,
                            faceInfo.landmarks);
                    StringBuilder builder = new StringBuilder();
                    builder.append("live-vis").append(visScore)
                            .append("  live-nir").append(nirScore)
                            .append("  live-depth").append(depthScore);

float silentLive(LiveType liveType, byte[] imageData, int height, int width, int[] landmarks)

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

float feature(FeatureType featureType, int[] imageData, int height, int width, int[] landmarks, byte[] feature)

                if (faceDetect == null) {
                    Toast.makeText(mContext,
                            "未初始化检测模型", Toast.LENGTH_SHORT).show();
                    return;
                }

                if (faceFeature == null) {
                    Toast.makeText(mContext,
                            "未初始化特征模型", Toast.LENGTH_SHORT).show();
                    return;
                }
                faceDetect.setDetectMethodType(FaceDetect.DetectType.DETECT_VIS);

                FaceInfo[] faceInfos = faceDetect.trackMaxFace(
                        featureIdPImg.data, featureIdPImg.height, featureIdPImg.width
                );

                byte[] feature1 = new byte[512];
                if (faceInfos != null && faceInfos.length > 0) {
                    FaceInfo faceInfo = faceInfos[0];
                    float length = faceFeature.feature(FaceFeature.FeatureType.FEATURE_VIS,
                            featureIdPImg.data, featureIdPImg.height, featureIdPImg.width, faceInfo.landmarks, feature1);
                    Log.e("handler", "VIS feature 1 length " + length);
                }
                faceDetect.clearTrackedFaces();

                FaceInfo[] faceInfos2 = faceDetect.trackMaxFace(
                        featureVisImg.data, featureVisImg.height, featureVisImg.width
                );

                byte[] feature2 = new byte[512];
                if (faceInfos2 != null && faceInfos2.length > 0) {
                    FaceInfo faceInfo2 = faceInfos2[0];
                    float length = faceFeature.feature(FaceFeature.FeatureType.FEATURE_VIS,
                            featureVisImg.data, featureVisImg.height, featureVisImg.width, faceInfo2.landmarks, feature2);
                    Log.e("handler", "VIS feature 2 length " + length);
                }
                faceDetect.clearTrackedFaces();

                float result = faceFeature.featureCompare(FaceFeature.FeatureType.FEATURE_VIS,
                        feature1, feature2);

float featureCompare(FeatureType featureType, byte[] feature1, byte feature2)

void initModel(final Context context,final String atttibuteModel,final String emotionModel,final Callback callback)

BDFaceSDKAttribute attribute(int[] imageData, int height, int width, int[] landmarks)

                if (faceDetect == null) {
                    Toast.makeText(mContext,
                            "未初始化检测模型", Toast.LENGTH_SHORT).show();
                    return;
                }

                if (faceAttributes == null) {
                    Toast.makeText(mContext,
                            "未初始化属性模型", Toast.LENGTH_SHORT).show();
                    return;
                }

                faceDetect.setDetectMethodType(FaceDetect.DetectType.DETECT_VIS);

                FaceInfo[] faceInfos = faceDetect.trackMaxFace(
                        liveVisImg.data, liveVisImg.height, liveVisImg.width);

                if (faceInfos != null && faceInfos.length > 0) {
                    FaceInfo faceInfo = faceInfos[0];
                    BDFaceSDKAttribute attribute = faceAttributes.attribute(liveVisImg.data,
                            liveVisImg.height, liveVisImg.width,
                            faceInfo.landmarks);

                    BDFaceSDKEmotions emotions = faceAttributes.emotions(liveVisImg.data,
                            liveVisImg.height, liveVisImg.width,
                            faceInfo.landmarks);

                    final StringBuilder builder = new StringBuilder();
                    if (attribute != null) {
                        builder.append(" attribute:");
                        builder.append(attribute.age);
                        builder.append("    ").append(attribute.emotion);
                        builder.append("    ").append(attribute.gender);
                        builder.append("    ").append(attribute.glasses);
                    }
                    if (emotions != null) {
                        builder.append("\n emotion:");
                        builder.append("    ").append(emotions.emotion);
                        builder.append("    ").append(emotions.expression_conf);
                    }
                    Log.e("handler", "attribute  " + builder.toString());

                }
                faceDetect.clearTrackedFaces();

BDFaceSDKEmotions emotions(int[] imageData, int height, int width, int[] landmarks) 

/**
 * 人脸信息实体类
 */

public class FaceInfo {
    public float mWidth; // rectangle width
    public float mAngle; // rectangle tilt angle [-45 45] in degrees
    public float mCenter_y;   // rectangle center y
    public float mCenter_x;  // rectangle center x
    public float mConf; // face detection score

    public int[] landmarks;
    public int face_id;
    public float[] headPose;
    public int[] is_live;

    public float illum = 0f;
    public float blur = 0f;
    public float[] occlu;

    public FaceInfo(float width, float angle, float y, float x, float conf) {
        mWidth = width;
        mAngle = angle;
        mCenter_y = y;
        mCenter_x = x;
        mConf = conf;
        landmarks = null;
        face_id = 0;
    }

    public FaceInfo(float width, float angle, float y, float x, float conf, int track_id, int[] ldmks) {
        mWidth = width;
        mAngle = angle;
        mCenter_y = y;
        mCenter_x = x;
        mConf = conf;
        landmarks = ldmks;
        face_id = track_id;
    }

    public FaceInfo(float width, float angle, float y, float x, float conf,
                    int track_id, int[] ldmks, float[] pose, int[] livestatus,
                    float illum,float blur,float[] occlu
    ) {
        mWidth = width;
        mAngle = angle;
        mCenter_y = y;
        mCenter_x = x;
        mConf = conf;
        landmarks = ldmks;
        face_id = track_id;
        headPose = pose;
        is_live = livestatus;
        this.illum = illum;
        this.blur = blur;
        this.occlu = occlu;
    }
}

// 图片信息类
public class BDFaceSDKImageInfo {
    public int height;                              // 图片高度
    public int widht;                              // 图片宽度
    public int[] data;                            // 图片数据
    public BDFaceSDKCommon.BDFaceImageType type;  // 图片格式

    public BDFaceSDKImageInfo(int height, int widht, int[] data, int type) {
        this.height = height;
        this.widht = widht;
        this.data = data;
        this.type = BDFaceSDKCommon.BDFaceImageType.values()[type];
    }
}

public class BDFaceSDKConfig {
    /**
     * 最小人脸检测大小 建议50
     */
    public int minFaceSize = 50;

    /**
     * 最大人脸检测大小 建议-1(不做限制)
     */
    public int maxFaceSize = -1;

    /**
     * 人脸跟踪，检测的时间间隔 默认 500ms
     */
    public int trackInterval = 0;

    /**
     * 人脸跟踪，跟踪时间间隔 默认 1000ms
     */
    public int detectInterval = 0;

    /**
     * 人脸置信度阈值，建议值0.5
     */
    public float noFaceSize = 0.5f;

    /**
     * 人脸姿态角 pitch,yaw,roll
     */
    public int pitch;
    public int yaw;
    public int roll;

    /**
     * 质量检测模糊，遮挡，光照，默认不做质量检测
     */
    public boolean isCheckBlur = true;
    public boolean isOcclusion = true;
    public boolean isIllumination = true;

    /**
     * 检测图片类型，可见光或者红外
     */
    public FaceDetect.DetectType detectMethodType
            = FaceDetect.DetectType.DETECT_VIS;
}

// 人脸属性
public class BDFaceSDKAttribute {
    public int age;                                    // 年龄
    public BDFaceSDKCommon.BDFaceRace race;            // 种族
    public BDFaceSDKCommon.BDFaceEmotion emotion;      // 表情
    public BDFaceSDKCommon.BDFaceGlasses glasses;      // 戴眼镜状态
    public BDFaceSDKCommon.BDFaceGender gender;        // 性别

    public BDFaceSDKAttribute(int age, int race, int emotion, int glasses, int gender) {
        this.age = age;
        this.race = BDFaceSDKCommon.BDFaceRace.values()[race];
        this.emotion = BDFaceSDKCommon.BDFaceEmotion.values()[emotion];
        this.gender = BDFaceSDKCommon.BDFaceGender.values()[gender];
        this.glasses = BDFaceSDKCommon.BDFaceGlasses.values()[glasses];
    }
}

// 人脸情绪
public class BDFaceSDKEmotions {
    public BDFaceSDKCommon.BDFaceEmotionEnum emotion;
    public float expression_conf;
    public float[] expression_conf_list;

    public BDFaceSDKEmotions(int emotion, float expression_conf, float[] expression_conf_list) {
        this.emotion = BDFaceSDKCommon.BDFaceEmotionEnum.values()[emotion];
        this.expression_conf = expression_conf;
        this.expression_conf_list = expression_conf_list;
    }
}
    // 图像类型
    public enum BDFaceImageType {
        BD_FACE_IMAGE_TYPE_RGB,         // rgb图像
        BD_FACE_IMAGE_TYPE_BGR,         // bgr图像
        BD_FACE_IMAGE_TYPE_RGBA,        // rgba图像
        BD_FACE_IMAGE_TYPE_BGRA,        // bgra图像
        BD_FACE_IMAGE_TYPE_GRAY,        // 灰度图
        BD_FACE_IMAGE_TYPE_DEPTH,       // 深度图
        BD_FACE_IMAGE_TYPE_YUV422,      // YUV422图像
        BD_FACE_IMAGE_TYPE_YUV_411,     // YUV 411图像
        BD_FACE_IMAGE_TYPE_YUV_420,     // YUV 411图像
        BD_FACE_IMAGE_TYPE_YUV_YUYV,    // YUV YUYV图像
        BD_FACE_IMAGE_TYPE_YUV_YU12,    // YUV YU12图像
        BD_FACE_IMAGE_TYPE_YUV_NV12,    // YUV NV12图像
        BD_FACE_IMAGE_TYPE_YUV_NV21,    // YUV NV21图像
    }

    // 表情类型
    public enum BDFaceEmotion {
        BDFACE_EMOTION_NEUTRAL,         // 中性表情
        BDFACE_EMOTION_SMILE,           // 微笑
        BDFACE_EMOTION_BIG_SMILE,       // 大笑
    }

    // 情绪
    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,   // 男性
    }
    /**
     * log种类枚举
     */
    public enum BDFaceLogInfo {
        BDFACE_LOG_VALUE_MESSAGE,   // 打印输出值日志
        BDFACE_LOG_ERROR_MESSAGE,   // 打印输出错误日志
        BDFACE_LOG_ALL_MESSAGE,     // 打印所有日志
    };