FaceScenic/app/src/main/java/com/hanghui/senic/network/HttpRequest.java

package com.hanghui.senic.network;

import android.app.AlarmManager;
import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.icu.util.Calendar;
import android.os.Build;
import android.os.Handler;
import android.util.Log;

import com.alibaba.fastjson.JSONObject;
import com.baidu.idl.main.facesdk.model.BaseConfig;
import com.baidu.idl.main.facesdk.model.SingleBaseConfig;
import com.common.pos.api.util.PosUtil;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import com.hanghui.senic.MyAppliction;
import com.hanghui.senic.activity.view.BaiDuFaceView;
import com.hanghui.senic.activity.view.ResultViewManager;
import com.hanghui.senic.baiduface.BaiduFaceController;
import com.hanghui.senic.bean.AlipayUserInfoBean;
import com.hanghui.senic.bean.AuthenticationBean;
import com.hanghui.senic.bean.BlacklistConfigBean;
import com.hanghui.senic.bean.DecryptBean;
import com.hanghui.senic.bean.FederatedPlatformsResponseBean;
import com.hanghui.senic.bean.FederatedPlatformsRequestBean;
import com.hanghui.senic.bean.SpecialCodeTradeThreeElementsBean;
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.DeviceInitManager;
import com.hanghui.senic.common.DoorMagneticSignalManager;
import com.hanghui.senic.common.EncryptionAndDecryptionUtil;
import com.hanghui.senic.common.PosManager;
import com.hanghui.senic.common.TaskStatus;
import com.hanghui.senic.common.UserInfoManager;
import com.hanghui.senic.common.contract.ContractInterface;
import com.hanghui.senic.common.gson.CompleteDataUtil;
import com.hanghui.senic.controller.BlacklistManager;
import com.hanghui.senic.controller.IDCardControllerManager;
import com.hanghui.senic.controller.PassportController;
import com.hanghui.senic.controller.QRCodeController;

import com.hanghui.senic.controller.SerialController;
import com.hanghui.senic.model.MyModel;
import com.hanghui.senic.presenter.MyPresenter;
import com.hanghui.senic.receiver.RebootReceiver;
import com.hanghui.senic.service.CheckExitService;
import com.hanghui.senic.service.FilterRepeatDataService;
import com.hanghui.senic.service.usbserialdemo.utile.ConfigManager;
import com.hanghui.senic.service.usbserialdemo.utile.DateUtil;
import com.hanghui.senic.service.usbserialdemo.utile.PopupWindowManager;
import com.hanghui.senic.network.retorfit.RetrofitUtil;
import com.hanghui.senic.service.usbserialdemo.utile.SharedPreferencesUtils;
import com.hanghui.senic.service.usbserialdemo.utile.StringIsNull;
import com.hanghui.senic.service.usbserialdemo.utile.VolumeUtil;
import com.hanghui.senic.service.usbserialdemo.utile.X1.RelaysAndLedUtile;
import com.hanghui.senic.service.usbserialdemo.utile.devicesUI.BaseDeviceUI;
import com.hanghui.senic.service.usbserialdemo.utile.loacat.AppLogUtils;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.lang.reflect.Type;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;

public class HttpRequest {
    public ContractInterface.PAuthentication pAuthentication;
    public ContractInterface.PUserwithftoken pUserwithftoken;
    public ContractInterface.PLogUploads pLogUploads;
    public ContractInterface.PDevice pDevice;
    private static HttpRequest instance;
    MyModel myModel;

    private HttpRequest() {
        myModel = new MyModel();
        pAuthentication = new MyPresenter(CommonUtil.getCurrentActivity());
        pUserwithftoken = new MyPresenter(CommonUtil.getCurrentActivity());
        pDevice = new MyPresenter(CommonUtil.getCurrentActivity());
        pLogUploads = new MyPresenter(this);
    }

    public static HttpRequest getInstance() {
        synchronized (HttpRequest.class) {
            if (instance == null) {
                instance = new HttpRequest();
            }
        }
        return instance;
    }

    //接口请求失败
    private Runnable requestConfigRunnable = new Runnable() {
        @Override
        public void run() {
            httpResponseCallback.updateView(Constants.Code_HttpResponseCallback_BottomTextPrompt, "获取在线配置中……");
            HttpRequest.getInstance().requestAuthentication();
        }
    };
    /**
     * 获取设备在线配置
     */
    private boolean isSQLCrashLogUpload = false;//判断是否上报本地数据库日志
    private boolean isAgainRequest = false;//是否再次请求 默认false

    /**
     * 请求在线配置
     */
    public void requestAuthentication() {
        pAuthentication.PAuthentication(ConfigManager.SN, ConfigManager.token, new MyPresenter.DataResponseCallback() {
            @Override
            public void onDataResponse(Object os) {
                AuthenticationBean authenticationBean = (AuthenticationBean) os;
                AppHandler.getHandler().removeCallbacks(requestConfigRunnable);
                AppLogUtils.e(false, "", "在线配置返回后销毁网络异常的悬浮框");
                PopupWindowManager.getInstance().dismissNetWorkpopupWindow();
                if (authenticationBean.getCode() != 200) {
                    if (isAgainRequest) { //第二次请求还是失败时才显示"在线配置获取失败，启用上一次本地配置"的提示文字
                        String promptMessage = ConfigManager.localConfiguration();
                        httpResponseCallback.updateView(Constants.Code_HttpResponseCallback_BottomTextPrompt, promptMessage);
                        return;
                    }
                    //在线配置获取失败
                    String msgs = authenticationBean.getMsg();
                    if (StringIsNull.IsStringNull(msgs)) {
                        msgs = "在线配置获取失败";
                    }
                    if (msgs.equals("设备商户平台未授权")) {
                        msgs = "设备授权平台未授权,请联系设备厂商";
                        httpResponseCallback.updateView(Constants.Code_HttpResponseCallback_BottomTextPrompt, msgs);
                        return;
                    }
                    httpResponseCallback.updateView(Constants.Code_HttpResponseCallback_BottomTextPrompt, msgs + "(3秒后重试)");
                    isAgainRequest = true;
                    postRequestConfigRunnable(3 * 1000);
                    return;
                }
                httpResponseCallback.updateView(Constants.Code_HttpResponseCallback_InternetAvailable, "设置网络正常图标");
                ConfigManager.isConfigRequestSuccess = true;
                try {
                    parseConfiguration(ConfigManager.getGson().toJson(os));
                } catch (Exception e) {
                    e.printStackTrace();
                }
                RetrofitUtil.setutilNull();//获取到配置后RetrofitUtil置为null，下次使用时才能重新创建实例，才能重新设置在线配置的超时时间
            }
        });
    }

    /**
     * 在线获取到配置 以及 本地缓存读取到配置 后都会执行parseConfiguration这个方法
     * @param jsonData
     */
    public void parseConfiguration(String jsonData) {
        if (StringIsNull.IsStringNull(jsonData)) {
            AppLogUtils.e(true, "设备配置项", "检测到在线配置数据为空,请检查传递数据是否正常, jsonData=" + jsonData);
            return;
        }
        AuthenticationBean authenticationBean = ConfigManager.getGson().fromJson(jsonData, AuthenticationBean.class);
        //补全数据，防止数据为空的情况
        authenticationBean = CompleteDataUtil.completeConfigurationBean(authenticationBean);
        //补全数据类型为int、boolean类型的字段
        CompleteDataUtil.completeData(authenticationBean);
        //保存在线配置到本地数据库
        List<String> list = MyAppliction.getmDbDao().queryData("data");
        if (list.size() > 0) {
            MyAppliction.getmDbDao().delete("data");
        }
        MyAppliction.getmDbDao().insertData("data", jsonData);
        //更新配置项
        ConfigManager.UpdateConfiguration(authenticationBean);
        if (ConfigManager.isUpdateConfig){
            return;
        }
        //将设备是否首次打开状态修改
        SharedPreferencesUtils.setParam(MyAppliction.getContext(), "forTheFirstTime", false);
        //弹框提示设备到期时间
        AppHandler.getHandler().postDelayed(new Runnable() {
            @Override
            public void run() {
                httpResponseCallback.updateView(Constants.Code_HttpResponseCallback_HideBottomTextView, "隐藏底部文字");
                initConfigIfDeviceNotExpiration();
            }
        }, 2 * 1000); //延迟2秒，等待"获取在线配置中……"的提示文字显示一段时间
    }

    /**
     * 设备是否过期的相关判断逻辑，如果已经过期则弹出过期提示框提示设备不能使用，如果没有过期则执行后续的外设初始化的流程
     *
     */
    private void initConfigIfDeviceNotExpiration() {
        //当到期时间为空时，直接初始化
        if (StringIsNull.IsStringNull(ConfigManager.getAuthenticationBean().getData().get(0).getExpirationDate())) {
            initConfig();
            httpResponseCallback.updateView(Constants.Code_HttpResponseCallback_ShowBottomTextView, "显示底部文字");
            return;
        }
        String startTime = ConfigManager.getNetworkTime();//获取网络时间
        String endTime = ConfigManager.getAuthenticationBean().getData().get(0).getExpirationDate();
        String timeRangeData = "";
        try {
            timeRangeData = String.valueOf(DateUtil.getTimeRange(startTime, endTime));
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }
        if (StringIsNull.IsStringNull(timeRangeData)) {//计算时间差的值为空，则不做任何处理，直接return
            return;
        }
        int timeRange = Integer.parseInt(timeRangeData);
        if (timeRange > 30) {//距离过期大于30天则不显示，直接进行初始化操作
            initConfig();
            httpResponseCallback.updateView(Constants.Code_HttpResponseCallback_ShowBottomTextView, "显示底部文字");
        } else {//距离过期小于等于30天，则显示到期时间提示框
            PopupWindowManager.getInstance().getExpirationTimeFloat(timeRange);
            PopupWindowManager.getInstance().setListener(new PopupWindowManager.OnClickListener() {
                @Override
                public void OnClickListener() {
                    initConfig();
                    httpResponseCallback.updateView(Constants.Code_HttpResponseCallback_ShowBottomTextView, "显示底部文字");
                }
            });

        }

        //timeRange < 0 表示已经过期
        if (timeRange < 0) {
            DeviceExpireManager.getInstance().setDeviceExpire(true);
        } else {
            DeviceExpireManager.getInstance().setDeviceExpire(false);
        }

    }

    private void initConfig() {
        //底部文字提示
        httpResponseCallback.updateView(Constants.Code_HttpResponseCallback_BottomTextPrompt, "在线配置获取成功");
        //主页背景图片
        httpResponseCallback.updateView(Constants.Code_HttpResponseCallback_HomeBackgroundImage, "主页背景图片");
        //崩溃日志上报
        //crashLogUpload();
        //设置百度face配置项
        setBaiDuFaceConfig();
        //设置音量
        setMediaVolume();
        //设置下拉通知栏及导航栏
        setNotificationAndNavigationBar();
        //开机自启动
        setAutoLaunch();
        //补光灯设置
        RelaysAndLedUtile.getInstance().setLedLight(ConfigManager.getAuthenticationBeanListBean().getLightMode(), false);

        //设置硬件开启的总数量
        setTotalHardwareOpenNum();
        httpResponseCallback.updateView(Constants.Code_HttpResponseCallback_StartHardware,"硬件启动");
        //设置身份证阅读器相关
        setupIDCardReader();
        //二维码启动或关闭
        setupQRCode();
        //护照机是否开启
        setupSmileAndPassport();
        //IC卡启动
        setICCardReader();
//        //smile服务
//        setStartSmileService();

        //设置SystemType
        setSystemType();
        //串口相关
        setSerialPort();
        //门磁信号相关
        SetPushGm();
        //定时重启是否开启
        setScheduledRestart();

        //黑名单配置
        BlacklistConfig();
        //启动滤重时间
        if (ConfigManager.getAuthenticationBean().getData().get(0).getInOutFilterRepeatTime() > 0) {
            FilterRepeatDataService.start(CommonUtil.getCurrentActivity());
        }
    }

    private void setBaiDuFaceConfig() {
        BaseConfig baseConfig = SingleBaseConfig.getBaseConfig();
        baseConfig.setBestImageScore(ConfigManager.getAuthenticationBeanListBean().getBestImageScore());
        baseConfig.setBestImage(ConfigManager.getAuthenticationBeanListBean().getUsingBestImage());
        baseConfig.setQualityControl(ConfigManager.getAuthenticationBeanListBean().getQualityControl());
        baseConfig.setBlur(ConfigManager.getAuthenticationBeanListBean().getBlur());
        baseConfig.setIllumination(ConfigManager.getAuthenticationBeanListBean().getIllum());
        if (!ConfigManager.getAuthenticationBeanListBean().getLivingControl()){
            baseConfig.setLivingControl(false);
            baseConfig.setType(0);
        } else {
            //设置活体检测模式
            baseConfig.setLivingControl(true);
            baseConfig.setType(ConfigManager.getAuthenticationBeanListBean().getLiveType());
        }

        baseConfig.setRgbLiveScore(ConfigManager.getAuthenticationBeanListBean().getRgbLiveScore());
        baseConfig.setNirLiveScore(ConfigManager.getAuthenticationBeanListBean().getNirLiveScore());
        baseConfig.setDepthLiveScore(ConfigManager.getAuthenticationBeanListBean().getDepthLiveScore());
        baseConfig.setMinimumFace(ConfigManager.getAuthenticationBeanListBean().getMinFaceSize());
        baseConfig.setRgbVideoDirection(ConfigManager.getAuthenticationBeanListBean().getRgbVideoDirection());
        baseConfig.setRgbDetectDirection(ConfigManager.getAuthenticationBeanListBean().getRgbDetectDirection());
        baseConfig.setNirDetectDirection(ConfigManager.getAuthenticationBeanListBean().getNirDetectDirection());
        baseConfig.setNirVideoDirection(ConfigManager.getAuthenticationBeanListBean().getNirVideoDirection());
        //1:1比对阈值
        baseConfig.setIdThreshold(ConfigManager.getAuthenticationBeanListBean().getOneToOneScoreThreshold());
        //1：N比对阈值
        baseConfig.setLiveThreshold(ConfigManager.getAuthenticationBeanListBean().getOneToNScoreThreshold());
        baseConfig.setRgbAndNirThreshold(ConfigManager.getAuthenticationBeanListBean().getOneToNScoreThreshold());
        baseConfig.setOneToNFailShowTip(ConfigManager.getAuthenticationBeanListBean().getOneToNFailShowTip());
        baseConfig.setOneToOneContinueFailTime(ConfigManager.getAuthenticationBeanListBean().getOneToOneContinueFailTime());
        //设置镜像
        baseConfig.setMirrorVideoRGB(ConfigManager.getAuthenticationBeanListBean().getMirrorVideoRGB());
        baseConfig.setMirrorVideoNIR(ConfigManager.getAuthenticationBeanListBean().getMirrorVideoNIR());
        baseConfig.setMirrorDetectRGB(ConfigManager.getAuthenticationBeanListBean().getMirrorDetectRGB());
        baseConfig.setMirrorDetectNIR(ConfigManager.getAuthenticationBeanListBean().getMirrorDetectNIR());

    }

    private void setTotalHardwareOpenNum() {
        if (ConfigManager.getAuthenticationBeanListBean().isUseIdcard()) {
            DeviceInitManager.getInstance().totalOpenHardwareNum++;
        }
        if (ConfigManager.getAuthenticationBeanListBean().isUseQrcode()){
            DeviceInitManager.getInstance().totalOpenHardwareNum++;
        }
        if (ConfigManager.getAuthenticationBeanListBean().isOpenPassport()) {
            DeviceInitManager.getInstance().totalOpenHardwareNum++;
        }
        if (ConfigManager.isOpenICCard()) {
            DeviceInitManager.getInstance().totalOpenHardwareNum++;
        }
    }

    public void setStartSmileService() {
        //SmileController.getInstance().init();
    }

    private void BlacklistConfig() {
        if (!ConfigManager.isOpenBlacklist()) {
            AppLogUtils.e(false, "黑名单配置", "黑名单配置未开启,直接return");
            return;
        }
        if (!ConfigManager.getAuthenticationBeanListBean().getUserBlacklistOfflineSwitch()) {
            //本地黑名单未开启,直接拉取三方黑名单
            userBlacklistConfig();
            return;
        }
        if (ConfigManager.getAuthenticationBeanListBean().getUserBlacklistOfflineSwitch()) {
            //本地黑名单开启,先拉取本地黑名单，然后再拉取三方黑名单配置
            localBlacklistConfig();
        }
    }

    /**
     * 三方黑名单配置
     */
    private void userBlacklistConfig() {
        if (!ConfigManager.getAuthenticationBeanListBean().getUserBlacklistInterfFetchSwitch()) {
            AppLogUtils.e(false, "黑名单配置", "黑名单未开启,不执行后续逻辑处理");
            return;
        }
        //拉取三方黑名单
        requestLocalBlacklistInterfConfig();
    }

    /**
     * 本地黑名单配置
     */
    private void localBlacklistConfig() {
        if (!ConfigManager.getAuthenticationBeanListBean().getUserBlacklistOfflineSwitch()) {
            AppLogUtils.e(false, "黑名单配置", "黑名单未开启,不执行后续逻辑处理");
            return;
        }
        //拉取本地黑名单
        requestLocalBlacklistConfig();

    }

    /**
     * 执行Android命令
     *
     * @param cmd 命令
     */
    private static void execSuCmd(String cmd) {
        Process process = null;
        DataOutputStream os = null;
        DataInputStream is = null;
        try {
            process = Runtime.getRuntime().exec("su");
            os = new DataOutputStream(process.getOutputStream());
            os.writeBytes(cmd + "\n");
            os.writeBytes("exit\n");
            os.flush();
            int aa = process.waitFor();
            is = new DataInputStream(process.getInputStream());
            byte[] buffer = new byte[is.available()];
            is.read(buffer);
            String out = new String(buffer);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (os != null) {
                    os.close();
                }
                if (is != null) {
                    is.close();
                }
                if (process != null) {
                    process.destroy();
                }

            } catch (Exception e) {
            }
        }
    }

    private void setScheduledRestart() {
        if (ConfigManager.getAuthenticationBeanListBean().getScheduledRestart()) {
            Calendar calendar = null;
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
                calendar = Calendar.getInstance();
                calendar.setTimeInMillis(System.currentTimeMillis());
                String scheduledRestartTime = ConfigManager.getAuthenticationBeanListBean().getScheduledRestartTime();
                int hour = Integer.parseInt(scheduledRestartTime.substring(0, 2));
                int minute = Integer.parseInt(scheduledRestartTime.substring(3, 5));
                int second = Integer.parseInt(scheduledRestartTime.substring(6));
                calendar.set(Calendar.HOUR_OF_DAY, hour);
                calendar.set(Calendar.MINUTE, minute);
                calendar.set(Calendar.SECOND, second);

                long setTime = calendar.getTimeInMillis();
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.getDefault());
                long currentTime = System.currentTimeMillis();
                // 如果当前的时间大于设定的时间，表明设定的时间是未来一天的，做一个加一天的操作
                if (currentTime >= setTime) {
                    calendar.add(Calendar.HOUR, 24);
                    calendar.getTimeInMillis();
                }
                // 2. 设置闹钟时间
                AlarmManager alarmManager = (AlarmManager) MyAppliction.getContext().getSystemService(Context.ALARM_SERVICE);
                Intent alarmIntent = new Intent(MyAppliction.getContext(), RebootReceiver.class);
                PendingIntent pendingIntent = PendingIntent.getBroadcast(MyAppliction.getContext(), 0, alarmIntent, 0);
                alarmManager.cancel(pendingIntent);//清除之前设置好的闹钟
                alarmManager.setInexactRepeating(AlarmManager.RTC_WAKEUP, calendar.getTimeInMillis(),
                        AlarmManager.INTERVAL_DAY, pendingIntent);
            }

        } else {
            CommonUtil.getCurrentActivity().stopService(new Intent(CommonUtil.getCurrentActivity(), RebootReceiver.class));
        }
    }

    private void setICCardReader() {
        //东信多合一阅读器的身份证和二维码是在同一个设备上，因此此时也需要初始化东信多合一的身份证阅读器DXAllInoneIDCardcontroller
        if (ConfigManager.isOpenICCard()) {
            httpResponseCallback.updateView(Constants.Code_HttpResponseCallback_ShowICCardIcon, "IC卡开启");
            IDCardControllerManager.init(9);
        }
    }

    //推送门磁信号
    private DoorMagneticSignalManager doorMagneticSignalManager;
    private Handler PushDoorSignalHandler = new Handler();
    private Runnable PushDoorSignalRunnable = new Runnable() {
        @Override
        public void run() {
            if (!StringIsNull.IsStringNull(ConfigManager.getAuthenticationBeanListBean().getGMAddress())) {
                Map<String, Object> map = new HashMap<>();
                map.put("sn", ConfigManager.getDeviceSN());
                map.put("doorStatus", ConfigManager.isShortContact);
                pAuthentication.PPushDoorMagneticSignal(map, ConfigManager.getAuthenticationBeanListBean().getGMAddress());
                PushDoorSignalHandler.postDelayed(PushDoorSignalRunnable, ConfigManager.getAuthenticationBeanListBean().getGMFrequency());

            }
        }
    };

    private void SetPushGm() {
        if (ConfigManager.getAuthenticationBeanListBean().isPushGm() &&
                !StringIsNull.IsStringNull(ConfigManager.getAuthenticationBeanListBean().getGMAddress())) {
            //门磁信号监听
            if (doorMagneticSignalManager == null) {
                doorMagneticSignalManager = new DoorMagneticSignalManager();
            }
            if (Build.MODEL.indexOf("F2") != -1) {
                doorMagneticSignalManager.start1();
            } else {
                doorMagneticSignalManager.start2(1);
            }
            if (ConfigManager.getAuthenticationBeanListBean().getGMFrequency() == 0) {
                ConfigManager.getAuthenticationBeanListBean().setGMFrequency(1000);
            }
            //启动定时器
            PushDoorSignalHandler.removeCallbacks(PushDoorSignalRunnable);
            PushDoorSignalHandler.postDelayed(PushDoorSignalRunnable, 0);
        }
    }

    private void setSerialPort() {
        //串口的关闭需要一点时间，如果调用关闭的方法后又立马打开串口会导致串口数据读取异常(持续不断的返回乱码的错误数据)
        AppHandler.getHandler().postDelayed(new Runnable() {
            @Override
            public void run() {
                //打开RS232开门的串口
                String UseSerialPort = StringIsNull.ReturnString(ConfigManager.getAuthenticationBeanListBean().getUseSerialPort());
                if (UseSerialPort.equals("RS232")
                        && !StringIsNull.IsStringNull(ConfigManager.getAuthenticationBeanListBean().getDoorSerialPort())) {
                    SerialController.getInstance().DoorGetSerial();
                }
                //获取结果页信息的串口通信地址
                if (ConfigManager.getAuthenticationBeanListBean().getCommunicationMode() == 3 &&
                        !StringIsNull.IsStringNull(ConfigManager.getAuthenticationBeanListBean().getCommunicationSerialPort())) {
                    //判断是否建立默认rs232串口连接
                    SerialController.getInstance().communicationComSerial();
                }
                //二维码串口通讯
                if (ConfigManager.getAuthenticationBeanListBean().isUseQrcode() &&
                        ConfigManager.getAuthenticationBeanListBean().getQrCodeReaderCommunicationMode() == 2) {
                    SerialController.getInstance().QrCodeComSerial();
                }
                //门磁信号串口地址
                if (ConfigManager.getAuthenticationBeanListBean().isPushGm() &&
                        !StringIsNull.IsStringNull(ConfigManager.getAuthenticationBeanListBean().getDoorSerialPortAddress())) {
                    SerialController.getInstance().doorSerialPortAddressComSerial();
                }
            }
        }, 3 * 1000);
    }

    private void setNotificationAndNavigationBar() {
        // 下拉通知栏
        if (!ConfigManager.getAuthenticationBeanListBean().isForbidPullDown()) {
            BaseDeviceUI.getInstance().getDeviceUI().showNotification();
        } else {
            BaseDeviceUI.getInstance().getDeviceUI().hideNotification();
        }
        // 隐藏底部导航栏
        if (!ConfigManager.getAuthenticationBeanListBean().isHideNavigationBar()) {
            BaseDeviceUI.getInstance().getDeviceUI().showNavigationBar();
        } else {
            BaseDeviceUI.getInstance().getDeviceUI().hideNavigationBar();
        }
    }

//    public void crashLogUpload() {
//        List<String> LogUploadsList = MyAppliction.getmDbDao().queryData1("CrashLog");
//        if (LogUploadsList.size() > 0) {
//            AppLogUtils.i(false, " 检测到有错误日志后 ", "上报错误日志信息：" + ConfigManager.getGson().toJson(LogUploadsList));
//            for (int i = 0; i < LogUploadsList.size(); i++) {
//                ConfigManager.setLogUploads(pLogUploads, "Crash", "报错信息", LogUploadsList.get(i), isSQLCrashLogUpload);
//                if (i == LogUploadsList.size() - 1) {
//                    isSQLCrashLogUpload = true;
//                }
//            }
//        }
//    }

    //二维码相关
    private void setupQRCode() {
        if (!ConfigManager.getAuthenticationBeanListBean().isUseQrcode()){
           return;
        }
        httpResponseCallback.updateView(Constants.Code_HttpResponseCallback_ShowQRCodeIcon, "二维码读头开启");
        //虚拟串口的二维码阅读器才需要初始化QRCodeController，串口的二维码阅读器走的是SerialController
        if (ConfigManager.getAuthenticationBeanListBean().getQrCodeReaderCommunicationMode() == 1 && ConfigManager.getAuthenticationBeanListBean().getQrCodeReaderBrand() != 6) {
            QRCodeController.getInstance().init();
        } else {
            QRCodeController.getInstance().destroy();
        }
        //东信多合一阅读器的身份证和二维码是在同一个设备上，因此此时也需要初始化东信多合一的身份证阅读器DXAllInoneIDCardcontroller
        if (ConfigManager.getAuthenticationBeanListBean().getQrCodeReaderBrand() == 6) {
            IDCardControllerManager.init(9);
        }
    }

    /**
     * 刷脸、护照机
     * <p>
     * 护照机初始化时间比较久，护照机开启的情况下等护照机初始化成功后再初始化smile刷脸
     */
    private void setupSmileAndPassport() {
        if (!ConfigManager.getAuthenticationBeanListBean().isOpenPassport()) {
            return;
        }

        httpResponseCallback.updateView(Constants.Code_HttpResponseCallback_ShowPassportIcon, "护照机开启");

        if (PassportController.getInstance().ocrThread != null && PassportController.getInstance().ocrThread.CheckDeviceOnlineEx() == 0) {
            return;
        }
        AppHandler.getHandler().post(new Runnable() {
            @Override
            public void run() {
                httpResponseCallback.updateView(Constants.Code_HttpResponseCallback_BottomTextPrompt, "护照机开始初始化");
                PassportController.getInstance().isExitApp = false;
                PassportController.getInstance().openOCrRecoge();
                TaskStatus.setStatus(TaskStatus.TASK_STATUS_WAIT);
                AppLogUtils.i(false, "判断护照机文件是否存在  " + ConfigManager.fileIsExists(ConfigManager.getSDPath() + "/AndroidWTone"));
                PassportController.getInstance().init();
                if (!ConfigManager.fileIsExists(ConfigManager.getSDPath() + "/AndroidWTone")) {
                    ConfigManager.isFileExists = false;
                } else {
                    ConfigManager.isFileExists = true;
                }
                PassportController.getInstance().PassportStart = "init";
            }
        });
    }

    /**
     * 设置音量
     */
    private void setMediaVolume() {
        int volume = ConfigManager.getAuthenticationBeanListBean().getVolume();
        int MediaVolume = (int) (volume * 0.15);
        VolumeUtil.getInstance().setMediaVolume(MediaVolume);
    }

    //身份证阅读器相关
    private void setupIDCardReader() {
        if (!ConfigManager.getAuthenticationBeanListBean().isUseIdcard()) {
            return ;
        }
        httpResponseCallback.updateView(Constants.Code_HttpResponseCallback_ShowIDCardIcon, "身份证阅读器开启");
        IDCardControllerManager.init(ConfigManager.getAuthenticationBeanListBean().getIdCardReaderBrand());
    }

    private void setAutoLaunch() {
        boolean AutoLaunch = ConfigManager.getAuthenticationBeanListBean().getAutoLaunch();
        SharedPreferencesUtils.setParam(CommonUtil.getCurrentActivity(), "autoLaunch", AutoLaunch);
        if (ConfigManager.getAuthenticationBeanListBean().getAutoLaunch()) {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                MyAppliction.getContext().startForegroundService(new Intent(MyAppliction.getContext(), CheckExitService.class));
            } else {
                MyAppliction.getContext().startService(new Intent(MyAppliction.getContext(), CheckExitService.class));
            }
        }
    }

    private void setSystemType() {
        if (ConfigManager.getAuthenticationBeanListBean().getSystemTypeCode() == 1 &&
                ConfigManager.getAuthenticationBeanListBean().getRelayOpenModel() == 2) {
            //蚂蚁os系统
            PosUtil.switchInputType(PosUtil.DOOR_INPUT, PosUtil.WIEGAND_INPUT, PosUtil.SWITCH_OPEN_INPUT1);
            PosManager.getInstance().registerInputBroadcast();
        }
    }

    public void postRequestConfigRunnable(long delayMillis) {
        AppHandler.getHandler().removeCallbacks(requestConfigRunnable);
        AppHandler.getHandler().postDelayed(requestConfigRunnable, delayMillis);
    }

    /**
     * 预检查核验接口请求
     */
    public void requestFederatedPlatformsCheck(boolean isNeedShowRequesting) {
        //判断核验接口是否开启
        if (ConfigManager.isLinkagePlatformClose()) {
            return;
        }
        //判断核验接口地址是否为空
        if (ConfigManager.isLinkageAdressEmpty()) {
            return;
        }
        //判断核验密钥是否为空
        if (ConfigManager.isEncryptKeyEmpty()) {
            return;
        }
        if (isNeedShowRequesting) {
            ResultViewManager.getInstance().setRequestingRunnable();
        }
        pAuthentication.PFederatedPlatformsCheck(ConfigManager.getFederatedPlatformsRequestBean(), new MyPresenter.DataResponseCallback() {
            @Override
            public void onDataResponse(Object o) {
                ResultViewManager.getInstance().removeRequestingRunnable();
                FederatedPlatformsResponseBean federatedPlatformsResponseBean = new FederatedPlatformsResponseBean();
                if (ConfigManager.isEncryptLinkage()) {
                    //数据解密
                    DecryptBean decryptBean = ConfigManager.getGson().fromJson((String) o, DecryptBean.class);

                    if (decryptBean.getCode() != 200) {//核验接口请求失败
                        if (StringIsNull.IsStringNull(decryptBean.getMsg())) {
                            decryptBean.setMsg("核验接口请求失败");
                        }
                        AppLogUtils.i(true, "核验接口返回处理中心-预检查", "开启预检查：返回数据code非200，通知调度中心处理");
                        federatedPlatformsResponseBean = DataManager.getInstance().getErrorOutcome("LocalError_B", decryptBean.getMsg(), decryptBean.getCode(), decryptBean.getMsg());
                        DataReturns.getInstance().doDataReturns(federatedPlatformsResponseBean, DataReturns.FACE_DATA_VIRTUAL);
                        return;
                    }
                    //验签失败
                    if (!EncryptionAndDecryptionUtil.checkSign(
                            ConfigManager.getAuthenticationBeanListBean().getCheckVerifyEncryptAppKey(),
                            ConfigManager.getAuthenticationBeanListBean().getCheckVerifyEncryptAppSecret(),
                            decryptBean.getData().getSign(),
                            String.valueOf(decryptBean.getData().getReqTimestamp()))) {
                        federatedPlatformsResponseBean = DataManager.getInstance().getErrorOutcome("LocalError", "核验接口验签出错", 500, "核验接口验签出错");
                        DataReturns.getInstance().doDataReturns(federatedPlatformsResponseBean, DataReturns.FACE_DATA_VIRTUAL);
                        return;
                    }
                    String decryptData = "";
                    decryptData = EncryptionAndDecryptionUtil.decrypt(ConfigManager.getAuthenticationBeanListBean().getCheckVerifyEncryptPrivateKey(), decryptBean.getData().getBizContent());
                    if (StringIsNull.IsStringNull(decryptData)) {
                        federatedPlatformsResponseBean = DataManager.getInstance().getErrorOutcome("LocalError_B", "核验接口解密失败", 500, "核验接口解密失败");
                        DataReturns.getInstance().doDataReturns(federatedPlatformsResponseBean, DataReturns.FACE_DATA_VIRTUAL);
                        return;
                    }
                    AppLogUtils.i(true, "接口请求_加密接口请求", "加密接口请求数据返回  " + decryptData);
                    federatedPlatformsResponseBean = new FederatedPlatformsResponseBean();
                    federatedPlatformsResponseBean.setMsg("请求成功");
                    federatedPlatformsResponseBean.setCode(200);
                    FederatedPlatformsResponseBean.DataDTO federatedPlatformsResponseBeanDtat = ConfigManager.getGson().fromJson(decryptData, FederatedPlatformsResponseBean.DataDTO.class);
                    federatedPlatformsResponseBean.setData(federatedPlatformsResponseBeanDtat);
                } else {
                    federatedPlatformsResponseBean = ConfigManager.getGson().fromJson((String) o, FederatedPlatformsResponseBean.class);
                }
                if (federatedPlatformsResponseBean.getCode() != 200) {//核验接口请求失败
                    if (StringIsNull.IsStringNull(federatedPlatformsResponseBean.getMsg())) {
                        federatedPlatformsResponseBean.setMsg("核验接口请求失败");
                    }
                    AppLogUtils.i(true, "核验接口返回处理中心-预检查", "开启预检查：返回数据code非200，通知调度中心处理");
                    federatedPlatformsResponseBean = DataManager.getInstance().getErrorOutcome("LocalError_B", federatedPlatformsResponseBean.getMsg(), federatedPlatformsResponseBean.getCode(),
                            federatedPlatformsResponseBean.getMsg());
                    DataReturns.getInstance().doDataReturns(federatedPlatformsResponseBean, DataReturns.FACE_DATA_VIRTUAL);
                    return;
                }
                CompleteDataUtil.completeFederatedPlatformsResponseBean(federatedPlatformsResponseBean);
                federatedPlatformsResponseBean = ConfigManager.getFederatedPlatformsResponseBean();
                AppLogUtils.i(true, "核验接口返回处理中心-预检查", "开启预检查：返回数据满足必要字段，通知调度中心处理");
                DataReturns.getInstance().doDataReturns(federatedPlatformsResponseBean, null);
            }
        });
    }

    /**
     * 预检查核验接口请求
     * <p>
     * 二维码/手输证件号/IC卡 是特殊情况，需要先获取到核验接口返回的姓名、身份证号、照片 这个二要素/三要素后才能调用PersonCard
     * 流程：
     * 1. 请求核验接口获取二要素/三要素（返回结果包含有结果页数据）
     * 2. 执行人证比对 & 展示核验接口获取结果页数据
     */
    public void requestFederatedPlatformsCheck_qrcode_enterIdnumber_icCard() {
        if (!ConfigManager.getAuthenticationBean().getData().get(0).isUseLinkage()) {
            String msg = "";
            if (Constants.IDCARD_TYPE == 5) {
                msg = "未开启相关配置,禁止使用手输证件号";
            } else if (Constants.IDCARD_TYPE == 6 || Constants.IDCARD_TYPE == 7) {
                msg = "未开启相关配置,禁止使用IC卡";
            } else if (Constants.IDCARD_TYPE == 3) {
                msg = "未开启相关配置,禁止使用二维码";
            }
            FederatedPlatformsResponseBean federatedPlatformsResponseBean = DataManager.getInstance().getErrorOutcome("LocalError_B", msg, 500, msg);
            DataReturns.getInstance().doDataReturns(federatedPlatformsResponseBean, DataReturns.FACE_DATA_VIRTUAL);
            return;
        }
        //判断核验接口是否开启
        if (ConfigManager.isLinkagePlatformClose()) {
            return;
        }
        //判断核验接口地址是否为空
        if (ConfigManager.isLinkageAdressEmpty()) {
            return;
        }
        //判断核验密钥是否为空
        if (ConfigManager.isEncryptKeyEmpty()) {
            return;
        }
        ResultViewManager.getInstance().setRequestingRunnable();
        pAuthentication.PFederatedPlatformsCheck(ConfigManager.getFederatedPlatformsRequestBean(), new MyPresenter.DataResponseCallback() {
            @Override
            public void onDataResponse(Object o) {
                ResultViewManager.getInstance().removeRequestingRunnable();
                FederatedPlatformsResponseBean federatedPlatformsResponseBean = null;
                if (ConfigManager.isEncryptLinkage()) {
                    //数据解密
                    DecryptBean decryptBean = ConfigManager.getGson().fromJson((String) o, DecryptBean.class);

                    if (decryptBean.getCode() != 200) {//核验接口请求失败
                        if (StringIsNull.IsStringNull(decryptBean.getMsg())) {
                            decryptBean.setMsg("核验接口请求失败");
                        }
                        AppLogUtils.i(true, "核验接口返回处理中心", "开启预检查：返回数据code非200，通知调度中心处理");
                        federatedPlatformsResponseBean = DataManager.getInstance().getErrorOutcome("LocalError_B", decryptBean.getMsg(), decryptBean.getCode(), decryptBean.getMsg());
                        DataReturns.getInstance().doDataReturns(federatedPlatformsResponseBean, DataReturns.FACE_DATA_VIRTUAL);
                        return;
                    }
                    //验签失败
                    if (!EncryptionAndDecryptionUtil.checkSign(
                            ConfigManager.getAuthenticationBeanListBean().getCheckVerifyEncryptAppKey(),
                            ConfigManager.getAuthenticationBeanListBean().getCheckVerifyEncryptAppSecret(),
                            decryptBean.getData().getSign(),
                            String.valueOf(decryptBean.getData().getReqTimestamp()))) {
                        federatedPlatformsResponseBean = DataManager.getInstance().getErrorOutcome("LocalError", "核验接口验签出错", 500, "核验接口验签出错");
                        DataReturns.getInstance().doDataReturns(federatedPlatformsResponseBean, DataReturns.FACE_DATA_VIRTUAL);
                        return;
                    }
                    String decryptData = "";
                    decryptData = EncryptionAndDecryptionUtil.decrypt(ConfigManager.getAuthenticationBeanListBean().getCheckVerifyEncryptPrivateKey(), decryptBean.getData().getBizContent());
                    if (StringIsNull.IsStringNull(decryptData)) {
                        federatedPlatformsResponseBean = DataManager.getInstance().getErrorOutcome("LocalError_B", "核验接口解密失败", 500, "核验接口解密失败");
                        DataReturns.getInstance().doDataReturns(federatedPlatformsResponseBean, DataReturns.FACE_DATA_VIRTUAL);
                        return;
                    }
                    AppLogUtils.i(true, "接口请求_加密接口请求", "加密接口请求数据返回  " + decryptData);
                    federatedPlatformsResponseBean = new FederatedPlatformsResponseBean();
                    federatedPlatformsResponseBean.setMsg("请求成功");
                    federatedPlatformsResponseBean.setCode(200);
                    FederatedPlatformsResponseBean.DataDTO federatedPlatformsResponseBeanDtat = ConfigManager.getGson().fromJson(decryptData, FederatedPlatformsResponseBean.DataDTO.class);
                    federatedPlatformsResponseBean.setData(federatedPlatformsResponseBeanDtat);
                    CompleteDataUtil.completeFederatedPlatformsResponseBean(federatedPlatformsResponseBean);
                } else {
                    federatedPlatformsResponseBean = ConfigManager.getGson().fromJson((String) o, FederatedPlatformsResponseBean.class);
                }
                if (federatedPlatformsResponseBean.getCode() != 200) {//核验接口请求失败
                    if (StringIsNull.IsStringNull(federatedPlatformsResponseBean.getMsg())) {
                        federatedPlatformsResponseBean.setMsg("核验接口请求失败");
                    }
                    AppLogUtils.i(true, "核验接口返回处理中心-预检查", "开启预检查：返回数据code非200，通知调度中心处理");
                    federatedPlatformsResponseBean = DataManager.getInstance().getErrorOutcome("LocalError_B", federatedPlatformsResponseBean.getMsg(), federatedPlatformsResponseBean.getCode(),
                            federatedPlatformsResponseBean.getMsg());
                    DataReturns.getInstance().doDataReturns(federatedPlatformsResponseBean, DataReturns.FACE_DATA_VIRTUAL);
                    return;
                }
                CompleteDataUtil.completeFederatedPlatformsResponseBean(federatedPlatformsResponseBean);

                //保存用户信息
                String name = federatedPlatformsResponseBean.getData().getName();
                String idNumber = federatedPlatformsResponseBean.getData().getIdNumber();
                String cardPhoto = federatedPlatformsResponseBean.getData().getPhoto();
                UserInfoManager.getInstance().setUserInformationBean(name, idNumber, cardPhoto, "", "");

                FederatedPlatformsRequestBean.ExtInfoDTO exInfoDTO = new FederatedPlatformsRequestBean.ExtInfoDTO();
                exInfoDTO.setPassRes("");
                exInfoDTO.setSmileParams("");
                exInfoDTO.setIdcardContent("");
                ConfigManager.setFederatedPlatformsRequestBean(ConfigManager.SN, Constants.IDCARD_TYPE, idNumber,
                        name, "", "check", "", "",
                        cardPhoto, exInfoDTO, ConfigManager.getFederatedPlatformsRequestBean().getData().getQrcode(),
                        ConfigManager.getFederatedPlatformsRequestBean().getData().getIcNumber());

                if (isUsePersonCard()) {

/*                    if (!StringIsNull.IsStringNull(name) && !StringIsNull.IsStringNull(idNumber)) {//二要素数据正常，开始进行人证比对
                        AppLogUtils.i(true, "核验接口返回处理中心-预检查", "开启人证比对，开启预检查：刷码或手输证件号返回有用户信息二要素 " + name + "-" + idNumber + "，通知调度中心处理");
                        //SmileController.getInstance().invokePersonCardWithSetState(name, idNumber, cardPhoto);
                        BaiduFaceController.getInstance().invokePersonCardWithSetState(name, idNumber, cardPhoto);
                        DataReturns.getInstance().doDataReturns(federatedPlatformsResponseBean, null);
                    } else {//二要素数据缺失，无法进行人证比对, 此时不用比对，直接成功
                        AppLogUtils.i(true, "核验接口返回处理中心-预检查", "开启人证比对，开启预检查：刷码或手输证件号返回无用户信息二要素，默认不比对，直接成功 " + name + "-" + idNumber + "，通知调度中心处理");
                        DataReturns.getInstance().doDataReturns(federatedPlatformsResponseBean, DataReturns.FACE_DATA_VIRTUAL);
                    }*/

                    //百度人脸的人证比对必须要有照片
                    if (!StringIsNull.IsStringNull(cardPhoto)) {//有照片数据，开始进行人证比对
                        AppLogUtils.i(true, "核验接口返回处理中心-预检查", "开启人证比对，开启预检查：刷码或手输证件号，接口返回有照片，通知调度中心处理");
                        //SmileController.getInstance().invokePersonCardWithSetState(name, idNumber, cardPhoto);
                        BaiduFaceController.getInstance().invokePersonCardWithSetState(name, idNumber, cardPhoto);
                        DataReturns.getInstance().doDataReturns(federatedPlatformsResponseBean, null);
                    } else {//照片数据缺失，无法进行人证比对, 此时不用比对，直接成功
                        AppLogUtils.i(true, "核验接口返回处理中心-预检查", "开启人证比对，开启预检查：刷码或手输证件号，接口返回没有照片，此时不需要人证比对");
                        DataReturns.getInstance().doDataReturns(federatedPlatformsResponseBean, DataReturns.FACE_DATA_VIRTUAL);
                    }

                } else {
                    AppLogUtils.i(true, "核验接口返回处理中心-预检查", "不开启人证比对，开启预检查：核验接口已返回数据，通知调度中心处理");
                    DataReturns.getInstance().doDataReturns(federatedPlatformsResponseBean, null);
                }
            }
        });

    }

    /**
     * 判断手输或刷码人证比对是否开启
     * <p>
     */
    private boolean isUsePersonCard() {
        if (Constants.IDCARD_TYPE == 3 &&
                ConfigManager.getAuthenticationBeanListBean().getQrCodeUsePersonCard()) {
            return true;
        }
        if (Constants.IDCARD_TYPE == 5 &&
                ConfigManager.getAuthenticationBeanListBean().getManualInUsePersonCard()) {
            return true;
        }
        if (Constants.IDCARD_TYPE == 6 &&
                ConfigManager.getAuthenticationBean().getData().get(0).getIc14443PersonCardComparison()) {
            return true;
        }
        if (Constants.IDCARD_TYPE == 7 &&
                ConfigManager.getAuthenticationBean().getData().get(0).getIc15693PersonCardComparison()) {
            return true;
        }
        return false;
    }

    /**
     * 通用模式的结果页数据请求
     */
    public void requestFederatedPlatforms() {
        //判断核验接口是否开启
        if (ConfigManager.isLinkagePlatformClose()) {
            return;
        }
        //判断核验接口地址是否为空
        if (ConfigManager.isLinkageAdressEmpty()) {
            return;
        }
        //判断核验密钥是否为空
        if (ConfigManager.isEncryptKeyEmpty()) {
            return;
        }
        ResultViewManager.getInstance().setRequestingRunnable();
        pAuthentication.PFederatedPlatforms(ConfigManager.getFederatedPlatformsRequestBean(), new MyPresenter.DataResponseCallback() {
            @Override
            public void onDataResponse(Object o) {
                ResultViewManager.getInstance().removeRequestingRunnable();
                FederatedPlatformsResponseBean federatedPlatformsResponseBean = new FederatedPlatformsResponseBean();
                if (ConfigManager.isEncryptLinkage()) {
                    //数据解密
                    DecryptBean decryptBean = ConfigManager.getGson().fromJson((String) o, DecryptBean.class);

                    if (decryptBean.getCode() != 200) {
                        String msg = decryptBean.getMsg();
                        if (StringIsNull.IsStringNull(msg)) {
                            msg = "核验接口请求失败";
                        }
                        AppLogUtils.e(true, "核验接口返回处理中心-通用", "关闭预检查：返回数据code非200，通知调度中心处理");
                        federatedPlatformsResponseBean = DataManager.getInstance().getErrorOutcome("LocalError_B", msg, 500, msg);
                        BaiDuFaceView.getInstance().getPlatformsCod(federatedPlatformsResponseBean);
                        return;
                    }
                    if (!EncryptionAndDecryptionUtil.checkSign(
                            ConfigManager.getAuthenticationBeanListBean().getCheckVerifyEncryptAppKey(),
                            ConfigManager.getAuthenticationBeanListBean().getCheckVerifyEncryptAppSecret(),
                            decryptBean.getData().getSign(),
                            String.valueOf(decryptBean.getData().getReqTimestamp()))) {
                        federatedPlatformsResponseBean = DataManager.getInstance().getErrorOutcome("LocalError", "核验接口验签出错", 500, "核验接口验签出错");
                        BaiDuFaceView.getInstance().getPlatformsCod(federatedPlatformsResponseBean);
                        return;
                    }
                    String decryptData = "";
                    decryptData = EncryptionAndDecryptionUtil.decrypt(ConfigManager.getAuthenticationBeanListBean().getCheckVerifyEncryptPrivateKey(), decryptBean.getData().getBizContent());
                    if (StringIsNull.IsStringNull(decryptData)) {
                        federatedPlatformsResponseBean = DataManager.getInstance().getErrorOutcome("LocalError_B", "核验接口解密失败", 500, "核验接口解密失败");
                        BaiDuFaceView.getInstance().getPlatformsCod(federatedPlatformsResponseBean);
                        return;
                    }
                    AppLogUtils.i(true, "加密接口请求入参", "加密接口请求数据返回  " + o);
                    federatedPlatformsResponseBean.setMsg("请求成功");
                    federatedPlatformsResponseBean.setCode(200);
                    FederatedPlatformsResponseBean.DataDTO federatedPlatformsResponseBeanDtat = ConfigManager.getGson().fromJson(decryptData, FederatedPlatformsResponseBean.DataDTO.class);
                    federatedPlatformsResponseBean.setData(federatedPlatformsResponseBeanDtat);
                } else {
                    federatedPlatformsResponseBean = ConfigManager.getGson().fromJson((String) o, FederatedPlatformsResponseBean.class);
                }

                if (federatedPlatformsResponseBean.getCode() != 200) {
                    if (StringIsNull.IsStringNull(federatedPlatformsResponseBean.getMsg())) {
                        federatedPlatformsResponseBean.setMsg("核验接口请求失败");
                    }
                    federatedPlatformsResponseBean = DataManager.getInstance().getErrorOutcome("LocalError", federatedPlatformsResponseBean.getMsg(), 500, federatedPlatformsResponseBean.getMsg());
                    BaiDuFaceView.getInstance().getPlatformsCod(federatedPlatformsResponseBean);
                    return;
                }
                CompleteDataUtil.completeFederatedPlatformsResponseBean(federatedPlatformsResponseBean);
                //展示悬浮框
                BaiDuFaceView.getInstance().getPlatformsCod(federatedPlatformsResponseBean);
            }
        });
    }

    /**
     * 二维码/手输证件号/IC卡 的是特殊情况，要先请求二要素/三要素后才能进行人证比对
     * <p>
     * 通用模式下的二维码/手输证件号/IC卡 开启人证比对时的执行流程：
     * 1. 请求核验接口获取二要素/三要素（返回结果包含有结果页数据）
     * 2. 执行人证比对
     * 3. 请求核验接口获取结果页数据
     * <p>
     * 按照1、2、3的步骤按顺序执行
     */
    public void requestFederatedPlatforms_qrcode_enterIdnumber_icCard() {
        if (!ConfigManager.getAuthenticationBean().getData().get(0).isUseLinkage()) {
            String msg = "";
            if (Constants.IDCARD_TYPE == 5) {
                msg = "未开启相关配置,禁止使用手输证件号";
            } else if (Constants.IDCARD_TYPE == 6 || Constants.IDCARD_TYPE == 7) {
                msg = "未开启相关配置,禁止使用IC卡";
            } else if (Constants.IDCARD_TYPE == 3) {
                msg = "未开启相关配置,禁止使用二维码";
            }
            FederatedPlatformsResponseBean federatedPlatformsResponseBean = DataManager.getInstance().getErrorOutcome("LocalError_B", msg, 500, msg);
            DataReturns.getInstance().doDataReturns(federatedPlatformsResponseBean, DataReturns.FACE_DATA_VIRTUAL);
            return;
        }
        //判断核验接口是否开启
        if (ConfigManager.isLinkagePlatformClose()) {
            return;
        }
        //判断核验接口地址是否为空
        if (ConfigManager.isLinkageAdressEmpty()) {
            return;
        }
        //判断核验密钥是否为空
        if (ConfigManager.isEncryptKeyEmpty()) {
            return;
        }
        ResultViewManager.getInstance().setRequestingRunnable();
        pAuthentication.PFederatedPlatforms(ConfigManager.getFederatedPlatformsRequestBean(), new MyPresenter.DataResponseCallback() {
            @Override
            public void onDataResponse(Object o) {
                ResultViewManager.getInstance().removeRequestingRunnable();
                FederatedPlatformsResponseBean federatedPlatformsResponseBean = null;
                if (ConfigManager.isEncryptLinkage()) {
                    //数据解密
                    DecryptBean decryptBean = ConfigManager.getGson().fromJson((String) o, DecryptBean.class);

                    if (decryptBean.getCode() != 200) {//核验接口请求失败
                        if (StringIsNull.IsStringNull(decryptBean.getMsg())) {
                            decryptBean.setMsg("核验接口请求失败");
                        }
                        AppLogUtils.i(true, "核验接口返回处理中心", "开启预检查：返回数据code非200，通知调度中心处理");
                        federatedPlatformsResponseBean = DataManager.getInstance().getErrorOutcome("LocalError_B", decryptBean.getMsg(), decryptBean.getCode(), decryptBean.getMsg());
                        BaiDuFaceView.getInstance().getPlatformsCod(federatedPlatformsResponseBean);
                        return;
                    }
                    //验签失败
                    if (!EncryptionAndDecryptionUtil.checkSign(
                            ConfigManager.getAuthenticationBeanListBean().getCheckVerifyEncryptAppKey(),
                            ConfigManager.getAuthenticationBeanListBean().getCheckVerifyEncryptAppSecret(),
                            decryptBean.getData().getSign(),
                            String.valueOf(decryptBean.getData().getReqTimestamp()))) {
                        federatedPlatformsResponseBean = DataManager.getInstance().getErrorOutcome("LocalError", "核验接口验签出错", 500, "核验接口验签出错");
                        BaiDuFaceView.getInstance().getPlatformsCod(federatedPlatformsResponseBean);
                        return;
                    }
                    String decryptData = "";
                    decryptData = EncryptionAndDecryptionUtil.decrypt(ConfigManager.getAuthenticationBeanListBean().getCheckVerifyEncryptPrivateKey(), decryptBean.getData().getBizContent());
                    if (StringIsNull.IsStringNull(decryptData)) {
                        federatedPlatformsResponseBean = DataManager.getInstance().getErrorOutcome("LocalError_B", "核验接口解密失败", 500, "核验接口解密失败");
                        BaiDuFaceView.getInstance().getPlatformsCod(federatedPlatformsResponseBean);
                        return;
                    }
                    AppLogUtils.i(true, "接口请求_加密接口请求", "加密接口请求数据返回  " + decryptData);
                    federatedPlatformsResponseBean = new FederatedPlatformsResponseBean();
                    federatedPlatformsResponseBean.setMsg("请求成功");
                    federatedPlatformsResponseBean.setCode(200);
                    FederatedPlatformsResponseBean.DataDTO federatedPlatformsResponseBeanDtat = ConfigManager.getGson().fromJson(decryptData, FederatedPlatformsResponseBean.DataDTO.class);
                    federatedPlatformsResponseBean.setData(federatedPlatformsResponseBeanDtat);
                    CompleteDataUtil.completeFederatedPlatformsResponseBean(federatedPlatformsResponseBean);
                } else {
                    federatedPlatformsResponseBean = ConfigManager.getGson().fromJson((String) o, FederatedPlatformsResponseBean.class);
                }
                if (federatedPlatformsResponseBean.getCode() != 200) {//核验接口请求失败
                    if (StringIsNull.IsStringNull(federatedPlatformsResponseBean.getMsg())) {
                        federatedPlatformsResponseBean.setMsg("核验接口请求失败");
                    }
                    AppLogUtils.i(true, "核验接口返回处理中心-预检查", "开启预检查：返回数据code非200，通知调度中心处理");
                    federatedPlatformsResponseBean = DataManager.getInstance().getErrorOutcome("LocalError_B", federatedPlatformsResponseBean.getMsg(), federatedPlatformsResponseBean.getCode(),
                            federatedPlatformsResponseBean.getMsg());
                    BaiDuFaceView.getInstance().getPlatformsCod(federatedPlatformsResponseBean);
                    return;
                }
                CompleteDataUtil.completeFederatedPlatformsResponseBean(federatedPlatformsResponseBean);

                //保存用户信息
                String name = StringIsNull.ReturnString(federatedPlatformsResponseBean.getData().getName());
                String idNumber = StringIsNull.ReturnString(federatedPlatformsResponseBean.getData().getIdNumber());
                String cardPhoto = StringIsNull.ReturnString(federatedPlatformsResponseBean.getData().getPhoto());
                UserInfoManager.getInstance().setUserInformationBean(name, idNumber, cardPhoto, "", "");

                FederatedPlatformsRequestBean.ExtInfoDTO exInfoDTO = new FederatedPlatformsRequestBean.ExtInfoDTO();
                exInfoDTO.setPassRes("");
                exInfoDTO.setSmileParams("");
                exInfoDTO.setIdcardContent("");
                ConfigManager.setFederatedPlatformsRequestBean(ConfigManager.SN, Constants.IDCARD_TYPE, idNumber,
                        name, "", "check", "", "",
                        cardPhoto, exInfoDTO, ConfigManager.getFederatedPlatformsRequestBean().getData().getQrcode(),
                        ConfigManager.getFederatedPlatformsRequestBean().getData().getIcNumber());

                if (isUsePersonCard()) {

/*                    if (!StringIsNull.IsStringNull(name) && !StringIsNull.IsStringNull(idNumber)) {//二要素数据正常，开始进行人证比对

                        AppLogUtils.i(true, "核验接口返回处理中心-预检查", "开启人证比对，开启预检查：刷码或手输证件号返回有用户信息二要素 " + name + "-" + idNumber + "，通知调度中心处理");
                        //SmileController.getInstance().invokePersonCardWithSetState(name, idNumber, cardPhoto);
                        BaiduFaceController.getInstance().invokePersonCardWithSetState(name, idNumber, cardPhoto);

                    } else {//二要素数据缺失，无法进行人证比对, 此时不用比对，直接成功
                        AppLogUtils.i(true, "核验接口返回处理中心-预检查", "开启人证比对，开启预检查：刷码或手输证件号返回无用户信息二要素，默认不比对，直接成功 " + name + "-" + idNumber + "，通知调度中心处理");
                        BaiDuFaceView.getInstance().getPlatformsCod(federatedPlatformsResponseBean);
                    }*/

                    //百度人脸的人证比对必须要有照片
                    if (!StringIsNull.IsStringNull(cardPhoto) ) {//有照片数据，开始进行人证比对

                        AppLogUtils.i(true, "核验接口返回处理中心-预检查", "开启人证比对，通用模式：刷码或手输证件号，接口返回有照片，通知调度中心处理");
                        //SmileController.getInstance().invokePersonCardWithSetState(name, idNumber, cardPhoto);
                        BaiduFaceController.getInstance().invokePersonCardWithSetState(name, idNumber, cardPhoto);

                    } else {//照片数据缺失，无法进行人证比对, 此时不用比对，直接成功
                        AppLogUtils.i(true, "核验接口返回处理中心-预检查", "开启人证比对，通用模式：刷码或手输证件号，接口返回没有照片，此时不需要人证比对");
                        BaiDuFaceView.getInstance().getPlatformsCod(federatedPlatformsResponseBean);
                    }


                } else {
                    AppLogUtils.i(true, "核验接口返回处理中心-预检查", "不开启人证比对，通用模式：核验接口已返回数据，通知调度中心处理");
                    BaiDuFaceView.getInstance().getPlatformsCod(federatedPlatformsResponseBean);
                }
            }
        });


    }


    /**
     * 预检查_核票_核验接口请求
     */
    public void requestFederatedPlatformsVerify() {
        //判断核验密钥是否为空
        if (ConfigManager.isEncryptKeyEmpty()) {
            return;
        }
        pAuthentication.PFederatedPlatformsVerify(ConfigManager.getFederatedPlatformsRequestBean());
    }


    /**
     * 用户入库
     */
    public void requestUserwithftoken(Map<String, Object> map) {
        //判断核验密钥是否为空
        if (ConfigManager.isAnonymousEncryptKeyEmpty()) {
            return;
        }
        map.put("sn", ConfigManager.getDeviceSN());
        pUserwithftoken.PUserwithftoken(map, com.hanghui.senic.network.Url.URL_FACEINADDRESS, new MyPresenter.DataResponseCallback() {
            @Override
            public void onDataResponse(Object o) {

            }
        });
    }

    /**
     * 商户平台请求
     * <p>
     * 先根据vid从景区获取三要素后再从联动平台请求结果页信息
     * <p>
     * 商户平台接口：根据vid、authcode、ftoken换取三要素, 只在纯刷脸时用到
     * <p>
     * 商户平台开启的情况下一般是在没有开发核验接口能力的景区，核验接口开启的情况下一般不会开启商户平台接口
     *
     * @param s1 刷脸成功时s1的示例值
     *           {
     *           "alipayUid": "",
     *           "code": 1000,
     *           "extInfo": "{\"checkWay\":\"scanFace\"}",
     *           "avatarBase64": "", //人脸小图
     *           "isvResult": true,
     *           "subCode": "OK_SUCCESS",
     *           "subMessage": "SUCCESS",
     *           "alipayUid":"66878"
     *           "vid": "1111",
     *           "ftoken":"fp1d27f47d863a9c19cb565ed3d6a347h43"
     *           }
     */
    public void requestThirdPartyPlatforms(String s1) {
        JSONObject jsonObject = JSONObject.parseObject(s1);
        Map jsonToMap = JSONObject.parseObject(jsonObject.toJSONString());
        jsonToMap.put("sn", ConfigManager.SN);
        String finalAvatarBase64Str = jsonObject.getString("avatarBase64");
        if (StringIsNull.IsStringNull(ConfigManager.getAuthenticationBeanListBean().getServiceAddress())) {
            FederatedPlatformsResponseBean federatedPlatformsResponseBean = DataManager.getInstance().getErrorOutcome("LocalError", "商户平台地址为空", 500, "商户平台地址为空");
            BaiDuFaceView.getInstance().getPlatformsCod(federatedPlatformsResponseBean);
            return;
        }
        //判断商户平台密钥是否为空
        if (ConfigManager.isTenantEncryptKeyEmpty()) {
            return;
        }
        ResultViewManager.getInstance().setRequestingRunnable();
        pAuthentication.PThirdPartyPlatforms(jsonToMap, new MyPresenter.DataResponseCallback() {
            @Override
            public void onDataResponse(Object o) {
                ResultViewManager.getInstance().removeRequestingRunnable();
                AlipayUserInfoBean alipayUserInfoBean = null;
                if (ConfigManager.getAuthenticationBeanListBean().getTenantEncryptSwitch()) {
                    //数据解密
                    DecryptBean decryptBean = ConfigManager.getGson().fromJson((String) o, DecryptBean.class);

                    if (decryptBean.getCode() != 200) {//商户平台请求失败
                        if (StringIsNull.IsStringNull(decryptBean.getMsg())) {
                            decryptBean.setMsg(ConfigManager.getAuthenticationBeanListBean().getTenantFailedTips());
                        }
                        FederatedPlatformsResponseBean federatedPlatformsResponseBean = DataManager.getInstance().getErrorOutcome("LocalError", decryptBean.getMsg(), 500, decryptBean.getMsg());
                        BaiDuFaceView.getInstance().getPlatformsCod(federatedPlatformsResponseBean);
                        return;
                    }
                    if (!EncryptionAndDecryptionUtil.checkSign(
                            ConfigManager.getAuthenticationBeanListBean().getTenantEncryptAppKey(),
                            ConfigManager.getAuthenticationBeanListBean().getTenantEncryptAppSecret(),
                            decryptBean.getData().getSign(),
                            String.valueOf(decryptBean.getData().getReqTimestamp()))) {
                        FederatedPlatformsResponseBean federatedPlatformsResponseBean = DataManager.getInstance().getErrorOutcome("LocalError", "商户接口验签出错", 500, "商户接口验签出错");
                        BaiDuFaceView.getInstance().getPlatformsCod(federatedPlatformsResponseBean);
                        return;
                    }

                    String decryptData = "";
                    decryptData = EncryptionAndDecryptionUtil.decrypt(ConfigManager.getAuthenticationBeanListBean().getTenantEncryptPrivateKey(),
                            decryptBean.getData().getBizContent());
                    if (StringIsNull.IsStringNull(decryptData)) {
                        FederatedPlatformsResponseBean federatedPlatformsResponseBean = DataManager.getInstance().getErrorOutcome("LocalError_B", "商户平台解密失败", 500, "商户平台解密失败");
                        BaiDuFaceView.getInstance().getPlatformsCod(federatedPlatformsResponseBean);
                        return;
                    }
                    alipayUserInfoBean = ConfigManager.getGson().fromJson(decryptData, AlipayUserInfoBean.class);
                } else {
                    alipayUserInfoBean = new Gson().fromJson((String) o, AlipayUserInfoBean.class);
                }
                if (StringIsNull.IsStringNull(alipayUserInfoBean.getErrcode()) || !alipayUserInfoBean.getErrcode().equals("0")) {
                    if (StringIsNull.IsStringNull(alipayUserInfoBean.getErrmsg())) {
                        alipayUserInfoBean.setErrmsg("商户平台请求失败");
                        alipayUserInfoBean.setOpenVoiceMsg("商户平台请求失败");
                    }
                    FederatedPlatformsResponseBean federatedPlatformsResponseBean = DataManager.getInstance().getErrorOutcome("LocalError", alipayUserInfoBean.getErrmsg(), 500, alipayUserInfoBean.getErrmsg());
                    BaiDuFaceView.getInstance().getPlatformsCod(federatedPlatformsResponseBean);
                    return;
                }
                String Base64 = "";
                if (!StringIsNull.IsStringNull(alipayUserInfoBean.getData().getPhotoBase64())) {
                    Base64 = alipayUserInfoBean.getData().getPhotoBase64();
                } else {
                    Base64 = finalAvatarBase64Str;
                }
                UserInfoManager.getInstance().setUserInformationBean(alipayUserInfoBean.getData().getUserName(),
                        alipayUserInfoBean.getData().getCertNo(), "",
                        Base64, alipayUserInfoBean.getData().getMobile());
                //判断年龄限制是否打开
                if (ConfigManager.isAgeLimitOpen(StringIsNull.ReturnString(alipayUserInfoBean.getData().getCertNo()))) {
                    return;
                }
                //判断黑名单中是否存在该用户
                if (BlacklistManager.getInstance().isInBlacklist(alipayUserInfoBean.getData().getCertNo(), alipayUserInfoBean.getData().getMobile())) {
                    return;
                }
                FederatedPlatformsRequestBean.ExtInfoDTO exInfoDTO = new FederatedPlatformsRequestBean.ExtInfoDTO();
                exInfoDTO.setPassRes("");
                exInfoDTO.setSmileParams(s1);
                exInfoDTO.setIdcardContent("");
                ConfigManager.setFederatedPlatformsRequestBean(ConfigManager.SN, Constants.IDCARD_TYPE,
                        StringIsNull.ReturnString(alipayUserInfoBean.getData().getCertNo()),
                        StringIsNull.ReturnString(alipayUserInfoBean.getData().getUserName()),
                        StringIsNull.ReturnString(alipayUserInfoBean.getData().getMobile()),
                        "", "", "",
                        alipayUserInfoBean.getData().getPhotoBase64(), exInfoDTO, "", "");
                //判断核验接口是否开启
                if (ConfigManager.isLinkagePlatformClose()) {
                    return;
                }

                //核验接口请求
                if (ConfigManager.isPreCheck()) {//预检测模式
                    DataReturns.getInstance().doDataReturns(null, s1);
                    HttpRequest.getInstance().requestFederatedPlatformsCheck(true);
                } else {//通用模式
                    HttpRequest.getInstance().requestFederatedPlatforms();
                }

            }
        });
    }

    /**
     * 急速通行模式下商户平台请求
     *
     * @param s1
     */
    public void requestThirdPartyPlatforms_FastThrough(String s1) {
        JSONObject jsonObject = JSONObject.parseObject(s1);
        Map jsonToMap = JSONObject.parseObject(jsonObject.toJSONString());
        jsonToMap.put("sn", ConfigManager.SN);
        String finalAvatarBase64Str = jsonObject.getString("avatarBase64");
        if (StringIsNull.IsStringNull(ConfigManager.getAuthenticationBeanListBean().getServiceAddress())) {
            AppLogUtils.e(true, "出站/进站 刷脸通行", "商户平台地址为空");
            return;
        }
        //判断商户平台密钥是否为空
        if (ConfigManager.isTenantEncryptKeyEmpty()) {
            return;
        }
        pAuthentication.PThirdPartyPlatforms(jsonToMap, new MyPresenter.DataResponseCallback() {
            @Override
            public void onDataResponse(Object o) {
                ResultViewManager.getInstance().removeRequestingRunnable();
                AlipayUserInfoBean alipayUserInfoBean = null;
                if (ConfigManager.getAuthenticationBeanListBean().getTenantEncryptSwitch()) {
                    //数据解密
                    DecryptBean decryptBean = ConfigManager.getGson().fromJson((String) o, DecryptBean.class);

                    if (decryptBean.getCode() != 200) {//商户平台请求失败
                        AppLogUtils.e(true, "出站/进站 刷脸通行", "商户平台请求失败");
                        return;
                    }
                    if (!EncryptionAndDecryptionUtil.checkSign(
                            ConfigManager.getAuthenticationBeanListBean().getTenantEncryptAppKey(),
                            ConfigManager.getAuthenticationBeanListBean().getTenantEncryptAppSecret(),
                            decryptBean.getData().getSign(),
                            String.valueOf(decryptBean.getData().getReqTimestamp()))) {
                        AppLogUtils.e(true, "出站/进站 刷脸通行", "商户接口验签出错");
                        return;
                    }

                    String decryptData = "";
                    decryptData = EncryptionAndDecryptionUtil.decrypt(ConfigManager.getAuthenticationBeanListBean().getTenantEncryptPrivateKey(),
                            decryptBean.getData().getBizContent());
                    if (StringIsNull.IsStringNull(decryptData)) {
                        AppLogUtils.e(true, "出站/进站 刷脸通行", "商户平台解密失败");
                        return;
                    }
                    alipayUserInfoBean = ConfigManager.getGson().fromJson(decryptData, AlipayUserInfoBean.class);
                } else {
                    alipayUserInfoBean = new Gson().fromJson((String) o, AlipayUserInfoBean.class);
                }
                if (StringIsNull.IsStringNull(alipayUserInfoBean.getErrcode()) || !alipayUserInfoBean.getErrcode().equals("0")) {
                    AppLogUtils.e(true, "出站/进站 刷脸通行", alipayUserInfoBean.getErrmsg());
                    return;
                }
                String Base64 = "";
                if (!StringIsNull.IsStringNull(alipayUserInfoBean.getData().getPhotoBase64())) {
                    Base64 = alipayUserInfoBean.getData().getPhotoBase64();
                } else {
                    Base64 = finalAvatarBase64Str;
                }
                UserInfoManager.getInstance().setUserInformationBean(alipayUserInfoBean.getData().getUserName(),
                        alipayUserInfoBean.getData().getCertNo(), alipayUserInfoBean.getData().getPhotoBase64(),
                        Base64, alipayUserInfoBean.getData().getMobile());

//                //判断年龄限制是否打开
//                if (ConfigManager.isAgeLimitOpen(StringIsNull.ReturnString(alipayUserInfoBean.getData().getCertNo()))) {
//                    return;
//                }
                //判断黑名单中是否存在该用户
                if (BlacklistManager.getInstance().isInBlacklist(alipayUserInfoBean.getData().getCertNo(), alipayUserInfoBean.getData().getMobile())) {
                    return;
                }
                FederatedPlatformsRequestBean.ExtInfoDTO exInfoDTO = new FederatedPlatformsRequestBean.ExtInfoDTO();
                exInfoDTO.setPassRes("");
                exInfoDTO.setSmileParams(s1);
                exInfoDTO.setIdcardContent("");
                ConfigManager.setFederatedPlatformsRequestBean(ConfigManager.SN, Constants.IDCARD_TYPE,
                        StringIsNull.ReturnString(alipayUserInfoBean.getData().getCertNo()),
                        StringIsNull.ReturnString(alipayUserInfoBean.getData().getUserName()),
                        StringIsNull.ReturnString(alipayUserInfoBean.getData().getMobile()),
                        "", "", "",
                        alipayUserInfoBean.getData().getPhotoBase64(), exInfoDTO, "", "");
                //记录上报
                String Photo = UserInfoManager.getInstance().getUserInformationBean().getScenePhoto();
                if (StringIsNull.IsStringNull(Photo)) {
                    Photo = UserInfoManager.getInstance().getUserInformationBean().getIdPhoto();
                }

                HttpRequest.getInstance().setEventRecords(ConfigManager.getAuthenticationBeanListBean().getPassWay(),
                        UserInfoManager.getInstance().getUserInformationBean().getName(),
                        UserInfoManager.getInstance().getUserInformationBean().getIdNumber(),
                        Photo,
                        "",
                        UserInfoManager.getInstance().getUserInformationBean().getMobile(), true, 0);


            }
        });
    }

    /**
     * 记录上报
     *
     * @param type
     * @param name
     * @param Cardid
     * @param Photo
     * @param idCardInfo
     * @param phone
     * @param start
     * @param reasonType
     */
    public void setEventRecords(String type, String name, String Cardid, String Photo, String idCardInfo,
                                String phone, boolean start, int reasonType) {
        /**
         * 当身份证号不为空时，判断身份证是否是重复上报的数据，重复则不做记录上报处理，不重复则执行进出记录上报操作
         */
        if (!StringIsNull.IsStringNull(Cardid)) {
            /**
             * 进出记录滤重操作（根据身份证号 + 当前时间戳 判断本次记录是否需要上报。  身份证号为空时，不做记录，直接上报）
             * 身份证号为空/检测到身份证号不在滤重时间内时上报记录
             */
            if (!ConfigManager.isRepeatedRequest(UserInfoManager.getInstance().getUserInformationBean().getIdNumber())) {
                Map map = DataManager.getInstance().setEventRecords(type, name, Cardid, Photo, idCardInfo, phone, start, reasonType);
                if (!StringIsNull.IsStringNull(com.hanghui.senic.network.Url.URL_EVENTRECORDS) && !com.hanghui.senic.network.Url.URL_EVENTRECORDS.equals("/")) {
                    pDevice.PEventRecords(map, com.hanghui.senic.network.Url.URL_EVENTRECORDS);
                }
            } else {
                AppLogUtils.e(false, "进出记录上报操作", "该身份证号已经上报过进出记录，一定时间内不做上报处理");
            }
        } else {
            Map map = DataManager.getInstance().setEventRecords(type, name, Cardid, Photo, idCardInfo, phone, start, reasonType);
            if (!StringIsNull.IsStringNull(com.hanghui.senic.network.Url.URL_EVENTRECORDS) && !com.hanghui.senic.network.Url.URL_EVENTRECORDS.equals("/")) {
                pDevice.PEventRecords(map, com.hanghui.senic.network.Url.URL_EVENTRECORDS);
            }
        }

    }

    /**
     * 特殊码换取三要素(请求的是授权平台另外配置的接口，与核验接口地址不一样，返回结果只有三要素，没有结果页数据)
     * 三要素获取到之后就是普通的人证比对/请求结果页的执行流程，和身份证数据读取到后的执行流程一样
     *
     * @param qrCode 二维码码值
     */
    public void requestFederatedPlatforms_SpecialCodeGetThreeElements(String qrCode) {
        Map<String, Object> map = new HashMap<>();
        map.put("qrCode", qrCode);
        pAuthentication.PSpecialCodeTradeThreeElements(map, ConfigManager.getAuthenticationBeanListBean().getSpecialCodeUrl(), new MyPresenter.DataResponseCallback() {
            @Override
            public void onDataResponse(Object o) {
                SpecialCodeTradeThreeElementsBean specialCodeTradeThreeElementsBean = ConfigManager.getGson().fromJson((String) o, SpecialCodeTradeThreeElementsBean.class);
                if (specialCodeTradeThreeElementsBean.getCode() != 200) {
                    String msg = "";
                    if (!StringIsNull.IsStringNull(specialCodeTradeThreeElementsBean.getMsg())) {
                        msg = specialCodeTradeThreeElementsBean.getMsg();
                    } else if (StringIsNull.IsStringNull(specialCodeTradeThreeElementsBean.getMsg()) && !StringIsNull.IsStringNull(specialCodeTradeThreeElementsBean.getErrmsg())) {
                        msg = specialCodeTradeThreeElementsBean.getErrmsg();
                    } else {
                        msg = "特殊码换三要素接⼝请求失败";
                    }
                    FederatedPlatformsResponseBean federatedPlatformsResponseBean = DataManager.getInstance().getErrorOutcome("LocalError_B", msg, 500, msg);
                    BaiDuFaceView.getInstance().getPlatformsCod(federatedPlatformsResponseBean);
                    return;
                }
                String name = StringIsNull.ReturnString(specialCodeTradeThreeElementsBean.getData().getCertName());
                String idNumber = StringIsNull.ReturnString(specialCodeTradeThreeElementsBean.getData().getCertNo());
                String cardPhoto = StringIsNull.ReturnString(specialCodeTradeThreeElementsBean.getData().getPhotoBase64());
                String phone = StringIsNull.ReturnString(specialCodeTradeThreeElementsBean.getData().getPhone());
                //保存用户信息
                UserInfoManager.getInstance().setUserInformationBean(name, idNumber, cardPhoto, "", phone);

                //判断黑名单中是否存在该用户
                if (BlacklistManager.getInstance().isInBlacklist(idNumber, phone)) {
                    return;
                }
                //判断年龄限制是否打开
                if (ConfigManager.isAgeLimitOpen(StringIsNull.ReturnString(idNumber))) {
                    return;
                }
                //判断核验接口是否开启
                if (ConfigManager.isLinkagePlatformClose()) {
                    return;
                }


                FederatedPlatformsRequestBean.ExtInfoDTO exInfoDTO = new FederatedPlatformsRequestBean.ExtInfoDTO();
                exInfoDTO.setPassRes("");
                exInfoDTO.setSmileParams("");
                exInfoDTO.setIdcardContent("");
                ConfigManager.setFederatedPlatformsRequestBean(ConfigManager.SN, Constants.IDCARD_TYPE, idNumber, name, phone, "", "", "", cardPhoto, exInfoDTO, qrCode, "");

                //核验接口请求
                if (ConfigManager.isPreCheck()) {//预检查模式下，同时去请求核验接口结果页数据
                    if (ConfigManager.getAuthenticationBeanListBean().getQrCodeUsePersonCard()) {//获取到三要素数据，如果开启了人证比对，则调用PersonCard唤起刷脸

/*                        if (!StringIsNull.IsStringNull(name) && !StringIsNull.IsStringNull(idNumber)){
                            //SmileController.getInstance().invokePersonCardWithSetState(name, idNumber, cardPhoto);
                            BaiduFaceController.getInstance().invokePersonCardWithSetState(name, idNumber, cardPhoto);

                            HttpRequest.getInstance().requestFederatedPlatformsCheck(false);
                        } else {
                            AppLogUtils.e(true, "特殊码换取三要素", "返回姓名、身份证证号存在为空的情况，直接展示结果页，不做人证比对");
                            DataReturns.getInstance().doDataReturns(null, DataReturns.FACE_DATA_VIRTUAL);
                            HttpRequest.getInstance().requestFederatedPlatformsCheck(true);
                        }*/

                        //百度人脸的人证比对必须要有照片
                        if (!StringIsNull.IsStringNull(cardPhoto)){
                            //SmileController.getInstance().invokePersonCardWithSetState(name, idNumber, cardPhoto);
                            BaiduFaceController.getInstance().invokePersonCardWithSetState(name, idNumber, cardPhoto);

                            HttpRequest.getInstance().requestFederatedPlatformsCheck(false);
                        } else {
                            AppLogUtils.e(true, "特殊码换取三要素", "返回的照片为空，直接展示结果页，不做人证比对");
                            DataReturns.getInstance().doDataReturns(null, DataReturns.FACE_DATA_VIRTUAL);
                            HttpRequest.getInstance().requestFederatedPlatformsCheck(true);
                        }

                    } else {
                        AppLogUtils.i(true, "特殊码换取三要素", "二维码没有开启人证比对，开启预检查：默认人证比对成功（虚拟）");
                        DataReturns.getInstance().doDataReturns(null, DataReturns.FACE_DATA_VIRTUAL);
                        HttpRequest.getInstance().requestFederatedPlatformsCheck(true);
                    }

                } else {//通用模式
                    if (ConfigManager.getAuthenticationBeanListBean().getQrCodeUsePersonCard()) {

/*                        if (!StringIsNull.IsStringNull(name) && !StringIsNull.IsStringNull(idNumber)){
                            //SmileController.getInstance().invokePersonCardWithSetState(name, idNumber, cardPhoto);
                            BaiduFaceController.getInstance().invokePersonCardWithSetState(name, idNumber, cardPhoto);
                        }else {
                            AppLogUtils.e(true,"特殊码换取三要素","返回姓名、身份证证号存在为空的情况，直接展示结果页，不做人证比对");

                            HttpRequest.getInstance().requestFederatedPlatforms();
                        }*/

                        //百度人脸的人证比对必须要有照片
                        if (!StringIsNull.IsStringNull(cardPhoto) ){
                            //SmileController.getInstance().invokePersonCardWithSetState(name, idNumber, cardPhoto);
                            BaiduFaceController.getInstance().invokePersonCardWithSetState(name, idNumber, cardPhoto);
                        }else {
                            AppLogUtils.e(true,"特殊码换取三要素","返回姓名、身份证证号存在为空的情况，直接展示结果页，不做人证比对");

                            HttpRequest.getInstance().requestFederatedPlatforms();
                        }


                    } else {
                        //如果没有开启人证比对，则直接去请求核验接口结果页数据
                        HttpRequest.getInstance().requestFederatedPlatforms();
                    }
                }
            }
        });
    }

    /**
     * 本地黑名单拉取
     */
    public void requestLocalBlacklistConfig() {
        Map<String, Object> map = new HashMap<>();
        map.put("deviceType", 0);//设备类型 <br />0-通用设备<br />1-HH_CULTURE<br />2-访客机<br />3-临时身份证名
        map.put("sn", ConfigManager.getDeviceSN());
        map.put("token", ConfigManager.token);
        pAuthentication.PLocalBlacklistConfig(map, new MyPresenter.DataResponseCallback() {
            @Override
            public void onDataResponse(Object o) {
                BlacklistConfigBean blacklistConfigBean = ConfigManager.getGson().fromJson((String) o, BlacklistConfigBean.class);
                if (blacklistConfigBean.getCode() != 200) {//请求失败
                    AppLogUtils.e(true, "本地黑名单配置", "本地黑名单配置接口拉取失败，返回code非200");
                    return;
                }
                if (blacklistConfigBean.getData() == null) {
                    AppLogUtils.e(true, "本地黑名单配置", "本地黑名单配置接口拉取失败，返回data为null，没有黑名单数据");
                    return;
                }
                //三方黑名单配置开启，将本地获取的黑名单暂时保存
                if (ConfigManager.getAuthenticationBeanListBean().getUserBlacklistInterfFetchSwitch()) {
                    BlacklistManager.getInstance().blacklist.clear();
                    BlacklistManager.getInstance().blacklist.addAll(blacklistConfigBean.getData());
                    userBlacklistConfig();
                } else {//三方黑名单配置未开启，直接将数据保存
                    //将黑名单数据保存到本地数据库中
                    BlacklistManager.getInstance().setBlacklist(blacklistConfigBean.getData());
                }

            }
        });
    }

    /**
     * 三方黑名单拉取
     */
    private void requestLocalBlacklistInterfConfig() {
        Map<String, Object> map = new HashMap<>();
        map.put("deviceType", 0);//设备类型 <br />0-通用设备<br />1-HH_CULTURE<br />2-访客机<br />3-临时身份证名
        map.put("sn", ConfigManager.getDeviceSN());
        map.put("token", ConfigManager.token);
        pAuthentication.PLocalBlacklistInterfConfig(map, new MyPresenter.DataResponseCallback() {
            @Override
            public void onDataResponse(Object o) {
                BlacklistConfigBean blacklistConfigBean = null;
                if (ConfigManager.isUserBlacklistEncrypt()) {
                    //数据解密
                    DecryptBean decryptBean = ConfigManager.getGson().fromJson((String) o, DecryptBean.class);

                    if (decryptBean.getCode() != 200) {//三方核验接口
                        AppLogUtils.e(true, "三方黑名单配置", "三方黑名单接口请求失败");
                        ConfigManager.localBlacklistInterfShowToast();
                        return;
                    }
                    if (!EncryptionAndDecryptionUtil.checkSign(
                            ConfigManager.getAuthenticationBeanListBean().getUserBlacklistEncryptAppKey(),
                            ConfigManager.getAuthenticationBeanListBean().getUserBlacklistEncryptAppSecret(),
                            decryptBean.getData().getSign(),
                            String.valueOf(decryptBean.getData().getReqTimestamp()))) {
                        AppLogUtils.e(true, "三方黑名单配置", "三方黑名单接口验签出错");
                        ConfigManager.localBlacklistInterfShowToast();
                        return;
                    }

                    String decryptData = "";
                    decryptData = EncryptionAndDecryptionUtil.decrypt(ConfigManager.getAuthenticationBeanListBean().getUserBlacklistEncryptPrivateKey(),
                            decryptBean.getData().getBizContent());
                    if (StringIsNull.IsStringNull(decryptData)) {
                        AppLogUtils.e(true, "三方黑名单配置", "三方黑名单接口解密失败");
                        ConfigManager.localBlacklistInterfShowToast();
                        return;
                    }
                    blacklistConfigBean = new BlacklistConfigBean();
                    blacklistConfigBean.setCode(200);
                    blacklistConfigBean.setMsg("请求成功");
                    Type listType = new TypeToken<List<BlacklistConfigBean.DataBean>>() {
                    }.getType();
                    List<BlacklistConfigBean.DataBean> blacklistConfigBeanData = ConfigManager.getGson().fromJson(decryptData, listType);
                    blacklistConfigBean.setData(blacklistConfigBeanData);
                } else {
                    blacklistConfigBean = new Gson().fromJson((String) o, BlacklistConfigBean.class);
                }
                AppLogUtils.i(true, "三方黑名单配置  ", "三方黑名单配置数据返回 " + ConfigManager.getGson().toJson(blacklistConfigBean));
                if (blacklistConfigBean.getCode() != 200) {//请求失败
                    AppLogUtils.e(true, "三方黑名单配置", "三方黑名单配置接口拉取失败，返回code非200");
                    ConfigManager.localBlacklistInterfShowToast();
                    return;
                }
                if (blacklistConfigBean.getData() == null) {
                    AppLogUtils.e(true, "三方黑名单配置", "三方黑名单配置接口拉取失败，返回data为null，没有黑名单数据");
                    ConfigManager.localBlacklistInterfShowToast();
                    return;
                }
                BlacklistManager.getInstance().blacklist.addAll(blacklistConfigBean.getData());
                //将黑名单数据保存到本地数据库中
                BlacklistManager.getInstance().setBlacklist(BlacklistManager.getInstance().blacklist);
            }
        });
    }

    public HttpResponseCallback httpResponseCallback;

    public HttpResponseCallback getHttpResponseCallback() {
        return httpResponseCallback;
    }

    public void setHttpResponseCallback(HttpResponseCallback httpResponseCallback) {
        this.httpResponseCallback = httpResponseCallback;
    }

    public interface HttpResponseCallback {
        void updateView(int code, String msg);
    }

}