FaceScenic/app/src/main/java/com/hanghui/senic/baiduface/BaiduFacePreviewActivity.java

package com.hanghui.senic.baiduface;


import android.graphics.Bitmap;
import android.hardware.Camera;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Log;
import android.view.KeyEvent;
import android.view.TextureView;
import android.view.View;
import android.view.ViewGroup;
import android.widget.FrameLayout;
import android.widget.ImageView;

import androidx.annotation.NonNull;

import com.baidu.idl.main.facesdk.FaceInfo;
import com.baidu.idl.main.facesdk.model.BDFaceImageInstance;
import com.baidu.idl.main.facesdk.model.BDFaceSDKCommon;
import com.baidu.idl.main.facesdk.model.SingleBaseConfig;
import com.baidu.idl.main.facesdk.utils.FaceUtils;
import com.bumptech.glide.load.engine.DiskCacheStrategy;
import com.bumptech.glide.request.RequestOptions;
import com.example.datalibrary.callback.CameraDataCallback;
import com.example.datalibrary.callback.FaceDetectCallBack;
import com.example.datalibrary.gatecamera.CameraPreviewManager;
import com.example.datalibrary.gl.view.GlMantleSurfacView;
import com.example.datalibrary.listener.SdkInitListener;
import com.example.datalibrary.manager.FaceSDKManager;
import com.example.datalibrary.model.BDFaceCheckConfig;
import com.example.datalibrary.model.BDFaceImageConfig;
import com.example.datalibrary.model.BDLiveConfig;
import com.example.datalibrary.model.LivenessModel;
import com.example.datalibrary.model.User;
import com.example.datalibrary.utils.BitmapUtils;
import com.example.datalibrary.utils.FaceOnDrawTexturViewUtil;
import com.example.datalibrary.utils.ToastUtils;
import com.hanghui.senic.MyAppliction;
import com.hanghui.senic.R;
import com.hanghui.senic.FaceOneToOneWaitEvent;
import com.hanghui.senic.activity.view.BaiDuFaceView;
import com.hanghui.senic.activity.view.ClickButtonFloatView;
import com.hanghui.senic.baiduface.view.BaiduPreviewTexture;
import com.hanghui.senic.baiduface.view.BaiduResultView;
import com.hanghui.senic.bean.FederatedPlatformsRequestBean;
import com.hanghui.senic.bean.FederatedPlatformsResponseBean;
import com.hanghui.senic.bean.PADQREvent;
import com.hanghui.senic.common.AppHandler;

import com.hanghui.senic.common.CommonUtil;
import com.hanghui.senic.common.Constants;
import com.hanghui.senic.common.DataManager;
import com.hanghui.senic.common.DataReturns;
import com.hanghui.senic.common.DeviceExpireManager;
import com.hanghui.senic.common.TaskStatus;
import com.hanghui.senic.common.ThreadPoolManager;
import com.hanghui.senic.common.UserInfoManager;
import com.hanghui.senic.controller.BlacklistManager;
import com.hanghui.senic.lib_base.event.LedLightEvent;
import com.hanghui.senic.network.HttpRequest;

import com.hanghui.senic.service.usbserialdemo.utile.ConfigManager;
import com.hanghui.senic.service.usbserialdemo.utile.StringIsNull;
import com.hanghui.senic.service.usbserialdemo.utile.StringUtils;
import com.hanghui.senic.service.usbserialdemo.utile.devicesUI.DeviceUtils;
import com.hanghui.senic.service.usbserialdemo.utile.loacat.AppLogUtils;
import com.hanghui.senic.utils.DoubClickUtils;
import com.hanghui.senic.utils.ImageLoaderUtils;

import org.greenrobot.eventbus.EventBus;
import org.greenrobot.eventbus.Subscribe;
import org.greenrobot.eventbus.ThreadMode;

/**
 * 百度face的刷脸页面
 * <p>
 * <p>
 * LivenessModel：人脸检测结果存储数据类
 * FaceApi:人脸库管理相关操作类， 添加用户：FaceApi.userAdd(user), 人脸检索 : FaceApi.getUserListById()
 * <p>
 * <p>
 * 注册到人脸库：
 * boolean isSuccess = FaceApi.getInstance().registerUserIntoDBmanager(null, userName, imageName, null, mFeatures);
 * <p>
 * <p>
 * LivenessModel.faceInfo : sdk的native方法执行人脸检测后返回的数据
 * <p>
 * faceInfo.score： 人脸置信度分数
 * Feature.score：  1:N比对分数
 * <p>
 * 本地5w条人脸时1：n比对要多少秒
 */
public class BaiduFacePreviewActivity extends BaiduFaceMainActivity implements BaiduResultView.BaiduFaceResultStateCallback {

    private static final String TAG = "BaiduFaceActivity";

    //相机预览页面
    private GlMantleSurfacView glMantleSurfacView;
    // rgb视频数据
    private BDFaceImageConfig bdFaceImageConfig;

    //人脸检测的配置参数， 识别阈值等
    private volatile BDFaceCheckConfig bdFaceCheckConfig;
    //活体检测的配置参数
    private BDLiveConfig bdLiveConfig;

    /*RGB摄像头图像宽和高*/       // 影响人脸宽高
    private static final int PREFER_WIDTH = SingleBaseConfig.getBaseConfig().getRgbAndNirWidth();
    private static final int PERFER_HEIGH = SingleBaseConfig.getBaseConfig().getRgbAndNirHeight();


    private volatile User mUser;//上一次识别到的人


    private int MODE_SCANFACE = 3;//纯刷脸
    private int MODE_PERSONCARD = 4;//人证比对

    /**
     * 是否需要处理刷脸数据，刷脸成功后，在结果页展示期间是不需要处理刷脸数据的
     */
    private volatile boolean isNeedVerify = true;

    private LivenessModel mCurLivenessModel = null;//最新刷到的人脸数据

    private BDFaceImageConfig bdNirFaceImageConfig;

    // RGB+IR 控件
    private BaiduPreviewTexture mPreview;
    private volatile Camera mCamera;

    private TextureView irPreviewView;
    long currentTime = System.currentTimeMillis();//检测到刷脸数据返回后，记录当前事件
    long startTime = 0L;//将刷脸返回时的当前时间保存，用于下次比较

    private final int WHAT_HIDE_LEDLIGHT = 0x22; //关闭补光灯事件
    private volatile boolean isOpenLighet = false; //是否已经打开补光灯
    private volatile boolean isBaiduFaceSucceed = false;  //百度是否已经激活授权成功，防止多次调用
    //结果页视图
    private FrameLayout baiDuView_FloatingResultPageFrame;
    private FrameLayout baiDuView_GeneralResultPageFrame;
    private ImageView iv_please_scanface;
    Handler faceFailedHandler = new Handler(Looper.getMainLooper());//刷脸连续未通过后使用handler延时一定时间后，显示失败结果页
    String mDeviceModel = DeviceUtils.getDeviceModel();
    volatile String userIdUniqueId = "";


    private BaiduResultView baiduResultView;

    /**
     * 清除同人脸间隔判断保存的userID
     */
    private Runnable userIdUniqueIdRunnable = new Runnable() {
        @Override
        public void run() {
            userIdUniqueId = "";
        }
    };

    private Handler mHandler = new Handler(Looper.getMainLooper()) {
        @Override
        public void handleMessage(@NonNull Message msg) {
            super.handleMessage(msg);
            if (WHAT_HIDE_LEDLIGHT == msg.what) {
                CommonUtil.setLedLight(false);
            }
        }
    };


    private BaiduFaceControllerCallback mBaiduFaceControllerCallback = new BaiduFaceControllerCallback() {
        @Override
        public void invokeScanFace() {
            invoke_ScanFace();
        }

        @Override
        public void invokePersonCard(String cardName, String cardNo, String cardPhotoBase64Str) {
            invoke_PersonCard(cardName, cardNo, cardPhotoBase64Str);
        }

        @Override
        public void invokeStopVerify() {
            invoke_StopVerify();
        }

        @Override
        public void invokeResume() {
            invoke_Resume();
        }
    };
    private BaiDuFaceView.BaiDuFaceViewCallback baiDuFaceViewCallback = new BaiDuFaceView.BaiDuFaceViewCallback() {
        @Override
        public void BaiDuFaceViewCallback() {
            //检测到View为空，重新赋值
            if (ConfigManager.isFloatingPages()) {
                BaiDuFaceView.getInstance().setView(baiDuView_FloatingResultPageFrame);
            } else {
                BaiDuFaceView.getInstance().setView(baiDuView_GeneralResultPageFrame);
            }
        }
    };

    @Override
    public int getLayout() {
        return R.layout.activity_baiduface_preview;
    }

    @Override
    public void setOnCreate() {
        TaskStatus.setInitState();
        EventBus.getDefault().register(this);
        // 双目摄像头IR 图像预览
        irPreviewView = findViewById(R.id.ir_camera_preview_view);
        if (SingleBaseConfig.getBaseConfig().getMirrorVideoNIR() == 1) {
            irPreviewView.setRotationY(180);
        }
        mPreview = new BaiduPreviewTexture(this, irPreviewView);
        AppLogUtils.i(true, TAG, "BaiduFaceActivity, onCreate()");
        super.setOnCreate();

        mDeviceModel = DeviceUtils.getDeviceModel();
    }

    @Override
    public void onPause() {
        super.onPause();
    }

    @Override
    protected void onStart() {
        super.onStart();
        if (isBaiduFaceSucceed && mHandler != null) {
            mHandler.post(() -> {
                stopCameraPreview();
                CameraPreviewManager.getInstance().startPreview(glMantleSurfacView,
                        SingleBaseConfig.getBaseConfig().getRgbVideoDirection(),
                        PREFER_WIDTH, PERFER_HEIGH);
                startCameraPreview();
            });

        }
    }

    @Override
    protected void onStop() {
        super.onStop();
        if (mHandler != null) {
            mHandler.post(() -> stopCameraPreview());
        }
    }

    @Override
    public void onResume() {
        super.onResume();

    }
    //返回键监听
    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        if(keyCode == 287 && event.getAction() == KeyEvent.ACTION_DOWN){
            if (DoubClickUtils.onDoubClick()) {
                return true;
            }
            if("PDA".equals(mDeviceModel)){ //东信手持设备
                EventBus.getDefault().post(new PADQREvent());
                return true;
            }

        }
        if (keyCode == KeyEvent.KEYCODE_BACK && event.getAction() == KeyEvent.ACTION_DOWN) {
            if ("PDA".equals(mDeviceModel) && ConfigManager.getAuthenticationBeanListBean().isHideNavigationBar()) {
                return super.onKeyDown(keyCode, event);
            }
            if (DoubClickUtils.onDoubClick()) {
                return true;
            }
            finish();
            return true;
        }
        return super.onKeyDown(keyCode, event);
    }

    public void OnDestoryListener() {
        super.OnDestoryListener();
        if (baiduResultView != null) {
            baiduResultView.onRelease();
        }
        CommonUtil.setLedLight(false);
        EventBus.getDefault().unregister(this);
        AppLogUtils.i(true, TAG, "BaiduFaceActivity, onDestroy()");
        AppHandler.getHandler().removeCallbacks(mPersonCardTimeoutRunnable);
        BaiDuFaceView.getInstance().setViewNull();
        removeBaiduFaceControllerCallback();
        HttpRequest.getInstance().destory();
        isBaiduFaceSucceed = false;
        stopCameraPreview();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        isBaiduFaceSucceed = false;
        isOpenLighet = false;
    }


    /**
     * 激活授权成功之后执行的流程
     */
    @Override
    public void doAfterLicenseSuccess() {
        if (isBaiduFaceSucceed) { //避免多次调用
            AppLogUtils.i(false, "doAfterLicenseSuccess", "doAfterLicenseSuccess 多次调用");
            return;
        }
        isBaiduFaceSucceed = true;
        try {
            //设置身份证阅读器相关
            HttpRequest.getInstance().setupIDCardReader(this);
            ThreadPoolManager.getInstance().execute(new Runnable() {
                @Override
                public void run() {
                    //开机自启动
                    HttpRequest.getInstance().setAutoLaunch();
                }
            });

        } catch (Exception e) {

        }
        initBaiduFaceControllerCallback();
        initListener(); // 初始化模型
        ThreadPoolManager.getInstance().execute(new Runnable() {
            @Override
            public void run() {
                FaceSDKManager.getInstance().initDataBases(MyAppliction.getContext()); //初始化人脸数据库
            }
        });
        FaceSDKManager.getInstance().setActiveLog(false);//百度人脸，关闭日志log, 否则sdk内部会极其高频的输出一大堆 "<line"  开头的log
        initViews();//初始化预览视图控件
        initFaceCheck();//人脸检测的配置参数
        stopCameraPreview();//关闭摄像头
        startCameraPreview();//打开摄像头图像预览

//        queryAllUsers();
    }


    private void initBaiduFaceControllerCallback() {
        BaiduFaceController.getInstance().setBaiduFaceControllerCallback(mBaiduFaceControllerCallback);
    }

    private void removeBaiduFaceControllerCallback() {
        BaiduFaceController.getInstance().setBaiduFaceControllerCallback(null);
    }


    private void queryAllUsers() {

        if (!CommonUtil.isDebug()) {
            return;
        }

/*        List<User> users = FaceApi.getInstance().getAllUserList();
        AppLogUtils.i(false, TAG, "查询人脸库, 所有用户 users.size=" + users.size());

        for (int i = 0; i < users.size(); i++) {
            User user = users.get(i);
            AppLogUtils.i(false, TAG, "查询人脸库, userName=" + user.getUserName());
        }*/


    }


    /**
     * 初始化模型
     */
    private void initListener() {
//        if (FaceSDKManager.initStatus != FaceSDKManager.SDK_MODEL_LOAD_SUCCESS) {
        FaceSDKManager.getInstance().initModel(mContext,
                FaceUtils.getInstance().getBDFaceSDKConfig(), new SdkInitListener() {
                    @Override
                    public void initStart() {
                    }

                    @Override
                    public void initLicenseSuccess() {
                    }

                    @Override
                    public void initLicenseFail(int errorCode, String msg) {
                    }

                    @Override
                    public void initModelSuccess() {
                        FaceSDKManager.initModelSuccess = true;
                        //ToastUtils.toast(mContext, "模型加载成功，欢迎使用");
                        AppLogUtils.i(true, TAG, "模型加载成功，欢迎使用");
                        BaiduFaceUtil.startBaiduFaceWebsocketService();
                    }

                    @Override
                    public void initModelFail(int errorCode, String msg) {
                        FaceSDKManager.initModelSuccess = false;
                        if (errorCode != -12) {
                            ToastUtils.toast(mContext, "模型加载失败，请尝试重启应用");
                            AppLogUtils.e(true, TAG, "模型加载失败，请尝试重启应用, errorCode:" + errorCode + " ,msg:" + msg);
                        }

                        AppLogUtils.e(true, TAG, "模型加载失败，initModelFail, errorCode:" + errorCode + " ,msg:" + msg);

                    }
                });
//        }
    }

    private void initViews() {
        glMantleSurfacView = findViewById(R.id.camera_textureview_baidu);

        glMantleSurfacView.initSurface(SingleBaseConfig.getBaseConfig().getRgbRevert(),
                SingleBaseConfig.getBaseConfig().getMirrorVideoRGB(),
                SingleBaseConfig.getBaseConfig().isOpenGl());

        CameraPreviewManager.getInstance().startPreview(glMantleSurfacView,
                SingleBaseConfig.getBaseConfig().getRgbVideoDirection(),
                PREFER_WIDTH, PERFER_HEIGH);

        //设置结果页视图
        baiDuView_FloatingResultPageFrame = findViewById(R.id.baiDuView_FloatingResultPageFrame);
        baiDuView_GeneralResultPageFrame = findViewById(R.id.baiDuView_GeneralResultPageFrame);
        showResultPage();
        //设置监听回调
        BaiDuFaceView.getInstance().setListener(baiDuFaceViewCallback);
        //设置预览页图片
        iv_please_scanface = findViewById(R.id.iv_please_scanface);
        RequestOptions options = new RequestOptions().placeholder(R.mipmap.please_scanface).error(R.mipmap.please_scanface)
                .diskCacheStrategy(DiskCacheStrategy.NONE).skipMemoryCache(true);
        ImageLoaderUtils.loadImage(ConfigManager.getAuthenticationBeanListBean().getPreviewPageUrl(), iv_please_scanface, options);
        baiduResultView=findViewById(R.id.result_view);
        baiduResultView.setBaiduFaceResultStateCallback(this);
        baiduResultView.setVisibility(View.INVISIBLE);
    }


    private void showResultPage() {
        baiDuView_FloatingResultPageFrame.setVisibility(View.GONE);
        baiDuView_GeneralResultPageFrame.setVisibility(View.GONE);
        if (ConfigManager.isFloatingPages()) {
            //结果页初始化
            BaiDuFaceView.getInstance().ResultView(baiDuView_FloatingResultPageFrame);
        } else {
            //结果页初始化
            BaiDuFaceView.getInstance().ResultView(baiDuView_GeneralResultPageFrame);
        }
    }


    /**
     * 人脸检测的配置参数
     */
    private void initFaceCheck() {
        bdFaceCheckConfig = FaceUtils.getInstance().getBDFaceCheckConfig();
        bdLiveConfig = FaceUtils.getInstance().getBDLiveConfig();
    }

    private void initNirFaceConfig(int height, int width) {
        bdNirFaceImageConfig = new BDFaceImageConfig(height, width,
                SingleBaseConfig.getBaseConfig().getNirDetectDirection(),
                SingleBaseConfig.getBaseConfig().getMirrorDetectNIR(),
                BDFaceSDKCommon.BDFaceImageType.BDFACE_IMAGE_TYPE_YUV_NV21);
    }

    private void initFaceConfig(int height, int width) {
        bdFaceImageConfig = new BDFaceImageConfig(height, width,
                SingleBaseConfig.getBaseConfig().getRgbDetectDirection(),
                SingleBaseConfig.getBaseConfig().getMirrorDetectRGB(),
                BDFaceSDKCommon.BDFaceImageType.BDFACE_IMAGE_TYPE_YUV_NV21);
    }


    /**
     * 打开摄像头图像预览
     */
    private void startCameraPreview() {
        try {
            CameraPreviewManager.getInstance().setCameraFacing(CameraPreviewManager.CAMERA_FACING_BACK);
            int[] cameraSize = CameraPreviewManager.getInstance().initCamera();//initCamera()是真正的开始相机预览画面
            initFaceConfig(cameraSize[1], cameraSize[0]);
            CameraPreviewManager.getInstance().setmCameraDataCallback(new CameraDataCallback() {
                @Override
                public void onGetCameraData(byte[] data, Camera camera, int width, int height) {
                    //AppLogUtils.i(false, TAG, "onGetCameraData(), 摄像头数据返回，data=" + data );
                    dealRgb(data);
                }

            });
            int mCameraNum = Camera.getNumberOfCameras();
            if (mCameraNum < 2) {
                return;
            }
            if (!ConfigManager.getAuthenticationBeanListBean().getCameraType().equals("IR")) {
                return;
            }
            if (SingleBaseConfig.getBaseConfig().getRBGCameraId() != -1) {
                mCamera = Camera.open(Math.abs(SingleBaseConfig.getBaseConfig().getRBGCameraId() - 1));
            } else {
                mCamera = Camera.open(1);
            }
            ViewGroup.LayoutParams layoutParams = irPreviewView.getLayoutParams();
            int w = layoutParams.width;
            int h = layoutParams.height;
            int cameraRotation = SingleBaseConfig.getBaseConfig().getNirVideoDirection();
            mCamera.setDisplayOrientation(cameraRotation);
            if (cameraRotation == 90 || cameraRotation == 270) {
                layoutParams.height = w;
                layoutParams.width = h;
                // 旋转90度或者270，需要调整宽高
            } else {
                layoutParams.height = h;
                layoutParams.width = w;
            }
            irPreviewView.setLayoutParams(layoutParams);
            if (mPreview == null) {
                mPreview = new BaiduPreviewTexture(this, irPreviewView);
            }
            mPreview.setCamera(mCamera, PREFER_WIDTH, PERFER_HEIGH);
            initNirFaceConfig(PERFER_HEIGH, PREFER_WIDTH);
            byte[] buffer = new byte[460800];
            mCamera.addCallbackBuffer(buffer);
            mCamera.setPreviewCallbackWithBuffer(new Camera.PreviewCallback() {
                @Override
                public void onPreviewFrame(byte[] data, Camera camera) {
                    if (camera != null) {
                        camera.addCallbackBuffer(data);
                        dealIr(data);
                    }
                }
            });
        } catch (Exception e) {
            AppLogUtils.e(true, TAG, "startCameraPreview:" + e.toString());
        }


    }

    private void dealRgb(byte[] data) {
//          Log.i("______456","rgb数据"+data.length);

        glMantleSurfacView.setFrame();

        bdFaceImageConfig.setData(data);
        checkData();

    }

    private void dealIr(byte[] data) {
//          Log.i("______456","---------------nir数据"+data.length);
//        SystemClock.sleep(30);
        bdNirFaceImageConfig.setData(data);
        checkData();

    }

    private synchronized void checkData() {
        FaceSDKManager.getInstance().onDetectCheck(bdFaceImageConfig, bdNirFaceImageConfig, null,
                bdFaceCheckConfig, new FaceDetectCallBack() {

                    @Override
                    public void onFaceDetectCallback(LivenessModel livenessModel) {
                        /**
                         注意：onFaceDetectCallback()方法的调用线程，当画面中没有人脸(即livenessModel==null)时该方法在main线程，
                         当画面中有人脸(即livenessModel!=null)时该方法在子线程
                         */

                        //AppLogUtils.i(false, TAG, "onFaceDetectCallback(), livenessModel=" + livenessModel  + "  ,thread=" +Thread.currentThread() );


                        // 设备已过期，不做任何处理
                        if (DeviceExpireManager.getInstance().isDeviceExpire()) {
                            return;
                        }

                        // livenessModel==null 即 画面中没有人脸
                        if (livenessModel == null) {
                            return;
                        }

                        mUser = livenessModel.getUser();//人脸库中匹配到人时getUser()就是非null
                        AppLogUtils.i(false, TAG, "onFaceDetectCallback(), 刷脸结果, livenessModel=" + livenessModel + "  ,isNeedVerify=" + isNeedVerify + " ,checkMode=" + bdFaceCheckConfig.getFeatureCheckMode());

                        if (isNeedVerify) {
                            if(ConfigManager.isNoVerificationFloatingPages()){
                                baiduResultView.baiDuFaceNoVerificationResultPage(livenessModel,
                                        bdFaceCheckConfig.getFeatureCheckMode());
                                return;
                            }
                            mCurLivenessModel = livenessModel;

                            //AppLogUtils.i(false, TAG, "bdFaceCheckConfig.getFeatureCheckMode()=" + bdFaceCheckConfig.getFeatureCheckMode() );

                            if (bdFaceCheckConfig.getFeatureCheckMode() == 3 && ConfigManager.getAuthenticationBeanListBean().getOpenOneToN()) {
                                doScanFaceResult(livenessModel);
                            } else if (bdFaceCheckConfig.getFeatureCheckMode() == 4) {
                                doPersonCardResult(livenessModel);
                            }

                        } else {
                            if (livenessModel != null && livenessModel.getBdNirFaceImageInstance() != null) {
                                livenessModel.getBdNirFaceImageInstance().destory();
                            }
                            if (livenessModel != null && livenessModel.getBdFaceImageInstance() != null) {
                                livenessModel.getBdFaceImageInstance().destory();
                            }
                        }


                    }

                    @Override
                    public void onTip(int code, String msg) {
                        //AppLogUtils.i(false, TAG, "onFaceDetectCallback, onTip(), code=" + code + " ,msg=" + msg);
                    }

                    @Override
                    public void onFaceDetectDarwCallback(LivenessModel livenessModel) {
                        // 绘制人脸框
                        showFrame(livenessModel);
                    }
                });
    }


    /**
     * 绘制人脸框
     *
     * @param livenessModel
     */
    public void showFrame(LivenessModel livenessModel) {
        if (livenessModel == null) {
            return;
        }
        if (glMantleSurfacView == null) {
            return;
        }
        glMantleSurfacView.onGlDraw(livenessModel.getFaceInfo(),
                livenessModel.getBdFaceImageInstance(),
                FaceOnDrawTexturViewUtil.drawFaceColor(mUser, livenessModel), ConfigManager.getAuthenticationBeanListBean().getFaceFollowBoxSwitch());

    }


    /**
     * 关闭摄像头
     */
    private void stopCameraPreview() {
        CameraPreviewManager.getInstance().stopPreview();
        try {
            if (mPreview != null) {
                mPreview.release();
                mPreview = null;
            }
            if (mCamera != null) {
                mCamera.stopPreview();
                mCamera.setPreviewCallbackWithBuffer(null);
                mCamera.setPreviewCallback(null);
                mCamera.release();
                mCamera = null;
            }
        } catch (Exception e) {
            Log.e("qing", "camera destory error");

        }


    }


    private void invoke_StopVerify() {
        AppLogUtils.i(false, TAG, "invoke_StopVerify() ");

        isNeedVerify = false;
    }

    /**
     * 恢复到初始态(即恢复到刷脸态)
     */
    private void invoke_Resume() {
        AppLogUtils.i(false, TAG, "invoke_Resume() ");

        isNeedVerify = true;

        invoke_ScanFace();


    }


    /**
     * 纯刷脸
     */
    private void invoke_ScanFace() {

        isNeedVerify = true;
        bdFaceCheckConfig = FaceUtils.getInstance().getBDFaceCheckConfig();

    }


    /**
     * 刷脸结果处理
     *
     * @param livenessModel
     */
    private void doScanFaceResult(LivenessModel livenessModel) {
        AppLogUtils.i(true, TAG, "doScanFaceResult(), livenessModel= " + livenessModel);
        if (livenessModel == null) {
            return;
        }

        FaceInfo faceInfo = livenessModel.getFaceInfo();

        AppLogUtils.i(false, TAG, "doScanFaceResult(), 人脸信息 faceInfo = " + faceInfo);

        // 比对分值，livenessModel.score只有在人证比对时sdk才设置score值，刷脸时sdk没有设置score值
        float compareScore = livenessModel.getFeatureScore();
        final float idThreshold = SingleBaseConfig.getBaseConfig().getIdThreshold();
        AppLogUtils.i(true, TAG, "doScanFaceResult()，刷脸结果，compareScore=" + compareScore + " ,idThreshold=" + idThreshold + " ,faceInfo.score=" + faceInfo.score);
//        queryAllUsers();
        //livenessModel.user只有在刷脸时sdk才设置user值，人证比对时sdk没有设置user值
        User user = livenessModel.getUser();
        AppLogUtils.i(true, TAG, "doScanFaceResult()，刷脸结果user=" + user);

        if (user == null) {//人脸库中没有找到对应的人

            AppLogUtils.i(true, TAG, "doScanFaceResult(), user == null " + " 抱歉 未能认出您");
            //1:N未通过判断是否显示提示语，不显示则不做处理
            if (ConfigManager.getAuthenticationBeanListBean().getOneToNFailShowTip()) {
                currentTime = System.currentTimeMillis();
                if (startTime == 0 || ((currentTime - startTime) > (ConfigManager.getAuthenticationBeanListBean().getOneToNContinueFailTime() * 1000) + 500)) {
                    startTime = currentTime;
                }
                if ((currentTime - startTime) > (ConfigManager.getAuthenticationBeanListBean().getOneToNContinueFailTime() * 1000)) {
                    TaskStatus.setStatus(TaskStatus.TASK_STATUS_FACE);
                    TaskStatus.setCurrentTask(TaskStatus.CURRENT_TASSK_LOCAL_FACE);
                    invoke_StopVerify();
                    faceFailedHandler.removeCallbacksAndMessages(null);
                    faceFailedHandler.post(new Runnable() {
                        @Override
                        public void run() {
                            //判断失败进出记录是否开启，且类型包含1：N刷脸失败类型
                            sendPushFailed(3,livenessModel.getBdFaceImageInstance());
                            String failText = "";
                            if (!StringIsNull.IsStringNull(ConfigManager.getAuthenticationBeanListBean().getFailText())) {
                                failText = ConfigManager.getAuthenticationBeanListBean().getFailText();
                            }
                            doPersonCardResult_fail(failText, ConfigManager.getAuthenticationBeanListBean().getFailVoice());
                        }
                    });
                }
            }

        } else {//人脸库中找到对应的人

            //销毁1:N人脸连续未通过的Runnable
            faceFailedHandler.removeCallbacksAndMessages(null);

            doScanFaceResult_Success(livenessModel);
            AppLogUtils.i(false, TAG, "doScanFaceResult(), " + user.getUserName() + " 欢迎您");

        }

    }


    /**
     * 纯刷脸成功后执行
     *
     * @param livenessModel
     */
    private void doScanFaceResult_Success(LivenessModel livenessModel) {
        AppLogUtils.i(true, TAG, "doScanFaceResult_Success() ");
        User user = livenessModel.getUser();
        if (user == null) {
            return;
        }
        //同人脸判断是否在规定时间内
        if (userIdUniqueId.equals(StringIsNull.ReturnString(user.getUserId()))){
            return;
        }
        invoke_StopVerify();
        TaskStatus.setStatus(TaskStatus.TASK_STATUS_FACE);
        TaskStatus.setCurrentTask(TaskStatus.CURRENT_TASSK_LOCAL_FACE);

        String faceRequestParams = BaiduFaceUtil.getScanFaceRequestParams(user);

        //setAuthCodeOrVid(jsonObject,extInfoJsonObject);
        //重置现场照片、姓名、身份证号等用户信息
        setUserInformationBean(livenessModel);
        //销毁按钮
        ClickButtonFloatView.getInstance().removeClickButtonFloatView();
        DataReturns.getInstance().clearData();
        //判断用户是否在有效期内
        if (ConfigManager.getAuthenticationBeanListBean().getValidTimeSwitch() && isUserExpire(user)) {
            return;
        }
        //判断黑名单中是否存在该用户
        if (BlacklistManager.getInstance().isInBlacklist(user.getIdNumber(), user.getPhone())) {
            //展示了阻止通行结果页，直接return掉，不做后续逻辑处理
            AppLogUtils.e(true, TAG + " ,黑名单", "doScanFaceResult_Success(), 用户在黑名单中");
            return;
        }

        //判断年龄限制是否打开
        if (ConfigManager.isAgeLimitOpen(user.getIdNumber(), user.getUserId())) {
            AppLogUtils.e(true, TAG + " ,年龄限制", "doScanFaceResult_Success(), 用户年龄限制不符合");
            return;
        }

        //判断1：N刷脸 同人脸间隔
        if(ConfigManager.getAuthenticationBeanListBean().getSameFaceInterval() > 0){
            userIdUniqueId = StringIsNull.ReturnString(user.getUserId());
            //销毁延时器，重新计时
            AppHandler.getHandler().removeCallbacks(userIdUniqueIdRunnable);
            AppHandler.getHandler().postDelayed(userIdUniqueIdRunnable,
                    ConfigManager.getAuthenticationBeanListBean().getSameFaceInterval() * 1000);
        }

        AppLogUtils.i(true, TAG, "doScanFaceResult_Success(), 请求结果页");

        Constants.IDCARD_TYPE = 0;
        //判断商户平台是否开启 - 开启后则直接通过商户平台进行请求
        if (ConfigManager.getAuthenticationBean().getData().get(0).getTenantSwitch()) {
            AppLogUtils.i(true, TAG, "刷脸成功, 商户平台开启");
            HttpRequest.getInstance().requestThirdPartyPlatforms(faceRequestParams, livenessModel.getUser().getUserId(), livenessModel.getFeatureScore());
        } else {
            AppLogUtils.i(true, TAG, "刷脸成功, 商户平台未开启");
            FederatedPlatformsRequestBean.ExtInfoDTO exInfoDTO = new FederatedPlatformsRequestBean.ExtInfoDTO();
            exInfoDTO.setPassRes("");
            //exInfoDTO.setSmileParams(faceRequestParams);
            exInfoDTO.setHhfaceParams(faceRequestParams);
            exInfoDTO.setIdcardContent("");
            ConfigManager.setFederatedPlatformsRequestBean(ConfigManager.SN, Constants.IDCARD_TYPE,
                    UserInfoManager.getInstance().getUserInformationBean().getIdNumber(),
                    UserInfoManager.getInstance().getUserInformationBean().getName(),
                    UserInfoManager.getInstance().getUserInformationBean().getMobile(),
                    "check", "", "", "", exInfoDTO, "", "",
                    UserInfoManager.getInstance().getUserInformationBean().getCardIdEx());
            if (ConfigManager.isPreCheck()) {//预检查模式
                DataReturns.getInstance().doDataReturns(null, faceRequestParams);
                HttpRequest.getInstance().requestFederatedPlatformsCheck(true);
            } else {//通用模式
                HttpRequest.getInstance().requestFederatedPlatforms();
            }
        }

        //BaiduFaceUtil.testShowWindowManagerView();


    }

    /**
     * 判断用户是否过期
     *
     * @param user 用户
     * @return 是否过期
     */
    private boolean isUserExpire(User user) {
        if (user == null) {
            return false;
        }

        long startTime = user.getStartTime();
        long endTime = user.getEndTime();
        long curTime = System.currentTimeMillis();
        if (curTime <= startTime){
            AppLogUtils.e(true, TAG + " ,用户是否过期", "doScanFaceResult_Success(), 用户未到有效时间");
            FederatedPlatformsResponseBean federatedPlatformsResponseBean = DataManager.getInstance().getErrorOutcome("LocalError_B", "未到有效时间", 500, "未到有效时间");
            BaiDuFaceView.getInstance().getPlatformsCod(federatedPlatformsResponseBean);
            return true;
        }
        if (curTime >= endTime){
            AppLogUtils.e(true, TAG + " ,用户是否过期", "doScanFaceResult_Success(), 用户已过期");
            FederatedPlatformsResponseBean federatedPlatformsResponseBean = DataManager.getInstance().getErrorOutcome("LocalError_B", "已过期", 500, "已过期");
            BaiDuFaceView.getInstance().getPlatformsCod(federatedPlatformsResponseBean);
            return true;
        }
//        //已过期
//        if (curTime <= startTime || curTime >= endTime) {
//
//            FederatedPlatformsResponseBean federatedPlatformsResponseBean = DataManager.getInstance().getErrorOutcome("LocalError_B", "不在有效期", 500, "不在有效期");
//            BaiDuFaceView.getInstance().getPlatformsCod(federatedPlatformsResponseBean);
//
//            return true;
//        }
        return false;
    }

    private void setUserInformationBean(LivenessModel livenessModel) {
        if (livenessModel == null) {
            return;
        }
        User user = livenessModel.getUser();

        if (user == null) {
            return;
        }
        String userName = user.getUserName();
        String idNumber = user.getIdNumber();
        String phone = user.getPhone();
        String photo = user.getPhoto();
        String cardIdEx = user.getCardIdEx();
        String userId = user.getUserId();
        String scenePhotoUrl = user.getPhoto();
        UserInfoManager.getInstance().setUserInformationBean(userName, idNumber, "", photo, phone, cardIdEx, userId, livenessModel.getFeatureScore(), scenePhotoUrl);
        //人脸图片
        BDFaceImageInstance rgbImage = livenessModel.getBdFaceImageInstance();
        if (rgbImage != null) {
            Bitmap bitmap = BitmapUtils.getInstaceBmp(rgbImage);
//            Log.e("","-------------重置现场照片6");
//            byte[] photoByteArray = BitmapUtils.bitmapToBytes(bitmap);
//            String photoBase64Str = CommonUtil.byteArrayToBase64String(photoByteArray);
//            String photoBase64Str = CommonUtil.bitmapToString(bitmap);
            String photoBase64 = ConfigManager.bitmapToString(bitmap);
            UserInfoManager.getInstance().setUserInformationBean(userName, idNumber, "", photoBase64, phone, bitmap, cardIdEx, userId, livenessModel.getFeatureScore(), scenePhotoUrl);
        } else {
            AppLogUtils.e(true, TAG, "updateScenePhoto(), bdFaceImageInstance == null, 结果页无法显示现场照片");
        }

    }


    /**
     * 更新现场照片
     *
     * @param livenessModel
     */
    private void updateUserInformationBean_ScenePhoto(LivenessModel livenessModel) {
/*        String avatarBase64 = "";
        if (s1JsonObject.containsKey(SMILE_AVATAR_BASE64)) {
            //端上透出的⼈脸图，可⽤于展示。
            avatarBase64 = s1JsonObject.getString(SMILE_AVATAR_BASE64);
        }
        //更新本地数据中的现场照片
        UserInfoManager.getInstance().updateUserInformationBean_ScenePhoto(avatarBase64);*/

        if (livenessModel == null) {
            return;
        }

        //人脸图片
        BDFaceImageInstance faceImage = livenessModel.getBdFaceImageInstance();
        if (faceImage != null) {
            Bitmap bitmap = BitmapUtils.getInstaceBmp(faceImage);
            byte[] photoByteArray = BitmapUtils.bitmapToBytes(bitmap);
            String photoBase64Str = CommonUtil.byteArrayToBase64String(photoByteArray);
            UserInfoManager.getInstance().updateUserInformationBean_ScenePhoto(photoBase64Str);

        } else {
            AppLogUtils.e(true, TAG, "updateScenePhoto(), bdFaceImageInstance == null, 结果页无法显示现场照片");
        }


    }


    /********** 人证比对相关逻辑 **********/

    /**
     * 人证比对的时间，PERSONCARD_TIMEOUT 的时间内只要有一次人证比对成功则本次人证比对就是成功，
     * 否则在 PERSONCARD_TIMEOUT 的时间内如果都是比对失败则本次人证比对失败
     */

    private final Runnable mPersonCardTimeoutRunnable = new Runnable() {
        @Override
        public void run() {
            doPersonCardResult_fail("比对超时", "比对超时");
        }
    };
    //判断1：1人脸连续未通过的runnable是否启动
    boolean isCreatedRunnable = false;

    /**
     * 1：N、1：1 刷脸失败进出记录推送
     * @param type
     */
    private void sendPushFailed(int type, BDFaceImageInstance rgbImage) {
        if (!ConfigManager.getAuthenticationBeanListBean().isPushFailedRecordSwitch()){
            AppLogUtils.e(false,"刷脸失败记录推送","刷脸失败记录推送 - 检测到未开启失败记录推送，直接return");
            return;
        }
        if (!ConfigManager.getAuthenticationBeanListBean().getPushFailedRecordType().contains(type)){
            AppLogUtils.e(false,"刷脸失败记录推送","刷脸失败记录推送 - 检测到失败类型中不包含当前类型，直接return  type = "+type);
            return;
        }
        String base64 = "";
        if (rgbImage != null) {
            Bitmap bitmap = BitmapUtils.getInstaceBmp(rgbImage);
            base64 = ConfigManager.bitmapToString(bitmap);
        }
        HttpRequest.getInstance().setEventRecords(TaskStatus.currentTask,
                UserInfoManager.getInstance().getUserInformationBean().getName(),
                UserInfoManager.getInstance().getUserInformationBean().getIdNumber(),
                base64, "", UserInfoManager.getInstance().getUserInformationBean().getMobile(),
                false, type, UserInfoManager.getInstance().getUserInformationBean().getCardIdEx(), "",null);
    }
    //1:N人脸连续未通过
    private final Runnable FaceErrorRunnable = new Runnable() {
        @Override
        public void run() {
            String failText = "";
            if (!StringIsNull.IsStringNull(ConfigManager.getAuthenticationBeanListBean().getFailText())) {
                failText = ConfigManager.getAuthenticationBeanListBean().getFailText();
            }
            doPersonCardResult_fail(failText, ConfigManager.getAuthenticationBeanListBean().getFailVoice());
        }
    };
    //1:1人脸连续未通过
    private final Runnable personCardFaceErrorRunnable = new Runnable() {
        @Override
        public void run() {
            String failText = "比对失败";
            doPersonCardResult_fail(failText, failText);
        }
    };


    /**
     * 人证比对
     */
    public void invoke_PersonCard(String cardName, String cardNo, String cardPhotoBase64Str) {
        AppLogUtils.e(true, TAG, "invoke_PersonCard()");

        if (StringUtils.isEmpty(cardPhotoBase64Str)) {
            AppLogUtils.e(true, TAG, "invoke_PersonCard(), 证件照片为空，无法人证比对");
            String msg = "证件照片为空，无法人证比对";
            doPersonCardResult_fail(msg, msg);
            return;
        }

        Bitmap cardPhotoBitmap = ConfigManager.stringToBitmap(cardPhotoBase64Str);

        if (cardPhotoBitmap == null) {
            AppLogUtils.e(true, TAG, "invoke_PersonCard(), cardPhotoBitmap == null，无法人证比对");
            String msg = "证件照片cardPhotoBitmap == null，无法人证比对";
            doPersonCardResult_fail(msg, msg);
            return;
        }

        byte[] secondFeature = new byte[512];
        // 提取特征值, 图片特征值提取成功的ret值是128
/*        float ret = FaceSDKManager.getInstance().personDetect(cardPhotoBitmap, secondFeature,
                com.baidu.idl.main.facesdk.identifylibrary.utils.FaceUtils.getInstance().getBDFaceCheckConfig(), this);*/

        float ret = FaceSDKManager.getInstance().personDetect(cardPhotoBitmap, secondFeature, bdFaceCheckConfig, this);

        if (ret != 128) {
            AppLogUtils.e(true, TAG, "invoke_PersonCard(), 照片特征提取失败，无法人证比对，ret=" + ret);
            String msg = "证件照片特征提取失败，无法人证比对";
            doPersonCardResult_fail(msg, msg);
            return;
        }

        invoke_PersonCard(secondFeature);

    }

    public void invoke_PersonCard(byte[] secondFeature) {
        AppLogUtils.e(true, TAG, "invoke_PersonCard()， secondFeature=" + secondFeature);
        AppHandler.getHandler().removeCallbacks(mPersonCardTimeoutRunnable);
        //立刻发送人证比对超时的Runnable
        AppHandler.getHandler().postDelayed(mPersonCardTimeoutRunnable, ConfigManager.getAuthenticationBean().getData().get(0).getOneToOneTimeout() * 1000);

        isNeedVerify = true;

        bdFaceCheckConfig.setSecondFeature(secondFeature);

        bdFaceCheckConfig.setFeatureCheckMode(4);

    }


    /**
     * 人证比对结果处理
     *
     * @param livenessModel
     */
    private void doPersonCardResult(LivenessModel livenessModel) {
        AppLogUtils.i(true, TAG, "doPersonCardResult(), livenessModel=" + livenessModel);
        if (livenessModel == null) {
            return;
        }
        // 人脸识别阈值判断
        // 比对分值，相似度分数
        float compareScore = livenessModel.getScore();
        float idThreshold = SingleBaseConfig.getBaseConfig().getIdThreshold();

        if (!ConfigManager.getAuthenticationBeanListBean().getLivingControl()) {  //活体检测未开启
            doPersonCardComparison(compareScore, idThreshold, livenessModel);

        } else {    //活体检测开启
            //活体阈值判断显示
            float rgbLivenessScore = livenessModel.getRgbLivenessScore();
            float rgbLivenessThreshold = bdLiveConfig.rgbLiveScore;//rgb活体阈值
            AppLogUtils.i(false, TAG, "doPersonCardResult(), 人证比对，rgbLivenessScore=" + rgbLivenessScore + " ,rgbLivenessThreshold=" + rgbLivenessThreshold
                    + " ,compareScore=" + compareScore + " ,idThreshold=" + idThreshold);

            if (rgbLivenessScore >= rgbLivenessThreshold) {
                doPersonCardComparison(compareScore, idThreshold, livenessModel);
            } else {
                AppLogUtils.i(true, TAG, "doPersonCardResult(), 人证比对失败，活体检测未通过");
            }
        }

    }

    private void doPersonCardComparison(float compareScore, float idThreshold, LivenessModel livenessModel) {
        if (compareScore >= idThreshold) {
            AppLogUtils.i(true, TAG, "doPersonCardResult(), 人证比对成功");
            //销毁1:1人脸连续未通过的Runnable
            faceFailedHandler.removeCallbacksAndMessages(null);
            UserInfoManager.getInstance().updateUserInformationBean_VerifyScore(compareScore);
            AppHandler.getHandler().post(new Runnable() {
                @Override
                public void run() {
                    doPersonCardResult_Success(livenessModel);
                }
            });

        } else {
            AppLogUtils.i(true, TAG, "doPersonCardResult(), 人证比对失败，人脸比对阈值未达到");
            if (!isCreatedRunnable) {
                isCreatedRunnable = true;
                faceFailedHandler.removeCallbacksAndMessages(null);
                faceFailedHandler.postDelayed(new Runnable() {
                    @Override
                    public void run() {
                        //判断失败进出记录是否开启，且类型包含1：1刷脸失败类型
                        UserInfoManager.getInstance().updateUserInformationBean_VerifyScore(compareScore);
                        sendPushFailed(4,livenessModel.getBdFaceImageInstance());
                        String failText = "比对失败";
                        doPersonCardResult_fail(failText, failText);
                    }
                }, ConfigManager.getAuthenticationBeanListBean().getOneToOneContinueFailTime() * 1000);
            }
        }
    }

    private void doPersonCardResult_Success(LivenessModel livenessModel) {
        AppLogUtils.i(true, TAG, "doPersonCardResult_Success()");

        AppHandler.getHandler().removeCallbacks(mPersonCardTimeoutRunnable);

        invoke_StopVerify();

        //更新现场照片
        updateUserInformationBean_ScenePhoto(livenessModel);

        String faceRequestParams = BaiduFaceUtil.getPersonCardRequestParams();
        //ConfigManager.updateFederatedPlatformsRequestBean_SmileParams(s1);
        ConfigManager.updateFederatedPlatformsRequestBean_hhfaceParams(faceRequestParams);

        if (ConfigManager.isPreCheck()) {//预检查模式
            AppLogUtils.i(true, TAG, "开启人证比对，开启预检查：人证比对成功，通知调度中心处理");
            DataReturns.getInstance().doDataReturns(null, faceRequestParams);
        } else {//通用模式
            HttpRequest.getInstance().requestFederatedPlatforms();
        }

    }

    private void doPersonCardResult_fail(String msg, String openVoiceMsg) {
        AppLogUtils.i(true, TAG, "doPersonCardResult_fail(), msg=" + msg);

        AppHandler.getHandler().removeCallbacks(mPersonCardTimeoutRunnable);

        invoke_StopVerify();
        if (StringIsNull.IsStringNull(openVoiceMsg)) {
            openVoiceMsg = msg;
        }
        FederatedPlatformsResponseBean federatedPlatformsResponseBean = DataManager.getInstance().getErrorOutcome("LocalError_B", msg, 500, openVoiceMsg, true);
        isCreatedRunnable = false;
        startTime = 0L;

        if (baiduResultView != null && ConfigManager.isNoVerificationFloatingPages()) {
            baiduResultView.showFailUI(msg, openVoiceMsg);
            return;
        }

        if (ConfigManager.isPreCheck()) {
            AppLogUtils.i(false, TAG, "doPersonCardResult_fail(), 预检查");
            DataReturns.getInstance().doDataReturns(federatedPlatformsResponseBean, DataReturns.FACE_DATA_VIRTUAL);
        } else {
            AppLogUtils.i(false, TAG, "doPersonCardResult_fail()， 通用模式");
            BaiDuFaceView.getInstance().getPlatformsCod(federatedPlatformsResponseBean);
        }

    }


    /**
     * @author xwh
     * Time 2024/10/19
     * Description: 补光灯
     **/
    @Subscribe(threadMode = ThreadMode.MAIN)
    public void ledLight(LedLightEvent event) {
        if (event == null || mHandler == null) {
            return;
        }
        if (event.isOpenLedLight()) {  //
            isOpenLighet = true;
            mHandler.removeMessages(WHAT_HIDE_LEDLIGHT);
            CommonUtil.setLedLight(true);
        } else if (isOpenLighet) {
            isOpenLighet = false;
            mHandler.removeMessages(WHAT_HIDE_LEDLIGHT);
            mHandler.sendEmptyMessageDelayed(WHAT_HIDE_LEDLIGHT, event.getDelay());
        }

    }
    @Subscribe(threadMode = ThreadMode.MAIN)
    public void showOneToOneUIEvent(FaceOneToOneWaitEvent event) {
        if (event == null || baiduResultView == null) {
            return;
        }
        baiduResultView.showOneToOneComparisonWaitUi(event.getMsgStrString(),event.getVoiceStr());
    }



    @Override
    public void invokeStopVerify() {
        AppHandler.getHandler().removeCallbacks(mPersonCardTimeoutRunnable);
        invoke_StopVerify();
    }

    @Override
    public void invokeResume() {
        isNeedVerify = true;
        if(bdFaceCheckConfig==null){
            bdFaceCheckConfig=FaceUtils.getInstance().getBDFaceCheckConfig();
        }
        bdFaceCheckConfig.setFeatureCheckMode(3);
        AppHandler.getHandler().removeCallbacks(mPersonCardTimeoutRunnable);
    }
}