修复引导过程中修改相机导致引导队列中止出队的问题 增加一键派警描述字段

‘liusuyi’

2023-08-24 2988d2670cf03ef1ab074b0c6cd54301570c8ba4

 ard-work/src/main/java/com/ruoyi/device/hiksdk/service/impl/HikClientServiceImpl.java

@@ -1,33 +1,29 @@
package com.ruoyi.device.hiksdk.service.impl;

import com.ruoyi.common.annotation.SdkOperate;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.file.FileUtils;
import com.ruoyi.constant.sdkPriority;
import com.ruoyi.common.utils.file.MimeTypeUtils;
import com.ruoyi.common.utils.uuid.IdUtils;
import com.ruoyi.device.camera.domain.CameraCmd;
import com.ruoyi.device.camera.mapper.ArdCamerasMapper;
import com.ruoyi.device.camera.service.IArdCamerasService;
import com.ruoyi.device.channel.domain.ArdChannel;
import com.ruoyi.device.hiksdk.common.GlobalVariable;
import com.ruoyi.device.camera.domain.ArdCameras;
import com.ruoyi.device.hiksdk.config.MinioClientSingleton;
import com.ruoyi.device.hiksdk.domain.recordInfo;
import com.ruoyi.device.hiksdk.util.hikSdkUtil.GisUtil;
import com.ruoyi.device.hiksdk.util.hikSdkUtil.HCNetSDK;
import com.ruoyi.device.hiksdk.service.IHikClientService;
import com.ruoyi.device.hiksdk.util.hikSdkUtil.LoginResultCallBack;
import com.ruoyi.device.hiksdk.util.minio.MinioUtils;
import com.ruoyi.system.mapper.SysUserMapper;
import com.ruoyi.storage.minio.utils.MinioUtils;
import com.sun.jna.Native;
import com.sun.jna.NativeLong;
import com.sun.jna.Platform;
import com.sun.jna.Pointer;
import com.sun.jna.ptr.IntByReference;
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Async;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import sun.misc.BASE64Encoder;

import java.util.Base64;
import javax.annotation.Resource;
import java.io.*;
import java.math.BigDecimal;
@@ -35,6 +31,7 @@
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.*;

import static com.ruoyi.device.hiksdk.util.hikSdkUtil.HCNetSDK.*;

/**
@@ -48,11 +45,12 @@
@Service
public class HikClientServiceImpl implements IHikClientService {

    @Value("${minio.endpoint}")
    private static String endpoint;
    @Resource
    ArdCamerasMapper ardCamerasMapper;

    private IArdCamerasService ardCamerasService;
    @Resource
    SysUserMapper sysUserMapper;
    private MinioUtils minioUtil;

    private static HCNetSDK hCNetSDK;

@@ -112,6 +110,7 @@
        }
        //打印海康sdk日志
        if (Platform.isWindows()) {

            String WIN_PATH = System.getProperty("user.dir") + File.separator + "ardLog" + File.separator + "logs" + File.separator;
            hCNetSDK.NET_DVR_SetLogToFile(3, WIN_PATH, true);
        } else {
@@ -132,13 +131,10 @@
            hCNetSDK.NET_DVR_Cleanup();
            camera.setLoginId(-1);
        }
        if (GlobalVariable.loginMap.containsKey(camera.getId())) {
            GlobalVariable.loginMap.remove(camera.getId());
        }
        GlobalVariable.loginMap.remove(camera.getId());
        GlobalVariable.loginMap.put(camera.getId(), lUserID);

        camera.setLoginId(lUserID);
        camera.setChannel((int) m_strDeviceInfo.byStartChan);
        camera.setStartDChan((int) m_strDeviceInfo.byStartChan);
        return camera;
    }

@@ -192,7 +188,7 @@
        int i = hCNetSDK.NET_DVR_Login_V40(m_strLoginInfo, m_strDeviceInfo);
        if (i < 0) {
            int errorCode = hCNetSDK.NET_DVR_GetLastError();
            log.info("登录异常：" + errorCode);
            log.error("登录异常：" + errorCode);
        }
    }

@@ -208,8 +204,9 @@
    public void loginAll() {
        try {
            log.debug("加载lib完成！");
            List<ArdCameras> ardCameras = ardCamerasMapper.selectArdCamerasListNoDataScope(new ArdCameras());
            List<ArdCameras> ardCameras = ardCamerasService.selectArdCamerasListNoDataScope(new ArdCameras());
            for (ArdCameras camera : ardCameras) {
                Thread.sleep(500);
                login(camera);
            }
        } catch (Exception ex) {
@@ -241,7 +238,7 @@
    /**
     * 是否在线
     *
     * @param cmd
     * @param cmd 相机命令
     */
    @Override
    public boolean isOnLine(CameraCmd cmd) {
@@ -250,8 +247,7 @@
            return false;
        }
        Integer userId = GlobalVariable.loginMap.get(cameraId);
        boolean isOnLine = hCNetSDK.NET_DVR_RemoteControl(userId, HCNetSDK.NET_DVR_CHECK_USER_STATUS, null, 0);
        return isOnLine;
        return hCNetSDK.NET_DVR_RemoteControl(userId, HCNetSDK.NET_DVR_CHECK_USER_STATUS, null, 0);
    }

    /**
@@ -276,13 +272,13 @@
            return false;
        }
        Integer userId = GlobalVariable.loginMap.get(cameraId);
        Integer dwStop;
        int dwStop;
        if (enable) {
            dwStop = 0;//开启
        } else {
            dwStop = 1;//关闭
        }
        Integer dwPTZCommand = -1;
        int dwPTZCommand = -1;
        switch (code) {
            /*方向*/
            case 1:
@@ -341,7 +337,7 @@
        boolean bool = hCNetSDK.NET_DVR_PTZControlWithSpeed_Other(userId, channelNum, dwPTZCommand, dwStop, speed);
        if (!bool) {
            int errorCode = hCNetSDK.NET_DVR_GetLastError();
            log.info("控制失败,请稍后重试" + errorCode);
            log.error("控制失败,请稍后重试" + errorCode);
        }
        return bool;
    }
@@ -349,7 +345,7 @@
    /**
     * 设置聚焦值
     *
     * @param cmd
     * @param cmd 相机命令
     */
    @Override
    @SdkOperate
@@ -369,7 +365,7 @@
        boolean bool = hCNetSDK.NET_DVR_GetDVRConfig(userId, NET_DVR_GET_FOCUSMODECFG, channelNum, point, focusmodeCfg.size(), ibrBytesReturned);
        if (!bool) {
            int code = hCNetSDK.NET_DVR_GetLastError();
            log.info("设置聚焦值失败,请稍后重试" + code);
            log.error("设置聚焦值失败,请稍后重试" + code);
        }
        return bool;
    }
@@ -377,7 +373,7 @@
    /**
     * 获取聚焦值
     *
     * @param cmd
     * @param cmd 相机命令
     */
    @Override
    public Map<String, Object> getFocusPos(CameraCmd cmd) {
@@ -402,7 +398,7 @@
            return map;
        } else {
            int code = hCNetSDK.NET_DVR_GetLastError();
            log.info("获取聚焦值失败,请稍后重试" + code);
            log.debug("获取聚焦值失败,请稍后重试" + code);
            return new HashMap<>();
        }
    }
@@ -410,7 +406,7 @@
    /**
     * 设置预置点
     *
     * @param cmd
     * @param cmd 相机命令
     */
    @Override
    @SdkOperate
@@ -425,7 +421,7 @@
        boolean bool = hCNetSDK.NET_DVR_PTZPreset_Other(userId, channelNum, SET_PRESET, PresetIndex);
        if (!bool) {
            int code = hCNetSDK.NET_DVR_GetLastError();
            log.info("预置点设置失败,请稍后重试" + code);
            log.error("预置点设置失败,请稍后重试" + code);
        }
        return bool;
    }
@@ -433,7 +429,7 @@
    /**
     * 转到预置点
     *
     * @param cmd
     * @param cmd 相机命令
     */
    @Override
    @SdkOperate
@@ -448,7 +444,7 @@
        boolean bool = hCNetSDK.NET_DVR_PTZPreset_Other(userId, channelNum, GOTO_PRESET, PresetIndex);
        if (!bool) {
            int code = hCNetSDK.NET_DVR_GetLastError();
            log.info("预置点设置失败,请稍后重试" + code);
            log.error("预置点设置失败,请稍后重试" + code);
        }
        return bool;
    }
@@ -480,8 +476,8 @@
            if (bool) {
                resolution.read();
                //视频输出口分辨率：0- 1024x768，1- 1280x720，2-1280x1024，3- 1680x1050，4- 1920x1080，5- 3840*2160
                byte byStreamType = resolution.struNormHighRecordPara.byStreamType;
                int dwVideoBitrate = resolution.struNormHighRecordPara.dwVideoBitrate;
//                byte byStreamType = resolution.struNormHighRecordPara.byStreamType;
//                int dwVideoBitrate = resolution.struNormHighRecordPara.dwVideoBitrate;
                int byResolution = resolution.struNormHighRecordPara.byResolution;
                switch (byResolution) {
                    case 0:
@@ -550,7 +546,7 @@
                }
            } else {
                int code = hCNetSDK.NET_DVR_GetLastError();
                System.out.println("控制失败,请稍后重试" + code);
                log.error("控制失败,请稍后重试" + code);
            }
        } catch (Exception ex) {
            log.error(ex.getMessage());
@@ -559,7 +555,6 @@
    }

    /**
     * @return
     * @描述 获取ptz信息
     * @参数 [userId, channelNum]
     * @返回值 boolean
@@ -583,7 +578,7 @@
        boolean bool = hCNetSDK.NET_DVR_GetDVRConfig(userId, HCNetSDK.NET_DVR_GET_PTZPOS, channelNum, pioint, m_ptzPosCurrent.size(), ibrBytesReturned);
        if (bool) {
            m_ptzPosCurrent.read();
            DecimalFormat df = new DecimalFormat("0.0");//设置保留位数
            // DecimalFormat df = new DecimalFormat("0.0");//设置保留位数
            //16进制转Integer后除10，保留小数点1位
            //实际显示的PTZ值是获取到的十六进制值的十分之一，
            //如获取的水平参数P的值是0x1750，实际显示的P值为175度；
@@ -595,7 +590,7 @@
            double p = b.setScale(1, BigDecimal.ROUND_HALF_UP).doubleValue();
            double t = c.setScale(1, BigDecimal.ROUND_HALF_UP).doubleValue();
            double z = d.setScale(1, BigDecimal.ROUND_HALF_UP).doubleValue();
            log.debug("T垂直参数为: " + p + "P水平参数为: " + t + "Z变倍参数为: " + z);
            //log.debug("T垂直参数为: " + p + "P水平参数为: " + t + "Z变倍参数为: " + z);
            Map<String, Object> ptzMap = new HashMap<>();
            ptzMap.put("p", p);
            ptzMap.put("t", t);
@@ -603,8 +598,8 @@
            return ptzMap;
        } else {
            int code = hCNetSDK.NET_DVR_GetLastError();
            log.info("控制失败,请稍后重试" + code);
            return null;
            log.error("控制失败,请稍后重试" + code);
            return new HashMap<>();
        }

    }
@@ -630,9 +625,9 @@
        NET_DVR_PTZPOS m_ptzPosCurrent = new NET_DVR_PTZPOS();
        m_ptzPosCurrent.wAction = 1;
        try {
            String p = String.valueOf((int) ((double) ptz.get("p") * 10));
            String t = String.valueOf((int) ((double) ptz.get("t") * 10));
            String z = String.valueOf((int) ((double) ptz.get("z") * 10));
            String p = String.valueOf((int) (ptz.get("p") * 10));
            String t = String.valueOf((int) (ptz.get("t") * 10));
            String z = String.valueOf((int) (ptz.get("z") * 10));
            m_ptzPosCurrent.wPanPos = (short) (Integer.parseInt(p, 16));
            m_ptzPosCurrent.wTiltPos = (short) (Integer.parseInt(t, 16));
            m_ptzPosCurrent.wZoomPos = (short) (Integer.parseInt(z, 16));
@@ -641,7 +636,7 @@
            boolean bool = hCNetSDK.NET_DVR_SetDVRConfig(userId, NET_DVR_SET_PTZPOS, channelNum, point, m_ptzPosCurrent.size());
            if (!bool) {
                int code = hCNetSDK.NET_DVR_GetLastError();
                log.info("设置ptz失败,请稍后重试" + code);
                log.error("设置ptz失败,请稍后重试" + code);
            }
            return bool;
        } catch (Exception ex) {
@@ -652,7 +647,7 @@

    @Override
    @SdkOperate
    public boolean setTargetPosition(CameraCmd cmd) {
    public boolean guideTargetPosition(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        Integer channelNum = cmd.getChannelNum();
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
@@ -662,7 +657,7 @@
        NET_DVR_PTZPOS m_ptzPosCurrent = new NET_DVR_PTZPOS();
        m_ptzPosCurrent.wAction = 1;
        try {
            ArdCameras cameras = ardCamerasMapper.selectArdCamerasById(cameraId);
            ArdCameras cameras = ardCamerasService.selectArdCamerasById(cameraId);
            double[] cameraPositon = new double[]{cameras.getLongitude(), cameras.getLatitude(), cameras.getAltitude()};
            double[] targetPositions = cmd.getTargetPosition();
            double[] cameraPTZ = GisUtil.getCameraPTZ(cameraPositon, targetPositions, 20, 150);
@@ -677,7 +672,7 @@
            boolean bool = hCNetSDK.NET_DVR_SetDVRConfig(userId, NET_DVR_SET_PTZPOS, channelNum, point, m_ptzPosCurrent.size());
            if (!bool) {
                int code = hCNetSDK.NET_DVR_GetLastError();
                log.info("设置ptz失败,请稍后重试" + code);
                log.error("设置ptz失败,请稍后重试" + code);
            }
            return bool;
        } catch (Exception ex) {
@@ -695,64 +690,36 @@
     * @修改人和其它信息 0-解锁 1-锁定
     */
    @Override
    @SdkOperate
    public boolean controlLock(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();//申请锁的相机
        ArdCameras ardCameras = ardCamerasMapper.selectArdCamerasById(cameraId);
        if (StringUtils.isNull(ardCameras)) {
            return false;//找不到相机拒绝操控
        }
        Integer expired = cmd.getExpired();//申请控制时长
        ArdCameras ardCameras = ardCamerasService.selectArdCamerasById(cameraId);
        Date now = new Date();
        now.setTime(now.getTime() + cmd.getExpired() * 1000);
        ardCameras.setOperatorExpired(now);//设置当前过期时间
        ardCamerasService.updateArdCameras(ardCameras);
        return true;
    }

    /**
     * @描述 操控解锁
     * @参数 [userId, channelNum]
     * @返回值 boolean
     * @创建人 刘苏义
     * @创建时间 2023/6/30 15:36
     * @修改人和其它信息
     */
    @Override
    public boolean controlUnLock(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();//申请解锁的相机
        String operator = cmd.getOperator();//申请者
        String currentOperator = ardCameras.getOperatorId();//相机当前控制者
        Date currentExpired = ardCameras.getOperatorExpired();//相机当前过期时间
        if (currentExpired == null) {
            //设置当前操作用户ID
            ardCameras.setOperatorId(operator);
            //设置当前过期时间
            Date now = new Date();
            now.setTime(now.getTime() + expired * 1000 * 60);
            ardCameras.setOperatorExpired(now);
            ardCamerasMapper.updateArdCameras(ardCameras);
        } else {
            //如果过期时间有值
            //如果是本人直接修改
            if (currentOperator.equals(operator)) {
                //设置当前过期时间
                Date now = new Date();
                now.setTime(now.getTime() + expired * 1000 * 60);
                ardCameras.setOperatorExpired(now);
                ardCamerasMapper.updateArdCameras(ardCameras);
            } else {
                //如果非本人比较优先级
                Integer currentLevel = 0;//当前操作者的优先级
                if (sdkPriority.priorityMap.containsKey(currentOperator)) {
                    /*当前控制者为系统报警用户*/
                    currentLevel = (Integer) sdkPriority.priorityMap.get(currentOperator);
                } else {
                    /*当前控制者为普通用户*/
                    SysUser sysUser = sysUserMapper.selectUserById(currentOperator);
                    currentLevel = sysUser.getCameraPriority();
                }
                Integer operatorLevel = 0;//获取申请者的优先级
                if (sdkPriority.priorityMap.containsKey(operator)) {
                    /*包含说明当前申请控制者为系统报警用户*/
                    operatorLevel = (Integer) sdkPriority.priorityMap.get(operator);
                } else {
                    /*否则申请控制者为当前登录用户*/
                    LoginUser loginUser = SecurityUtils.getLoginUser();
                    SysUser user = loginUser.getUser();//获取登录用户的信息
                    operatorLevel = user.getCameraPriority();
                }
                //判断优先级
                if (operatorLevel > currentLevel) {
                    Date now = new Date();
                    now.setTime(now.getTime() + expired * 60 * 1000);
                    ardCameras.setOperatorExpired(now);//设置当前过期时间
                    ardCameras.setOperatorId(operator);//设置当前用户
                    ardCamerasMapper.updateArdCameras(ardCameras);
                } else {
                    return false;//优先级低无法上锁
                }
        ArdCameras ardCameras = ardCamerasService.selectArdCamerasById(cameraId);
        if (ardCameras.getOperatorId().equals(operator)) {
            //如果解锁相机的当前用户是申请者，则清空该相机的过期时间
            ardCameras.setOperatorExpired(null);
            int i = ardCamerasService.updateArdCameras(ardCameras);
            if (i > 0) {
                log.debug(cameraId + "--解锁成功");
            }
        }
        return true;
@@ -781,12 +748,11 @@
        boolean bool = hCNetSDK.NET_DVR_GetDVRConfig(userId, NET_DVR_GET_PTZLOCKCFG, channelNum, point, netDvrPtzLockcfg.size(), ibrBytesReturned);
        if (!bool) {
            int code = hCNetSDK.NET_DVR_GetLastError();
            log.info("获取ptz锁定信息失败,请稍后重试" + code);
            log.error("获取ptz锁定信息失败,请稍后重试" + code);
            return -1;
        } else {
            netDvrPtzLockcfg.read();
            int byWorkMode = netDvrPtzLockcfg.byWorkMode;
            return byWorkMode;
            return netDvrPtzLockcfg.byWorkMode;
        }
    }

@@ -846,7 +812,7 @@
        boolean bool = hCNetSDK.NET_DVR_GetDVRConfig(userId, NET_DVR_GET_PTZSCOPE, channelNum, point, m_ptzPosCurrent.size(), ibrBytesReturned);
        if (!bool) {
            int code = hCNetSDK.NET_DVR_GetLastError();
            log.info("设置ptz失败,请稍后重试" + code);
            log.error("设置ptz失败,请稍后重试" + code);
            return new HashMap<>();
        } else {
            m_ptzPosCurrent.read();
@@ -896,7 +862,7 @@
            log.error("获取前端参数失败，错误码：" + hCNetSDK.NET_DVR_GetLastError());
        }
        struCameraParam.read();
        log.info("是否开启透雾：" + struCameraParam.struDefogCfg.byMode);
        log.debug("是否开启透雾：" + struCameraParam.struDefogCfg.byMode);

        NET_DVR_DEFOGCFG defogcfg = new NET_DVR_DEFOGCFG();
        if (enable) {
@@ -910,10 +876,9 @@
        boolean bool = hCNetSDK.NET_DVR_SetDVRConfig(userId, NET_DVR_SET_CCDPARAMCFG_EX, channelNum, point, struCameraParam.size());
        if (!bool) {
            int code = hCNetSDK.NET_DVR_GetLastError();
            log.info("设置透雾失败,请稍后重试" + code);
            return false;
            log.error("设置透雾失败,请稍后重试" + code);
        }
        log.info("设置透雾成功");
        log.debug("设置透雾成功");
        return bool;
    }

@@ -943,7 +908,7 @@
            log.error("获取前端参数失败，错误码：" + hCNetSDK.NET_DVR_GetLastError());
        }
        struDayNigh.read();
        log.info("是否开启夜视：" + struDayNigh.struDayNight.byDayNightFilterType);
        log.debug("是否开启夜视：" + struDayNigh.struDayNight.byDayNightFilterType);

        NET_DVR_DAYNIGHT daynight = new NET_DVR_DAYNIGHT();
        if (enable) {
@@ -959,10 +924,9 @@
        boolean bool = hCNetSDK.NET_DVR_SetDVRConfig(userId, NET_DVR_SET_CCDPARAMCFG_EX, channelNum, point, struDayNigh.size());
        if (!bool) {
            int code = hCNetSDK.NET_DVR_GetLastError();
            log.info("设置夜视失败,请稍后重试" + code);
            return false;
            log.error("设置夜视失败,请稍后重试" + code);
        }
        log.info("设置夜视成功");
        log.debug("设置夜视成功");
        return bool;
    }

@@ -989,10 +953,10 @@
        IntByReference ibrBytesReturned = new IntByReference(0);
        boolean b_GetCameraParam = hCNetSDK.NET_DVR_GetDVRConfig(userId, NET_DVR_GET_FOCUSMODECFG, channelNum, point, struFocusMode.size(), ibrBytesReturned);
        if (!b_GetCameraParam) {
            System.out.println("获取前端参数失败，错误码：" + hCNetSDK.NET_DVR_GetLastError());
            log.error("获取前端参数失败，错误码：" + hCNetSDK.NET_DVR_GetLastError());
        }
        struFocusMode.read();
        log.info("当前聚焦模式：" + struFocusMode.byFocusMode);
        log.debug("当前聚焦模式：" + struFocusMode.byFocusMode);

        if (enable) {
            struFocusMode.byFocusMode = 1;//手动聚焦
@@ -1006,11 +970,29 @@
        boolean bool = hCNetSDK.NET_DVR_SetDVRConfig(userId, NET_DVR_SET_FOCUSMODECFG, channelNum, point, struFocusMode.size());
        if (!bool) {
            int code = hCNetSDK.NET_DVR_GetLastError();
            log.info("设置聚焦模式失败,请稍后重试" + code);
            return false;
            log.error("设置聚焦模式失败,请稍后重试" + code);
        }
        log.info("设置聚焦模式成功");
        log.debug("设置聚焦模式成功");
        return bool;
    }

    public String getFocusMode(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        Integer channelNum = cmd.getChannelNum();
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
            return "";
        }
        Integer userId = GlobalVariable.loginMap.get(cameraId);
        NET_DVR_FOCUSMODE_CFG struFocusMode = new NET_DVR_FOCUSMODE_CFG();
        Pointer point = struFocusMode.getPointer();
        IntByReference ibrBytesReturned = new IntByReference(0);
        boolean b_GetCameraParam = hCNetSDK.NET_DVR_GetDVRConfig(userId, NET_DVR_GET_FOCUSMODECFG, channelNum, point, struFocusMode.size(), ibrBytesReturned);
        if (!b_GetCameraParam) {
            log.error("获取前端参数失败，错误码：" + hCNetSDK.NET_DVR_GetLastError());
        }
        struFocusMode.read();
        log.debug("当前聚焦模式：" + struFocusMode.byFocusMode);
        return String.valueOf(struFocusMode.byFocusMode);
    }

    /**
@@ -1031,7 +1013,7 @@
            return false;
        }
        Integer userId = GlobalVariable.loginMap.get(cameraId);
        Integer dwStop;
        int dwStop;
        if (enable) {
            dwStop = 0;//开启
        } else {
@@ -1040,10 +1022,9 @@
        boolean bool = hCNetSDK.NET_DVR_PTZControl_Other(userId, channelNum, HEATER_PWRON, dwStop);
        if (!bool) {
            int code = hCNetSDK.NET_DVR_GetLastError();
            log.info("设置云台加热失败,请稍后重试" + code);
            return false;
            log.error("设置云台加热失败,请稍后重试" + code);
        }
        log.info("设置云台加热成功");
        log.debug("设置云台加热成功");
        return bool;
    }

@@ -1073,7 +1054,7 @@
            log.error("获取前端参数失败，错误码：" + hCNetSDK.NET_DVR_GetLastError());
        }
        struDeicing.read();
        log.info("是否开启除冰：" + struDeicing.byEnableDeicing);
        log.debug("是否开启除冰：" + struDeicing.byEnableDeicing);

        if (enable) {
            struDeicing.byEnableDeicing = 1;//开启
@@ -1084,17 +1065,16 @@
        boolean bool = hCNetSDK.NET_DVR_SetDVRConfig(userId, NET_DVR_SET_DEVSERVER_CFG, channelNum, point, struDeicing.size());
        if (!bool) {
            int code = hCNetSDK.NET_DVR_GetLastError();
            log.info("设置镜头除冰失败,请稍后重试" + code);
            return false;
            log.error("设置镜头除冰失败,请稍后重试" + code);
        }
        log.info("设置镜头除冰成功");
        log.debug("设置镜头除冰成功");
        return bool;
    }

    /**
     * 截图 返给前端
     *
     * @param cmd
     * @param cmd 相机命令
     */
    public String captureJPEGPicture(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
@@ -1119,43 +1099,14 @@
        ByteBuffer jpegBuffer = ByteBuffer.allocate(1024 * 1024);
        // 抓图到内存，单帧数据捕获并保存成JPEG存放在指定的内存空间中
        boolean is = hCNetSDK.NET_DVR_CaptureJPEGPicture_NEW(userId, channelNum, jpeg, jpegBuffer, 1024 * 1024, a);
        log.info("-----------这里开始图片存入内存----------" + is);
        log.debug("-----------这里开始图片存入内存----------" + is);


        BASE64Encoder encoder = new BASE64Encoder();
        String png_base64 = encoder.encodeBuffer(jpegBuffer);//转换成base64串
        Base64.Encoder decoder = Base64.getEncoder();
        //  BASE64Encoder encoder = new BASE64Encoder();
        String png_base64 = decoder.encodeToString(jpegBuffer.array());//转换成base64串
        png_base64 = png_base64.replaceAll("\n", "").replaceAll("\r", "");//删除 \r\n
        log.info("-----------处理完成截图数据----------");
        log.debug("-----------处理完成截图数据----------");
        return png_base64;

//        ByteArrayInputStream in = new ByteArrayInputStream(jpegBuffer.array(), 0, a.getValue());
//        OutputStream outputStream = null;
//        try {
//            //1、设置response 响应头 //设置页面不缓存,清空buffer
//            response.reset();
//            //字符编码
//            response.setCharacterEncoding("UTF-8");
//            //二进制传输数据
//            response.setContentType("multipart/form-data");
//            //设置响应头
//            response.setHeader("Content-Disposition", "attachment;fileName=" + URLEncoder.encode(new SimpleDateFormat("yyyyMMddHHmmss").format(new Date()) + ".jpeg", "UTF-8"));
//
//            outputStream = response.getOutputStream();
//            // LoginUser loginUser = LoginContext.me().getLoginUser();
//            waterMarkUtil.markImageByIO("", in, outputStream, null, "jpeg");
//            outputStream.flush();
//        } catch (Exception e) {
//            e.printStackTrace();
//            log.error("抓图失败，请稍后重试");
//        } finally {
//            try {
//                outputStream.close();
//            } catch (IOException e) {
//                log.error("抓图失败，请稍后重试");
//            }
//        }


    }

    /**
@@ -1192,25 +1143,22 @@
        //设置图片大小
        ByteBuffer jpegBuffer = ByteBuffer.allocate(1024 * 1024);
        // 抓图到内存，单帧数据捕获并保存成JPEG存放在指定的内存空间中
        log.info("-----------这里开始封装 NET_DVR_CaptureJPEGPicture_NEW---------");
        log.debug("-----------这里开始封装 NET_DVR_CaptureJPEGPicture_NEW---------");
        boolean is = hCNetSDK.NET_DVR_CaptureJPEGPicture_NEW(userId, channelNum, jpeg, jpegBuffer, 1024 * 1024, a);
        log.info("-----------这里开始图片存入内存----------" + is);
        log.debug("-----------这里开始图片存入内存----------" + is);
        if (is) {
            log.info("hksdk(抓图)-结果状态值(0表示成功):" + hCNetSDK.NET_DVR_GetLastError());
            log.debug("hksdk(抓图)-结果状态值(0表示成功):" + hCNetSDK.NET_DVR_GetLastError());
            byte[] array = jpegBuffer.array();
            //存储到minio
            String BucketName = "pic";
            String uuid = UUID.randomUUID().toString().replace("-", "");
            String time = new SimpleDateFormat("yyyyMMdd").format(new Date());
            String ObjectName = time + "/" + uuid + ".jpeg";
            String ContentType = "image/JPEG";
            String ObjectName = "capture/" + IdUtils.simpleUUID() + ".jpeg";
            InputStream input = new ByteArrayInputStream(array);
            String url = "";
            try {
                boolean b = MinioUtils.uploadObject(BucketName, ObjectName, input, input.available(), ContentType);
                boolean b = minioUtil.uploadObject(BucketName, ObjectName, input, input.available(), MimeTypeUtils.IMAGE_JPEG);
                if (b) {
                    url = MinioUtils.getBucketObjectUrl(BucketName, ObjectName);
                    log.info("上传文件成功!" + url);
                    url = minioUtil.getBucketObjectUrl(BucketName, ObjectName);
                    log.debug("上传文件成功!" + url);
                }
            } catch (IOException ex) {
                log.error("上传文件异常：" + ex.getMessage());
@@ -1218,7 +1166,7 @@
            return url;
        } else {
            int code = hCNetSDK.NET_DVR_GetLastError();
            log.info("抓图失败,请稍后重试" + code);
            log.error("抓图失败,请稍后重试" + code);
            return "";
        }
    }
@@ -1270,31 +1218,21 @@
                        log.error("取流失败" + hCNetSDK.NET_DVR_GetLastError());
                        return "";
                    }
                    log.info("取流成功");
                    log.debug("取流成功");
                    GlobalVariable.previewMap.put(cameraId, lRealHandle);
                }
                if (!hCNetSDK.NET_DVR_SaveRealData_V30(GlobalVariable.previewMap.get(cameraId), 2, path)) {
                    log.error("保存视频文件到临时文件夹失败 错误码为:  " + hCNetSDK.NET_DVR_GetLastError());
                    return "";
                }
                log.info("录像开始");
                log.debug("录像开始");
            } else {
                if (GlobalVariable.previewMap.containsKey(cameraId)) {
                    Integer lRealHandle = GlobalVariable.previewMap.get(cameraId);
                    hCNetSDK.NET_DVR_StopRealPlay(lRealHandle);
                    GlobalVariable.previewMap.remove(cameraId);
                }
                log.info("录像停止");
                //存入minio
                String BucketName = cmd.getRecordBucketName();
                String ObjectName = cmd.getRecordObjectName();
                String ContentType = "video/MP4";
                FileInputStream stream = new FileInputStream(path);
                boolean b = MinioUtils.uploadObject(BucketName, ObjectName, stream, stream.available(), ContentType);
                if (b) {
                    url = MinioUtils.getBucketObjectUrl(BucketName, ObjectName);
                    log.info("上传文件成功!" + MinioClientSingleton.domainUrl + "/" + BucketName + "/" + ObjectName);
                }
                log.debug("录像停止");
            }
            return url;
        } catch (Exception ex) {
@@ -1304,12 +1242,11 @@
    }

    @Override
    public void recordToMinio(CameraCmd cmd) {
    public void recordStart(CameraCmd cmd) {
        try {
            String cameraId = cmd.getCameraId();
            Integer channelNum = cmd.getChannelNum();
            String path = FileUtils.createFile("D:/recordTemp/" + cameraId + ".mp4");
            boolean enable = cmd.isEnable();
            if (!GlobalVariable.loginMap.containsKey(cameraId)) {
                return;
            }
@@ -1334,44 +1271,159 @@
            previewinfo.bBlocked = 0;//0- 非阻塞取流，1-阻塞取流
            previewinfo.byNPQMode = 0;//NPQ模式：0-直连模式，1-过流媒体模式
            previewinfo.write();
            if (enable) {
                if (GlobalVariable.previewMap.containsKey(cameraId)) {
                    Integer lRealHandle = GlobalVariable.previewMap.get(cameraId);
                    hCNetSDK.NET_DVR_StopRealPlay(lRealHandle);
                    GlobalVariable.previewMap.remove(cameraId);
                    log.info("录像停止");
                }
                int lRealHandle = hCNetSDK.NET_DVR_RealPlay_V40(userId, previewinfo, null, null);
                if (lRealHandle == -1) {
                    log.error("取流失败" + hCNetSDK.NET_DVR_GetLastError());
                    return;
                }
                log.info("取流成功");
                GlobalVariable.previewMap.put(cameraId, lRealHandle);
                if (!hCNetSDK.NET_DVR_SaveRealData_V30(GlobalVariable.previewMap.get(cameraId), 2, path)) {
                    log.error("保存视频文件到临时文件夹失败 错误码为:  " + hCNetSDK.NET_DVR_GetLastError());
                    return;
                }
                log.info("录像开始");
            } else {
                if (GlobalVariable.previewMap.containsKey(cameraId)) {
                    Integer lRealHandle = GlobalVariable.previewMap.get(cameraId);
                    hCNetSDK.NET_DVR_StopRealPlay(lRealHandle);
                    GlobalVariable.previewMap.remove(cameraId);
                }
                log.info("录像停止");
                //存入minio
                String BucketName = cmd.getRecordBucketName();
                String ObjectName = cmd.getRecordObjectName();
                String ContentType = "video/MP4";
                FileInputStream stream = new FileInputStream(path);
                boolean b = MinioUtils.uploadObject(BucketName, ObjectName, stream, stream.available(), ContentType);
                if (b) {
                    log.info("上传文件成功!" + MinioClientSingleton.domainUrl + "/" + BucketName + "/" + ObjectName);
            if (GlobalVariable.previewMap.containsKey(cameraId)) {
                Integer lRealHandle = GlobalVariable.previewMap.get(cameraId);
                hCNetSDK.NET_DVR_StopRealPlay(lRealHandle);
                GlobalVariable.previewMap.remove(cameraId);
                log.debug("停止当前录像");
            }
            int lRealHandle = hCNetSDK.NET_DVR_RealPlay_V40(userId, previewinfo, null, null);
            if (lRealHandle == -1) {
                log.error("取流失败" + hCNetSDK.NET_DVR_GetLastError());
                return;
            }
            log.debug("取流成功");
            GlobalVariable.threadMap.put(cameraId, Thread.currentThread().getName());
            GlobalVariable.previewMap.put(cameraId, lRealHandle);
            if (!hCNetSDK.NET_DVR_SaveRealData_V30(GlobalVariable.previewMap.get(cameraId), 2, path)) {
                log.error("保存视频文件到临时文件夹失败 错误码为:  " + hCNetSDK.NET_DVR_GetLastError());
                return;
            }
            log.debug("录像开始");
        } catch (Exception ex) {
            log.error("开始录像异常" + ex.getMessage());
        }
    }

    @Override
    public String recordStopToMinio(CameraCmd cmd) {
        String url = "";
        try {
            String cameraId = cmd.getCameraId();
            Integer channelNum = cmd.getChannelNum();
            String path = FileUtils.createFile("D:/recordTemp/" + cameraId + ".mp4");
            if (!GlobalVariable.loginMap.containsKey(cameraId)) {
                return "";
            }
            Integer userId = GlobalVariable.loginMap.get(cameraId);
            //region 强制I帧
            HCNetSDK.NET_DVR_I_FRAME netDvrIFrame = new HCNetSDK.NET_DVR_I_FRAME();   //新建结构体对象
            netDvrIFrame.read();
            netDvrIFrame.dwChannel = channelNum;//因为上文代码中设置了通道号，按照上文中的设置
            netDvrIFrame.byStreamType = 0;
            netDvrIFrame.dwSize = netDvrIFrame.size();
            netDvrIFrame.write();
            if (!hCNetSDK.NET_DVR_RemoteControl(userId, 3402, netDvrIFrame.getPointer(), netDvrIFrame.dwSize)) {
                log.error("强制I帧 错误码为:  " + hCNetSDK.NET_DVR_GetLastError());
            }
            //endregion
            //region 预览参数
            NET_DVR_PREVIEWINFO previewinfo = new NET_DVR_PREVIEWINFO();
            previewinfo.read();
            previewinfo.lChannel = channelNum;
            previewinfo.dwStreamType = 0;//码流类型：0-主码流，1-子码流，2-三码流，3-虚拟码流，以此类推
            previewinfo.dwLinkMode = 0;//连接方式：0-TCP方式，1-UDP方式，2-多播方式，3-RTP方式，4-RTP/RTSP，5-RTP/HTTP，6-HRUDP（可靠传输），7-RTSP/HTTPS，8-NPQ
            previewinfo.hPlayWnd = null;//播放窗口的句柄，为NULL表示不解码显示。
            previewinfo.bBlocked = 0;//0- 非阻塞取流，1-阻塞取流
            previewinfo.byNPQMode = 0;//NPQ模式：0-直连模式，1-过流媒体模式
            previewinfo.write();
            //endregion
            if (GlobalVariable.previewMap.containsKey(cameraId)) {
                Integer lRealHandle = GlobalVariable.previewMap.get(cameraId);
                hCNetSDK.NET_DVR_StopRealPlay(lRealHandle);
                GlobalVariable.previewMap.remove(cameraId);
            }
            log.debug("录像停止");
            //存入minio
            String BucketName = cmd.getRecordBucketName();
            String ObjectName = cmd.getRecordObjectName()+".mp4";
            FileInputStream stream = new FileInputStream(path);
            boolean b = minioUtil.uploadObject(BucketName, ObjectName, stream, stream.available(), "video/MP4");
            if (b) {
                url = minioUtil.getBucketObjectUrl(BucketName, ObjectName);
                log.debug("上传文件成功!" + url);
            }
            return url;
        } catch (Exception ex) {
            log.error("录像异常" + ex.getMessage());
            return "";
        }
    }

    @Override
    public void recordStopNotToMinio(CameraCmd cmd) {
        try {
            String cameraId = cmd.getCameraId();
            Integer channelNum = cmd.getChannelNum();
            if (!GlobalVariable.loginMap.containsKey(cameraId)) {
                return;
            }
            Integer userId = GlobalVariable.loginMap.get(cameraId);
            //强制I帧结构体对象
            HCNetSDK.NET_DVR_I_FRAME netDvrIFrame = new HCNetSDK.NET_DVR_I_FRAME();   //新建结构体对象
            netDvrIFrame.read();
            netDvrIFrame.dwChannel = channelNum;//因为上文代码中设置了通道号，按照上文中的设置
            netDvrIFrame.byStreamType = 0;
            netDvrIFrame.dwSize = netDvrIFrame.size();
            netDvrIFrame.write();
            if (!hCNetSDK.NET_DVR_RemoteControl(userId, 3402, netDvrIFrame.getPointer(), netDvrIFrame.dwSize)) {
                log.error("强制I帧 错误码为:  " + hCNetSDK.NET_DVR_GetLastError());
            }
            //预览参数
            NET_DVR_PREVIEWINFO previewinfo = new NET_DVR_PREVIEWINFO();
            previewinfo.read();
            previewinfo.lChannel = channelNum;
            previewinfo.dwStreamType = 0;//码流类型：0-主码流，1-子码流，2-三码流，3-虚拟码流，以此类推
            previewinfo.dwLinkMode = 0;//连接方式：0-TCP方式，1-UDP方式，2-多播方式，3-RTP方式，4-RTP/RTSP，5-RTP/HTTP，6-HRUDP（可靠传输），7-RTSP/HTTPS，8-NPQ
            previewinfo.hPlayWnd = null;//播放窗口的句柄，为NULL表示不解码显示。
            previewinfo.bBlocked = 0;//0- 非阻塞取流，1-阻塞取流
            previewinfo.byNPQMode = 0;//NPQ模式：0-直连模式，1-过流媒体模式
            previewinfo.write();
            if (GlobalVariable.previewMap.containsKey(cameraId)) {
                Integer lRealHandle = GlobalVariable.previewMap.get(cameraId);
                hCNetSDK.NET_DVR_StopRealPlay(lRealHandle);
                GlobalVariable.previewMap.remove(cameraId);
            }
            log.debug("录像停止");
        } catch (Exception ex) {
            log.error("录像停止异常" + ex.getMessage());
        }
    }

    //获取IP通道
    @Override
    public List<ArdChannel> getCameraChannelList(ArdCameras camera) {
        /*获取通道*/
        List<ArdChannel> channelList = new ArrayList<>();
        try {
            Integer chanNum = camera.getChanNum();
            Integer startDChan = camera.getStartDChan();
            if (chanNum > 0) {
                // 获取通道号
                for (int iChannum = 0; iChannum < chanNum; iChannum++) {
                    ArdChannel ardChannel = new ArdChannel();
                    int channum = iChannum + startDChan+1;
                    HCNetSDK.NET_DVR_PICCFG_V40 strPicCfg = new HCNetSDK.NET_DVR_PICCFG_V40();
                    strPicCfg.dwSize = strPicCfg.size();
                    strPicCfg.write();
                    Pointer pStrPicCfg = strPicCfg.getPointer();
                    NativeLong lChannel = new NativeLong(channum);
                    IntByReference pInt = new IntByReference(0);
                    boolean b_GetPicCfg = hCNetSDK.NET_DVR_GetDVRConfig(camera.getLoginId(), HCNetSDK.NET_DVR_GET_PICCFG_V40, lChannel.intValue(),
                            pStrPicCfg, strPicCfg.size(), pInt);
                    if (b_GetPicCfg) {
                        strPicCfg.read();
                        String channelName = new String(strPicCfg.sChanName, "GBK").trim();
                        ardChannel.setName(channelName);
                    }
                    ardChannel.setDeviceId(camera.getId());
                    ardChannel.setChanNo(iChannum + 1);
                    channelList.add(ardChannel);
                }
            }
        } catch (Exception ex) {
            log.error("录像异常" + ex.getMessage());
            log.error("获取相机通道异常:" + ex.getMessage());
        }
        return channelList;
    }
}