1、修改相机异步登录 2、sdk切换更改为策略模式 3、修复手动巡检停止录像bug

‘liusuyi’

2023-11-07 6decb63d865de6b551324fd9782555786132170e

1、修改相机异步登录
2、sdk切换更改为策略模式
3、修复手动巡检停止录像bug

 ard-work/src/main/java/com/ruoyi/device/camera/service/ICameraSdkService.java

@@ -2,6 +2,8 @@


import com.ruoyi.device.camera.domain.ArdCameras;

import com.ruoyi.device.camera.domain.CameraCmd;

import org.springframework.scheduling.annotation.Async;



import java.util.Map;



public interface ICameraSdkService {


 ard-work/src/main/java/com/ruoyi/device/camera/service/impl/AsyncLogin.java

文件已删除

 ard-work/src/main/java/com/ruoyi/device/camera/service/impl/CameraSdkServiceImpl.java

@@ -7,8 +7,8 @@
import com.ruoyi.device.camera.domain.CameraCmd;

import com.ruoyi.device.camera.service.IArdCamerasService;

import com.ruoyi.device.camera.service.ICameraSdkService;

import com.ruoyi.utils.sdk.dhsdk.service.IDhClientService;

import com.ruoyi.utils.sdk.hiksdk.service.IHikClientService;

import com.ruoyi.device.camera.strategy.SdkStrategy;

import com.ruoyi.device.camera.strategy.SdkStrategyFactory;

import lombok.extern.slf4j.Slf4j;

import org.springframework.boot.ApplicationArguments;

import org.springframework.boot.ApplicationRunner;

@@ -32,27 +32,30 @@
    @Resource

    private IArdCamerasService ardCamerasService;

    @Resource

    IHikClientService hikClientService;

    private RedisCache redisCache;

    @Resource

    IDhClientService dhClientService;

    @Resource

    RedisCache redisCache;

    private SdkStrategyFactory sdkStrategyFactory;



    /**

     * 启动线程方法，用于执行初始化登录相机的逻辑

     *

     * @param args 命令行参数

     */

    @Override

    public void run(ApplicationArguments args) throws Exception {

    public void run(ApplicationArguments args) {



        try {

            // 从ardCamerasService中获取ArdCameras列表

            List<ArdCameras> ardCameras = ardCamerasService.selectArdCamerasListNoDataScope(new ArdCameras());

            for (ArdCameras camera : ardCameras) {

                if ("1".equals(camera.getFactory())) {

                    hikClientService.login(camera);

                } else if ("2".equals(camera.getFactory())) {

                    dhClientService.login(camera);

                }

                login(camera);

            }

        } catch (Exception ex) {

            // 初始化登录相机异常，记录错误日志

            log.error("初始化登录相机异常：" + ex.getMessage());

        }

    }





    //登录

    @Override

@@ -61,13 +64,10 @@
        try {

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    hikClientService.login(ardCamera);

                    result = true;

                } else if (factory.equals("2")) {

                    dhClientService.login(ardCamera);

                    result = true;

                }

                SdkStrategy sdkStrategy = sdkStrategyFactory.getSdkStrategy(factory);

                //sdkStrategy.login(ardCamera);//同步登录

                sdkStrategy.asyncLogin(ardCamera);//异步登录

                result=true;

            }

        } catch (Exception ex) {

            log.error("登录异常：" + ex.getMessage());

@@ -84,11 +84,8 @@
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    result = hikClientService.logout(cameraId);

                } else if (factory.equals("2")) {

                    result = dhClientService.logout(cameraId);

                }

                SdkStrategy sdkStrategy = sdkStrategyFactory.getSdkStrategy(factory);

                result = sdkStrategy.logout(cameraId);

            }

        } catch (Exception ex) {

            log.error("注销异常：" + ex.getMessage());

@@ -106,11 +103,8 @@
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    onLine = hikClientService.isOnLine(cmd);

                } else if (factory.equals("2")) {

                    onLine = dhClientService.isOnLine(cmd);

                }

                SdkStrategy sdkStrategy = sdkStrategyFactory.getSdkStrategy(factory);

                onLine = sdkStrategy.isOnLine(cmd);

            }

            return onLine;

        } catch (Exception ex) {

@@ -129,11 +123,8 @@
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    result = hikClientService.pTZControlWithSpeed(cmd);

                } else if (factory.equals("2")) {

                    result = dhClientService.pTZControl(cmd);

                }

                SdkStrategy sdkStrategy = sdkStrategyFactory.getSdkStrategy(factory);

                result = sdkStrategy.pTZControl(cmd);

            }

            return result;

        } catch (Exception ex) {

@@ -151,11 +142,8 @@
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    result = hikClientService.setFocusPos(cmd);

                } else if (factory.equals("2")) {

                    result = dhClientService.setFocusPos(cmd);

                }

                SdkStrategy sdkStrategy = sdkStrategyFactory.getSdkStrategy(factory);

                result = sdkStrategy.setFocusPos(cmd);

            }

        } catch (Exception ex) {

            log.error("设置聚焦值异常：" + ex.getMessage());

@@ -173,11 +161,8 @@
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    result = hikClientService.getFocusPos(cmd);

                } else if (factory.equals("2")) {

                    result = dhClientService.getFocusPos(cmd);

                }

                SdkStrategy sdkStrategy = sdkStrategyFactory.getSdkStrategy(factory);

                result = sdkStrategy.getFocusPos(cmd);

            }

        } catch (Exception ex) {

            log.error("获取聚焦值异常：" + ex.getMessage());

@@ -187,6 +172,7 @@


    //设置预置位

    @Override

    @SdkOperate

    public boolean setPreset(CameraCmd cmd) {

        boolean result = false;

        try {

@@ -194,11 +180,8 @@
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    result = hikClientService.setPreset(cmd);

                } else if (factory.equals("2")) {

                    result = dhClientService.setPreset(cmd);

                }

                SdkStrategy sdkStrategy = sdkStrategyFactory.getSdkStrategy(factory);

                result = sdkStrategy.setPreset(cmd);

            }

        } catch (Exception ex) {

            log.error("设置预置位异常：" + ex.getMessage());

@@ -208,6 +191,7 @@


    //调用预置位

    @Override

    @SdkOperate

    public boolean gotoPreset(CameraCmd cmd) {

        boolean result = false;

        try {

@@ -215,11 +199,8 @@
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    result = hikClientService.gotoPreset(cmd);

                } else if (factory.equals("2")) {

                    result = dhClientService.gotoPreset(cmd);

                }

                SdkStrategy sdkStrategy = sdkStrategyFactory.getSdkStrategy(factory);

                result = sdkStrategy.gotoPreset(cmd);

            }

        } catch (Exception ex) {

            log.error("调用预置位异常：" + ex.getMessage());

@@ -236,11 +217,8 @@
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    map = hikClientService.getVideoCompressionCfg(cmd);

                } else if (factory.equals("2")) {

                    map = dhClientService.getVideoCompressionCfg(cmd);

                }

                SdkStrategy sdkStrategy = sdkStrategyFactory.getSdkStrategy(factory);

                map = sdkStrategy.getVideoCompressionCfg(cmd);

            }

        } catch (Exception ex) {

            log.error("获取码流压缩参数异常：" + ex.getMessage());

@@ -257,11 +235,8 @@
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    result = hikClientService.controlDefogcfg(cmd);

                } else if (factory.equals("2")) {

                    //不支持

                }

                SdkStrategy sdkStrategy = sdkStrategyFactory.getSdkStrategy(factory);

                result = sdkStrategy.controlDefogcfg(cmd);

            }

        } catch (Exception ex) {

            log.error("操控透雾异常：" + ex.getMessage());

@@ -278,11 +253,8 @@
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    result = hikClientService.controlInfrarecfg(cmd);

                } else if (factory.equals("2")) {

                    result = dhClientService.controlInfrarecfg(cmd);

                }

                SdkStrategy sdkStrategy = sdkStrategyFactory.getSdkStrategy(factory);

                result = sdkStrategy.controlInfrarecfg(cmd);

            }

        } catch (Exception ex) {

            log.error("操控红外异常：" + ex.getMessage());

@@ -299,11 +271,8 @@
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    result = hikClientService.controlFocusMode(cmd);

                } else if (factory.equals("2")) {

                    result = dhClientService.controlFocusMode(cmd);

                }

                SdkStrategy sdkStrategy = sdkStrategyFactory.getSdkStrategy(factory);

                result = sdkStrategy.controlFocusMode(cmd);

            }

        } catch (Exception ex) {

            log.error("操控聚焦模式异常：" + ex.getMessage());

@@ -320,11 +289,8 @@
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    result = hikClientService.getFocusMode(cmd);

                } else if (factory.equals("2")) {

                    result = dhClientService.getFocusMode(cmd);

                }

                SdkStrategy sdkStrategy = sdkStrategyFactory.getSdkStrategy(factory);

                result = sdkStrategy.getFocusMode(cmd);

            }

        } catch (Exception ex) {

            log.error("获取聚焦模式异常：" + ex.getMessage());

@@ -341,11 +307,8 @@
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    result = hikClientService.controlPTHeateRpwron(cmd);

                } else if (factory.equals("2")) {

                    //不支持

                }

                SdkStrategy sdkStrategy = sdkStrategyFactory.getSdkStrategy(factory);

                result = sdkStrategy.controlPTHeateRpwron(cmd);

            }

        } catch (Exception ex) {

            log.error("操控云台加热异常：" + ex.getMessage());

@@ -362,11 +325,8 @@
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    result = hikClientService.controlCameraDeicing(cmd);

                } else if (factory.equals("2")) {

                    //不支持

                }

                SdkStrategy sdkStrategy = sdkStrategyFactory.getSdkStrategy(factory);

                result = sdkStrategy.controlCameraDeicing(cmd);

            }

        } catch (Exception ex) {

            log.error("操控云台加热异常：" + ex.getMessage());

@@ -383,11 +343,8 @@
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    result = hikClientService.getPTZLockInfo(cmd);

                } else if (factory.equals("2")) {



                }

                SdkStrategy sdkStrategy = sdkStrategyFactory.getSdkStrategy(factory);

                result = sdkStrategy.getPTZLockInfo(cmd);

            }

        } catch (Exception ex) {

            log.error("获取云台锁定信息异常：" + ex.getMessage());

@@ -413,13 +370,8 @@
            if (ardCamera != null) {

                //获取摄像头工厂

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    //调用hikClientService的picCutCate方法

                    url = hikClientService.picCutCate(cmd);

                } else if (factory.equals("2")) {

                    //调用dhClientService的picCutCate方法

                    url = dhClientService.picCutCate(cmd);

                }

                SdkStrategy sdkStrategy = sdkStrategyFactory.getSdkStrategy(factory);

                url = sdkStrategy.picCutCate(cmd);

            }

        } catch (Exception ex) {

            log.error("抓图异常：" + ex.getMessage());

@@ -436,11 +388,8 @@
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    map = hikClientService.getPtz(cmd);

                } else if (factory.equals("2")) {

                    map = dhClientService.getPtz(cmd);

                }

                SdkStrategy sdkStrategy = sdkStrategyFactory.getSdkStrategy(factory);

                map = sdkStrategy.getPtz(cmd);

            }

        } catch (Exception ex) {

            log.error("获取ptz异常：" + ex.getMessage());

@@ -457,11 +406,8 @@
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    map = hikClientService.getPtzScope(cmd);

                } else if (factory.equals("2")) {



                }

                SdkStrategy sdkStrategy = sdkStrategyFactory.getSdkStrategy(factory);

                map = sdkStrategy.getPtzScope(cmd);

            }

        } catch (Exception ex) {

            log.error("获取ptz范围异常：" + ex.getMessage());

@@ -479,11 +425,8 @@
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    result = hikClientService.setPtz(cmd);

                } else if (factory.equals("2")) {

                    result = dhClientService.setPtz(cmd);

                }

                SdkStrategy sdkStrategy = sdkStrategyFactory.getSdkStrategy(factory);

                result = sdkStrategy.setPtz(cmd);

            }

        } catch (Exception ex) {

            log.error("设置ptz异常：" + ex.getMessage());

@@ -501,11 +444,8 @@
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    result = hikClientService.setZeroPtz(cmd);

                } else if (factory.equals("2")) {

                    result = dhClientService.setZeroPtz(cmd);

                }

                SdkStrategy sdkStrategy = sdkStrategyFactory.getSdkStrategy(factory);

                result = sdkStrategy.setZeroPtz(cmd);

            }

        } catch (Exception ex) {

            log.error("设置零方位角异常：" + ex.getMessage());

@@ -523,11 +463,8 @@
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    result = hikClientService.guideTargetPosition(cmd);

                } else if (factory.equals("2")) {

                    result = dhClientService.guideTargetPosition(cmd);

                }

                SdkStrategy sdkStrategy = sdkStrategyFactory.getSdkStrategy(factory);

                result = sdkStrategy.guideTargetPosition(cmd);

            }

        } catch (Exception ex) {

            log.error("引导指向目标异常：" + ex.getMessage());

@@ -590,11 +527,8 @@
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    url = hikClientService.record(cmd);

                } else if (factory.equals("2")) {

                    url = dhClientService.record(cmd);

                }

                SdkStrategy sdkStrategy = sdkStrategyFactory.getSdkStrategy(factory);

                url = sdkStrategy.record(cmd);

            }

        } catch (Exception ex) {

            log.error("录像异常：" + ex.getMessage());

@@ -611,11 +545,8 @@
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    result = hikClientService.recordStart(cmd);

                } else if (factory.equals("2")) {

                    result = dhClientService.recordStart(cmd);

                }

                SdkStrategy sdkStrategy = sdkStrategyFactory.getSdkStrategy(factory);

                result = sdkStrategy.recordStart(cmd);

            }

        } catch (Exception ex) {

            log.error("开始录像异常：" + ex.getMessage());

@@ -632,11 +563,8 @@
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    url = hikClientService.recordStopToMinio(cmd);

                } else if (factory.equals("2")) {

                    url = dhClientService.recordStopToMinio(cmd);

                }

                SdkStrategy sdkStrategy = sdkStrategyFactory.getSdkStrategy(factory);

                url = sdkStrategy.recordStopToMinio(cmd);

            }

        } catch (Exception ex) {

            log.error("停止录像异常：" + ex.getMessage());

@@ -653,11 +581,8 @@
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    result = hikClientService.recordStopNotToMinio(cmd);

                } else if (factory.equals("2")) {

                    result = dhClientService.recordStopNotToMinio(cmd);

                }

                SdkStrategy sdkStrategy = sdkStrategyFactory.getSdkStrategy(factory);

                result = sdkStrategy.recordStopNotToMinio(cmd);

            }

        } catch (Exception ex) {

            log.error("停止录像异常：" + ex.getMessage());

@@ -674,11 +599,8 @@
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    map = hikClientService.getGisInfo(cmd);

                } else if (factory.equals("2")) {

                    map = dhClientService.getGisInfo(cmd);

                }

                SdkStrategy sdkStrategy = sdkStrategyFactory.getSdkStrategy(factory);

                map = sdkStrategy.getGisInfo(cmd);

            }

        } catch (Exception ex) {

            log.error("获取相机架设参数异常：" + ex.getMessage());


 ard-work/src/main/java/com/ruoyi/device/camera/strategy/SdkStrategy.java

文件名从 ard-work/src/main/java/com/ruoyi/utils/sdk/hiksdk/service/IHikClientService.java 修改
@@ -1,109 +1,106 @@
package com.ruoyi.utils.sdk.hiksdk.service;



import com.ruoyi.device.camera.domain.ArdCameras;

import com.ruoyi.device.camera.domain.CameraCmd;

import com.ruoyi.device.channel.domain.ArdChannel;



import java.util.List;

import java.util.Map;



/**

 * @ClassName: IHikClientService

 * @Description: 海康操作客户端接口类

 * @Author: Administrator

 * @Date: 2023年01月17日 15:59

 * @Version: 1.0

 **/

public interface IHikClientService {



    //同步登录

    void login(ArdCameras cameras);



    //异步登录

    void asyncLogin(ArdCameras cameras);



    //注销

    boolean logout(String cameraId);



    //在线状态

    boolean isOnLine(CameraCmd cmd);



    //云台控制

    boolean pTZControlWithSpeed(CameraCmd cmd);



    //设置聚焦值

    boolean setFocusPos(CameraCmd cmd);



    //获取聚焦值

    int getFocusPos(CameraCmd cmd);



    //设置预置位

    boolean setPreset(CameraCmd cmd);



    //调用预置位

    boolean gotoPreset(CameraCmd cmd);



    //获取码流压缩参数

    Map<String, Object> getVideoCompressionCfg(CameraCmd cmd);



    //透雾

    boolean controlDefogcfg(CameraCmd cmd);



    //红外

    boolean controlInfrarecfg(CameraCmd cmd);



    //聚焦模式

    boolean controlFocusMode(CameraCmd cmd);



    //获取聚焦模式

    String getFocusMode(CameraCmd cmd);



    //云台加热

    boolean controlPTHeateRpwron(CameraCmd cmd);



    //镜头除冰

    boolean controlCameraDeicing(CameraCmd cmd);



    //获取云台锁定信息

    int getPTZLockInfo(CameraCmd cmd);



    //抓图-返给前端二进制流

    String captureJPEGPicture(CameraCmd cmd);



    //抓图

    String picCutCate(CameraCmd cmd);



    //ptz 三坐标

    Map<String, Object> getPtz(CameraCmd cmd);



    //获取ptz范围

    Map<String, Object> getPtzScope(CameraCmd cmd);



    //设置ptz

    boolean setPtz(CameraCmd cmd);



    //设置零方位角

    boolean setZeroPtz(CameraCmd cmd);



    //手动录像

    String record(CameraCmd cmd);





    //引导目标位置

    boolean guideTargetPosition(CameraCmd cmd);



    //开始录像

    boolean recordStart(CameraCmd cmd);



    //停止录像-上传minio-返回录像url

    String recordStopToMinio(CameraCmd cmd);



    //停止录像-不上传minio

    boolean recordStopNotToMinio(CameraCmd cmd);



    //获取相机通道信息

    public List<ArdChannel> getCameraChannelList(ArdCameras camera);



    //获取GIS信息数据

    public Map<String, Object> getGisInfo(CameraCmd cmd);

}

package com.ruoyi.device.camera.strategy;

import com.ruoyi.device.camera.domain.ArdCameras;
import com.ruoyi.device.camera.domain.CameraCmd;
import com.ruoyi.device.channel.domain.ArdChannel;
import java.util.List;
import java.util.Map;

/**
 *  相机SDK策略接口
 * 刘苏义
 * 2023/11/7 10:48:52
 */
public interface SdkStrategy {

    //同步登录
    boolean login(ArdCameras cameras);

    //异步登录
    void asyncLogin(ArdCameras cameras);

    //注销
    boolean logout(String cameraId);

    //在线状态
    boolean isOnLine(CameraCmd cmd);

    //云台控制
    boolean pTZControl(CameraCmd cmd);

    //设置聚焦值
    boolean setFocusPos(CameraCmd cmd);

    //获取聚焦值
    int getFocusPos(CameraCmd cmd);

    //设置预置位
    boolean setPreset(CameraCmd cmd);

    //调用预置位
    boolean gotoPreset(CameraCmd cmd);

    //获取码流压缩参数
    Map<String, Object> getVideoCompressionCfg(CameraCmd cmd);

    //透雾
    boolean controlDefogcfg(CameraCmd cmd);

    //红外
    boolean controlInfrarecfg(CameraCmd cmd);

    //聚焦模式
    boolean controlFocusMode(CameraCmd cmd);

    //获取聚焦模式
    String getFocusMode(CameraCmd cmd);

    //云台加热
    boolean controlPTHeateRpwron(CameraCmd cmd);

    //镜头除冰
    boolean controlCameraDeicing(CameraCmd cmd);

    //获取云台锁定信息
    int getPTZLockInfo(CameraCmd cmd);

    //抓图-返给前端二进制流
    String captureJPEGPicture(CameraCmd cmd);

    //抓图
    String picCutCate(CameraCmd cmd);

    //ptz 三坐标
    Map<String, Object> getPtz(CameraCmd cmd);

    //获取ptz范围
    Map<String, Object> getPtzScope(CameraCmd cmd);

    //设置ptz
    boolean setPtz(CameraCmd cmd);

    //设置零方位角
    boolean setZeroPtz(CameraCmd cmd);

    //手动录像
    String record(CameraCmd cmd);


    //引导目标位置
    boolean guideTargetPosition(CameraCmd cmd);

    //开始录像
    boolean recordStart(CameraCmd cmd);

    //停止录像-上传minio-返回录像url
    String recordStopToMinio(CameraCmd cmd);

    //停止录像-不上传minio
    boolean recordStopNotToMinio(CameraCmd cmd);

    //获取相机通道信息
    public List<ArdChannel> getCameraChannelList(ArdCameras camera);

    //获取GIS信息数据
    public Map<String, Object> getGisInfo(CameraCmd cmd);
}

 ard-work/src/main/java/com/ruoyi/device/camera/strategy/SdkStrategyFactory.java

对比新文件
@@ -0,0 +1,43 @@
package com.ruoyi.device.camera.strategy;

import com.ruoyi.device.camera.domain.ArdCameras;
import com.ruoyi.utils.sdk.dhsdk.service.impl.DhSdkStrategy;
import com.ruoyi.utils.sdk.hiksdk.service.impl.HikSdkStrategy;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;


/**
 * @Description: SDK策略工厂类
 * @ClassName: SdkStrategyFactory
 * @Author: 刘苏义
 * @Date: 2023年11月07日10:53:00
 **/
@Component
public class SdkStrategyFactory {

    @Resource
    private HikSdkStrategy hikSdkStrategy;
    @Resource
    private DhSdkStrategy dhSdkStrategy;

    /**
     * 根据传入的工厂参数获取对应的Sdk策略
     *
     * @param factory 工厂参数
     * @return 对应的Sdk策略
     * @throws IllegalArgumentException 如果不支持该工厂参数
     */
    public SdkStrategy getSdkStrategy(String factory) {
        if (factory.equals("1")) {
            return hikSdkStrategy;
        } else if (factory.equals("2")) {
            return dhSdkStrategy;
        } else {
            throw new IllegalArgumentException("Unsupported device: " + factory);
        }
    }

}

 ard-work/src/main/java/com/ruoyi/inspect/service/impl/ArdVideoInspectTaskServiceImpl.java

@@ -9,7 +9,6 @@
import com.ruoyi.device.camera.domain.CameraCmd;

import com.ruoyi.device.camera.mapper.ArdCamerasMapper;

import com.ruoyi.device.camera.service.ICameraSdkService;

import com.ruoyi.utils.sdk.hiksdk.service.IHikClientService;

import com.ruoyi.inspect.domain.ArdVideoInspectRecord;

import com.ruoyi.inspect.mapper.ArdVideoInspectRecordMapper;

import com.ruoyi.inspect.mapper.ArdVideoInspectTaskStepMapper;


 ard-work/src/main/java/com/ruoyi/inspect/service/impl/InspectionTaskManager.java

@@ -1,10 +1,12 @@
package com.ruoyi.inspect.service.impl;



import com.ruoyi.device.camera.domain.CameraCmd;

import com.ruoyi.device.camera.service.ICameraSdkService;

import com.ruoyi.device.camera.service.impl.CameraSdkServiceImpl;

import com.ruoyi.utils.sdk.common.GlobalVariable;

import com.ruoyi.utils.sdk.hiksdk.service.IHikClientService;

import com.ruoyi.inspect.domain.ArdVideoInspectTask;

import com.ruoyi.inspect.mapper.ArdVideoInspectTaskMapper;

import com.ruoyi.utils.sdk.hiksdk.service.impl.HikSdkStrategy;

import lombok.extern.slf4j.Slf4j;

import org.springframework.stereotype.Component;



@@ -28,7 +30,7 @@
    @Resource

    ArdVideoInspectTaskMapper ardVideoInspectTaskMapper;

    @Resource

    private IHikClientService hikClientService;

    private ICameraSdkService cameraSdkService;



    public static Map<String, InspectionTask> taskMap;//已启动任务map



@@ -77,7 +79,7 @@
            CameraCmd cmd = new CameraCmd();

            cmd.setCameraId(ardVideoInspectTask.getCameraId());

            cmd.setChanNo(ardVideoInspectTask.getChannel());

            hikClientService.recordStopNotToMinio(cmd);

            cameraSdkService.recordStopNotToMinio(cmd);

            GlobalVariable.previewMap.remove(cameraId);

        }

        /*停止任务*/


 ard-work/src/main/java/com/ruoyi/utils/sdk/dhsdk/controller/DhSdkController.java

@@ -8,7 +8,7 @@
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.device.camera.domain.CameraCmd;
import com.ruoyi.utils.sdk.dhsdk.service.IDhClientService;
import com.ruoyi.utils.sdk.dhsdk.service.impl.DhSdkStrategy;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.stereotype.Controller;
@@ -36,7 +36,7 @@
public class DhSdkController extends BaseController {

    @Resource
    private IDhClientService sdk;
    private DhSdkStrategy sdk;


    @ApiOperation(value = "云台控制", notes = "Code:1-左上 2-上 3-右上 4-左 5-巡航 6-右 7-左下 8-下 9-右下 10-焦距变大 11-焦距变小\n" +

 ard-work/src/main/java/com/ruoyi/utils/sdk/dhsdk/service/IDhClientService.java

文件已删除

 ard-work/src/main/java/com/ruoyi/utils/sdk/dhsdk/service/impl/DhSdkStrategy.java

文件名从 ard-work/src/main/java/com/ruoyi/utils/sdk/dhsdk/service/impl/DhClientServiceImpl.java 修改
@@ -1,941 +1,1063 @@
package com.ruoyi.utils.sdk.dhsdk.service.impl;



import com.ruoyi.alarm.global.domain.GuidePriorityQueue;

import com.ruoyi.alarm.global.domain.GuideTask;

import com.ruoyi.common.annotation.SdkOperate;

import com.ruoyi.common.utils.file.FileUtils;

import com.ruoyi.common.utils.file.MimeTypeUtils;

import com.ruoyi.common.utils.uuid.IdUtils;

import com.ruoyi.device.camera.domain.ArdCameras;

import com.ruoyi.device.camera.domain.CameraCmd;

import com.ruoyi.device.camera.service.IArdCamerasService;

import com.ruoyi.device.channel.domain.ArdChannel;

import com.ruoyi.device.channel.service.IArdChannelService;

import com.ruoyi.utils.sdk.dhsdk.lib.NetSDKLib;

import com.ruoyi.utils.sdk.dhsdk.lib.NetSDKLib.LLong;

import com.ruoyi.utils.sdk.dhsdk.lib.enumeration.EM_NEW_CONFIG;

import com.ruoyi.utils.sdk.dhsdk.lib.enumeration.NET_EM_CFG_OPERATE_TYPE;

import com.ruoyi.utils.sdk.dhsdk.lib.structure.CFG_VIDEO_IN_FOCUS;

import com.ruoyi.utils.sdk.dhsdk.lib.structure.DH_OUT_PTZ_VIEW_RANGE_STATUS;

import com.ruoyi.utils.sdk.dhsdk.module.*;

import com.ruoyi.utils.sdk.dhsdk.service.IDhClientService;

import com.ruoyi.utils.sdk.common.GlobalVariable;

import com.ruoyi.media.domain.Vtdu;

import com.ruoyi.media.service.IVtduService;

import com.ruoyi.utils.gis.GisUtil;

import com.ruoyi.utils.minio.MinioUtil;

import com.sun.jna.Pointer;

import lombok.extern.slf4j.Slf4j;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.stereotype.Service;



import javax.annotation.Resource;

import java.io.*;

import java.text.DecimalFormat;

import java.util.*;

import java.util.concurrent.PriorityBlockingQueue;



import static com.ruoyi.utils.sdk.dhsdk.lib.NetSDKLib.*;

import static com.ruoyi.utils.sdk.dhsdk.lib.NetSDKLib.NET_PTZ_ControlType.NET_PTZ_POINT_MOVE_CONTROL;

import static com.ruoyi.utils.sdk.dhsdk.lib.NetSDKLib.NET_PTZ_ControlType.NET_PTZ_POINT_SET_CONTROL;

import static com.ruoyi.utils.sdk.dhsdk.lib.ToolKits.getErrorCodePrint;

import static com.ruoyi.utils.sdk.dhsdk.module.LoginModule.netsdk;





/**

 * @ClassName DhSdkServiceImpl

 * @Description:

 * @Author 刘苏义

 * @Date 2023/10/13 21:19

 * @Version 1.0

 */

@Service

@Slf4j(topic = "dhSdk")

public class DhClientServiceImpl implements IDhClientService {

    @Resource

    private IArdCamerasService ardCamerasService;

    @Resource

    private IArdChannelService ardChannelService;

    @Resource

    private IVtduService vtduService;

    @Value("${minio.endpoint}")

    private String minioEndPoint;

    private final Object lock = new Object();



    // 设备断线通知回调

    private static DisConnect disConnect = new DisConnect();

    // 网络连接恢复

    private static HaveReConnect haveReConnect = new HaveReConnect();





    /**

     * 登录

     * 刘苏义

     * 2023/10/17 8:28:13

     */

    @Override

    public Boolean login(ArdCameras camera) {

        LoginModule.init(disConnect, haveReConnect);

        NetSDKLib.NET_DEVICEINFO_Ex m_stDeviceInfo = new NetSDKLib.NET_DEVICEINFO_Ex();

        LLong loginId = LoginModule.login(camera.getIp(), camera.getPort(), camera.getUsername(), camera.getPassword(), m_stDeviceInfo);

        if (loginId.longValue() <= 0) {

            camera.setChanNum(0);

            camera.setLoginId(-1);

            camera.setState("0");

            ardCamerasService.updateArdCameras(camera);

            return false;

        }

        if (GlobalVariable.loginMap.containsKey(camera.getId())) {

            GlobalVariable.loginMap.remove(camera.getId());

        }

        //删除管理通道

        ardChannelService.deleteArdChannelByDeviceId(camera.getId());

        camera.setState("1");

        camera.setChanNum(m_stDeviceInfo.byChanNum);

        camera.setStartDChan(1);

        camera.setLoginId((int) loginId.longValue());

        ardCamerasService.updateArdCameras(camera);

        GlobalVariable.loginMap.put(camera.getId(), loginId);



        //获取最新通道

        for (int i = 1; i < m_stDeviceInfo.byChanNum + 1; i++) {

            ArdChannel channel = new ArdChannel();

            AV_CFG_ChannelName av_cfg_channelName = new AV_CFG_ChannelName();

            boolean b = ConfigModule.GetNewDevConfig(loginId, i - 1, CFG_CMD_CHANNELTITLE, av_cfg_channelName);

            if (b) {

                String chanName = null;

                try {

                    chanName = new String(av_cfg_channelName.szName, "GBK").trim();

                } catch (UnsupportedEncodingException e) {

                    e.printStackTrace();

                }

                channel.setName(chanName);

            } else {

                channel.setName("通道" + i);

            }

            channel.setDeviceId(camera.getId());

            channel.setChanNo(i);

            ardChannelService.insertArdChannel(channel);

        }

        //配置到流媒体

        for (int i = 1; i < m_stDeviceInfo.byChanNum + 1; i++) {

            String name = camera.getId() + "_" + i;

            String rtspSource = "rtsp://" + camera.getUsername() + ":" + camera.getPassword() + "@" + camera.getIp() + ":" + camera.getRtspPort() + "/cam/realmonitor?channel=" + i + "&subtype=0";

            Vtdu vtdu = vtduService.selectVtduByName(name);

            if (vtdu != null) {

                vtduService.deleteVtduByName(name);

            }

            //添加到流媒体

            CameraCmd cmd = new CameraCmd(camera.getId(), i);

            Map<String, Object> videoCompressionCfg = getVideoCompressionCfg(cmd);

            vtdu = new Vtdu();

            if (videoCompressionCfg.get("videoEncType") != null) {

                if (videoCompressionCfg.get("videoEncType").equals("标准h264")) {

                    vtdu.setIsCode("0");//默认不转码

                } else {

                    vtdu.setIsCode("1");//默认转码

                }

            } else {

                vtdu.setIsCode("0");//默认不转码

            }

            vtdu.setRtspSource(rtspSource);

            vtdu.setName(camera.getId() + "_" + i);

            vtdu.setMode("1");//默认CPU软解码

            vtdu.setCameraId(camera.getId());

            vtduService.insertVtdu(vtdu);

        }



        //创建引导队列

        if (!GuidePriorityQueue.cameraQueueMap.containsKey(camera.getId())) {

            Comparator<GuideTask> comparator = GuidePriorityQueue.getComparator();

            PriorityBlockingQueue<GuideTask> priorityQueue = new PriorityBlockingQueue<>(1000, comparator);

            GuidePriorityQueue.cameraQueueMap.put(camera.getId(), priorityQueue);

        }

        return true;

    }



    /**

     * 注销

     * 刘苏义

     * 2023/10/17 8:28:13

     */

    @Override

    public Boolean logout(String cameraId) {

        if (!GlobalVariable.loginMap.containsKey(cameraId)) {

            return false;

        }

        LLong loginId = (LLong) GlobalVariable.loginMap.get(cameraId);

        return LoginModule.logout(loginId);

    }



    /**

     * 是否在线检测

     * 刘苏义

     * 2023/10/17 8:28:13

     */

    @Override

    public boolean isOnLine(CameraCmd cmd) {

        try {

            String cameraId = cmd.getCameraId();

            if (!GlobalVariable.loginMap.containsKey(cameraId)) {

                return false;

            }

            LLong loginId = (LLong) GlobalVariable.loginMap.get(cameraId);

            NetSDKLib.NET_WORKSTATE dh_ptz_location_info = new NetSDKLib.NET_WORKSTATE();

            boolean b = ConfigModule.queryDevState(loginId, NET_DEVSTATE_ONLINE, dh_ptz_location_info);

            if (!b) {

                return false;

            }

        } catch (Exception ex) {

            log.error("检测在线异常：" + ex.getMessage());

            return false;

        }

        return true;

    }



    /**

     * 云台控制

     * 刘苏义

     * 2023/10/17 8:28:13

     */

    @Override

    @SdkOperate

    public boolean pTZControl(CameraCmd cmd) {

        String cameraId = cmd.getCameraId();

        boolean enable = cmd.isEnable();

        Integer chanNo = cmd.getChanNo();

        Integer speed = cmd.getSpeed();

        Integer code = cmd.getCode();

        if (!GlobalVariable.loginMap.containsKey(cameraId)) {

            return false;

        }

        LLong loginId = (LLong) GlobalVariable.loginMap.get(cameraId);

        int dwStop;

        if (enable) {

            dwStop = 0;//开启

        } else {

            dwStop = 1;//关闭

        }

        int dwPTZCommand = -1;

        switch (code) {

            /*方向*/

            case 1:

                dwPTZCommand = NET_EXTPTZ_ControlType.NET_EXTPTZ_LEFTTOP;

                break;

            case 2:

                dwPTZCommand = NET_PTZ_ControlType.NET_PTZ_UP_CONTROL;

                break;

            case 3:

                dwPTZCommand = NET_EXTPTZ_ControlType.NET_EXTPTZ_RIGHTTOP;

                break;

            case 4:

                dwPTZCommand = NET_PTZ_ControlType.NET_PTZ_LEFT_CONTROL;

                break;

            case 5:

                dwPTZCommand = NET_PTZ_ControlType.NET_PTZ_POINT_LOOP_CONTROL;

                break;

            case 6:

                dwPTZCommand = NET_PTZ_ControlType.NET_PTZ_RIGHT_CONTROL;

                break;

            case 7:

                dwPTZCommand = NET_EXTPTZ_ControlType.NET_EXTPTZ_LEFTDOWN;

                break;

            case 8:

                dwPTZCommand = NET_PTZ_ControlType.NET_PTZ_DOWN_CONTROL;

                break;

            case 9:

                dwPTZCommand = NET_EXTPTZ_ControlType.NET_EXTPTZ_RIGHTDOWN;

                break;

            /*焦距*/

            case 10:

                dwPTZCommand = NET_PTZ_ControlType.NET_PTZ_ZOOM_ADD_CONTROL;

                break;

            case 11:

                dwPTZCommand = NET_PTZ_ControlType.NET_PTZ_ZOOM_DEC_CONTROL;

                break;

            /*焦点*/

            case 12:

                dwPTZCommand = NET_PTZ_ControlType.NET_PTZ_FOCUS_ADD_CONTROL;

                break;

            case 13:

                dwPTZCommand = NET_PTZ_ControlType.NET_PTZ_FOCUS_DEC_CONTROL;

                break;

            /*光圈*/

            case 14:

                dwPTZCommand = NET_PTZ_ControlType.NET_PTZ_APERTURE_ADD_CONTROL;

                break;

            case 15:

                dwPTZCommand = NET_PTZ_ControlType.NET_PTZ_APERTURE_DEC_CONTROL;

                break;

            case 16:

                dwPTZCommand = NET_PTZ_ControlType.NET_PTZ_LAMP_CONTROL;

                break;

        }

        boolean bool = PtzControlModule.ptzControl(loginId, chanNo - 1, dwPTZCommand, speed, speed, 0, dwStop);

        if (!bool) {

            log.error("控制失败,请稍后重试" + getErrorCodePrint());

        }

        return bool;

    }



    /**

     * 获取PTZ值

     * 刘苏义

     * 2023/10/17 8:28:13

     */

    @Override

    public Map<String, Object> getPtz(CameraCmd cmd) {

        Map<String, Object> ptzMap = new HashMap<>();

        String cameraId = cmd.getCameraId();

        if (!GlobalVariable.loginMap.containsKey(cameraId)) {

            return null;

        }

        LLong loginId = (LLong) GlobalVariable.loginMap.get(cameraId);

        NetSDKLib.NET_PTZ_LOCATION_INFO dh_ptz_location_info = new NetSDKLib.NET_PTZ_LOCATION_INFO();

        boolean b = ConfigModule.queryDevState(loginId, NET_DEVSTATE_PTZ_LOCATION, dh_ptz_location_info);

        if (b) {

            DecimalFormat df = new DecimalFormat("0.0");//设置保留位数

            String nPTZPan = df.format((float) dh_ptz_location_info.nPTZPan / 10);

            float t = (float) dh_ptz_location_info.nPTZTilt / 10 * -1;

            String nPTZTilt = df.format(t < 0 ? t + 360 : t);

            String nPTZZoom = df.format((float) dh_ptz_location_info.nPTZZoom);

            ptzMap.put("p", nPTZPan);

            ptzMap.put("t", nPTZTilt);

            ptzMap.put("z", nPTZZoom);

        }

        return ptzMap;

    }



    /**

     * @描述 设置ptz信息

     * @参数 [userId, channelNum]

     * @返回值 boolean

     * @创建人 刘苏义

     * @创建时间 2023/1/17 16:36

     * @修改人和其它信息 注意俯仰角度负值需要加上360得到的正值进行设置

     */

    @Override

    @SdkOperate

    public boolean setPtz(CameraCmd cmd) {

        String cameraId = cmd.getCameraId();

        Integer chanNo = cmd.getChanNo();

        Map<String, Double> ptz = cmd.getPtzMap();

        if (!GlobalVariable.loginMap.containsKey(cameraId)) {

            return false;

        }

        LLong loginId = (LLong) GlobalVariable.loginMap.get(cameraId);

        try {

            int p = (int) (ptz.get("p") * 10);

            int t = (int) (ptz.get("t") * 10);

            t = t > 900 ? 3600 - t : t * -1;



            int z = ptz.get("z").intValue() == 0 ? 1 : ptz.get("z").intValue();

            boolean bool = netsdk.CLIENT_DHPTZControlEx(loginId, chanNo - 1, NetSDKLib.NET_EXTPTZ_ControlType.NET_EXTPTZ_EXACTGOTO, p, t, z, 0);

            if (!bool) {

                log.error("控制失败,请稍后重试" + getErrorCodePrint());

            }

            return bool;

        } catch (Exception ex) {

            log.error(ex.getMessage());

            return false;

        }

    }



    /**

     * @描述 设置零方位角

     * @参数 [userId, channelNum]

     * @返回值 boolean

     * @创建人 刘苏义

     * @创建时间 2023/1/17 16:36

     * @修改人和其它信息 注意俯仰角度负值需要加上360得到的正值进行设置

     */

    @Override

    public boolean setZeroPtz(CameraCmd cmd) {

        String cameraId = cmd.getCameraId();

        Integer chanNo = cmd.getChanNo();

        if (!GlobalVariable.loginMap.containsKey(cameraId)) {

            return false;

        }

        LLong loginId = (LLong) GlobalVariable.loginMap.get(cameraId);

        boolean bool = NetSDKLib.NETSDK_INSTANCE.CLIENT_DHPTZControlEx(loginId, chanNo - 1, NetSDKLib.NET_EXTPTZ_ControlType.NET_EXTPTZ_RESETZERO, 0, 0, 0, 0);

        if (!bool) {

            log.error("控制失败,请稍后重试" + getErrorCodePrint());

        }

        return bool;

    }



    /**

     * @描述 截图 存服务器

     * @参数 [cameraId, channelNum]

     * @返回值 java.lang.String

     * @创建人 刘苏义

     * @创建时间 2023/2/2 14:59

     * @修改人和其它信息

     */

    @Override

    public String picCutCate(CameraCmd cmd) {

        String cameraId = cmd.getCameraId();

        Integer chanNo = cmd.getChanNo();

        if (!GlobalVariable.loginMap.containsKey(cameraId)) {

            return "";

        }

        LLong loginId = (LLong) GlobalVariable.loginMap.get(cameraId);

        String bucketName = "pic";

        String picUrl = "";

        String bucketObject = "/capture/" + IdUtils.simpleUUID() + ".jpeg";

        fCaptureReceiveCB m_CaptureReceiveCB = new fCaptureReceiveCB(minioEndPoint, bucketName, bucketObject);

        CapturePictureModule.setSnapRevCallBack(m_CaptureReceiveCB);

        boolean b = CapturePictureModule.remoteCapturePicture(loginId, chanNo - 1);

        if (b) {

            picUrl = minioEndPoint + "/" + bucketName + bucketObject;

        }

        return picUrl;



    }



    /**

     * @描述 短时录像

     * @参数 [userId, channelNum, enable]

     * @返回值 void

     * @创建人 刘苏义

     * @创建时间 2023/1/20 11:18

     * @修改人和其它信息

     */

    @Override

    public String record(CameraCmd cmd) {

        try {

            String url = "";

            String cameraId = cmd.getCameraId();

            Integer chanNo = cmd.getChanNo();

            String path = FileUtils.createFile("D:/recordTemp/" + cameraId + ".mp4");

            boolean enable = cmd.isEnable();

            if (!GlobalVariable.loginMap.containsKey(cameraId)) {

                return "";

            }

            LLong loginId = (LLong) GlobalVariable.loginMap.get(cameraId);



            if (enable) {

                LLong lRealHandle = new LLong(0);

                if (!GlobalVariable.previewMap.containsKey(cameraId)) {

                    lRealHandle = RealPlayModule.startRealPlay(loginId, chanNo - 1, path);

                    if (lRealHandle.longValue() <= 0) {

                        log.error("取流失败" + getErrorCodePrint());

                        return "";

                    }

                    log.debug("取流成功");

                    GlobalVariable.previewMap.put(cameraId, lRealHandle.intValue());

                }

                log.debug("录像开始");

            } else {

                if (GlobalVariable.previewMap.containsKey(cameraId)) {

                    LLong lRealHandle = new LLong(GlobalVariable.previewMap.get(cameraId));

                    RealPlayModule.stopRealPlay(lRealHandle);

                    GlobalVariable.previewMap.remove(cameraId);

                }

                log.debug("录像停止");

            }

            return url;

        } catch (Exception ex) {

            log.error("录像异常" + ex.getMessage());

            return "";

        }

    }



    @Override

    public boolean recordStart(CameraCmd cmd) {

        try {

            String cameraId = cmd.getCameraId();

            Integer chanNo = cmd.getChanNo();

            String path = FileUtils.createFile("D:/recordTemp/" + cameraId + ".mp4");

            if (!GlobalVariable.loginMap.containsKey(cameraId)) {

                return false;

            }

            LLong loginId = (LLong) GlobalVariable.loginMap.get(cameraId);

            LLong lRealHandle;

            if (GlobalVariable.previewMap.containsKey(cameraId)) {

                lRealHandle = new LLong(GlobalVariable.previewMap.get(cameraId));

                RealPlayModule.stopRealPlay(lRealHandle);

                GlobalVariable.previewMap.remove(cameraId);

                log.debug("停止当前录像");

            }

            lRealHandle = RealPlayModule.startRealPlay(loginId, chanNo - 1, path);

            if (lRealHandle.longValue() <= 0) {

                log.error("取流失败" + getErrorCodePrint());

            }

            log.debug("取流成功");

            GlobalVariable.previewMap.put(cameraId, lRealHandle.intValue());

            GlobalVariable.threadMap.put(cameraId, Thread.currentThread().getName());

            //if (!netsdk.CLIENT_SaveRealData(lRealHandle, path)) {

            //    log.error("保存视频文件到临时文件夹失败 错误码为:  " +getErrorCodePrint());

            //    return false;

            //}

            log.debug("录像开始");

            return true;

        } catch (Exception ex) {

            log.error("开始录像异常" + ex.getMessage());

            return false;

        }

    }



    @Override

    public String recordStopToMinio(CameraCmd cmd) {

        String url = "";

        try {

            String cameraId = cmd.getCameraId();

            String path = FileUtils.createFile("D:/recordTemp/" + cameraId + ".mp4");

            if (!GlobalVariable.loginMap.containsKey(cameraId)) {

                return "";

            }

            LLong lRealHandle;

            if (GlobalVariable.previewMap.containsKey(cameraId)) {

                lRealHandle = new LLong(GlobalVariable.previewMap.get(cameraId));

                RealPlayModule.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 boolean recordStopNotToMinio(CameraCmd cmd) {

        boolean result = false;

        try {

            String cameraId = cmd.getCameraId();

            if (!GlobalVariable.loginMap.containsKey(cameraId)) {

                return false;

            }

            LLong lRealHandle;

            if (GlobalVariable.previewMap.containsKey(cameraId)) {

                lRealHandle = new LLong(GlobalVariable.previewMap.get(cameraId));

                RealPlayModule.stopRealPlay(lRealHandle);

                GlobalVariable.previewMap.remove(cameraId);

                log.debug("停止当前录像");

            }



            result = true;

        } catch (Exception ex) {

            log.error("录像异常" + ex.getMessage());

        }

        return result;

    }



    /**

     * 引导目标位置

     * 刘苏义

     * 2023/10/17 8:27:48

     */

    @Override

    public boolean guideTargetPosition(CameraCmd cmd) {

        String cameraId = cmd.getCameraId();

        Integer chanNo = cmd.getChanNo();

        if (!GlobalVariable.loginMap.containsKey(cameraId)) {

            return false;

        }

        LLong loginId = (LLong) GlobalVariable.loginMap.get(cameraId);

        try {

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

            int p = (int) (cameraPTZ[0] * 10);

            int t = (int) (cameraPTZ[1] * 10);

            int z = (int) (cameraPTZ[2]);

            boolean bool = netsdk.CLIENT_DHPTZControlEx(loginId, chanNo - 1, NetSDKLib.NET_EXTPTZ_ControlType.NET_EXTPTZ_EXACTGOTO, p, t, z, 0);

            if (!bool) {

                log.error("控制失败,请稍后重试" + getErrorCodePrint());

            }

            return bool;

        } catch (Exception ex) {

            log.error("引导异常:" + ex.getMessage());

            return false;

        }

    }



    //转至预置点

    @Override

    public boolean gotoPreset(CameraCmd cmd) {

        String cameraId = cmd.getCameraId();

        Integer chanNo = cmd.getChanNo();

        Integer PresetIndex = cmd.getPresetIndex();

        if (!GlobalVariable.loginMap.containsKey(cameraId)) {

            return false;

        }

        LLong loginId = (LLong) GlobalVariable.loginMap.get(cameraId);

        try {



            boolean bool = netsdk.CLIENT_DHPTZControlEx(loginId, chanNo - 1, NET_PTZ_POINT_MOVE_CONTROL, 0, PresetIndex, 0, 0);

            if (!bool) {

                log.error("控制失败,请稍后重试" + getErrorCodePrint());

            }

            return bool;

        } catch (Exception ex) {

            log.error("转至预置点异常:" + ex.getMessage());

            return false;

        }

    }



    @Override

    //设置预置位

    public boolean setPreset(CameraCmd cmd) {

        String cameraId = cmd.getCameraId();

        Integer chanNo = cmd.getChanNo();

        Integer PresetIndex = cmd.getPresetIndex();

        if (!GlobalVariable.loginMap.containsKey(cameraId)) {

            return false;

        }

        LLong loginId = (LLong) GlobalVariable.loginMap.get(cameraId);

        try {



            boolean bool = netsdk.CLIENT_DHPTZControlEx(loginId, chanNo - 1, NET_PTZ_POINT_SET_CONTROL, 0, PresetIndex, 0, 0);

            if (!bool) {

                log.error("控制失败,请稍后重试" + getErrorCodePrint());

            }

            return bool;

        } catch (Exception ex) {

            log.error("设置预置点异常:" + ex.getMessage());

            return false;

        }

    }



    //切换聚焦模式

    @Override

    public boolean controlFocusMode(CameraCmd cmd) {

        String cameraId = cmd.getCameraId();

        Integer chanNo = cmd.getChanNo();

        boolean enable = cmd.isEnable();

        if (!GlobalVariable.loginMap.containsKey(cameraId)) {

            return false;

        }

        LLong loginId = (LLong) GlobalVariable.loginMap.get(cameraId);

        try {

            CFG_VIDEO_IN_FOCUS cfg_video_in_focus = new CFG_VIDEO_IN_FOCUS();

            cfg_video_in_focus.nVideoInFocusRealNum = 3;//配置使用个数

            for (int i = 0; i < 3; i++) {

                cfg_video_in_focus.stVideoInFocusUnit[i].nSensitivity = 1;//聚焦灵敏度, 0-高, 1-默认, 2-低



                cfg_video_in_focus.stVideoInFocusUnit[i].nIRCorrection = 2;//红外光聚焦修正, 0-不修正, 1-修正, 2-自动修正

                cfg_video_in_focus.stVideoInFocusUnit[i].nFocusLimit = 10000;//聚焦极限值, 单位毫米

                if (enable) {//聚焦模式, 0-关闭, 1-辅助聚焦, 2-自动聚焦, 3-半自动聚焦, 4-手动聚焦

                    cfg_video_in_focus.stVideoInFocusUnit[i].nMode = 4;//手动聚焦

                    cfg_video_in_focus.stVideoInFocusUnit[i].emFocusMode = 0;//聚焦极限Manual

                    log.debug("当前为手动聚焦模式");

                } else {

                    cfg_video_in_focus.stVideoInFocusUnit[i].nMode = 2;//自动聚焦

                    cfg_video_in_focus.stVideoInFocusUnit[i].emFocusMode = 1;//聚焦极限Auto

                    log.debug("当前为自动聚焦模式");

                }

            }

            cfg_video_in_focus.nChannelIndex = chanNo - 1;

            boolean bool = ConfigModule.SetDevConfig(loginId, chanNo - 1, NetSDKLib.CFG_CMD_VIDEOIN_FOCUS, cfg_video_in_focus);

            if (!bool) {

                log.error("控制失败,请稍后重试" + getErrorCodePrint());

            }

            return bool;

        } catch (Exception ex) {

            log.error("切换聚焦模式异常:" + ex.getMessage());

            return false;

        }

    }



    @Override

    public String getFocusMode(CameraCmd cmd) {

        String mode = "";

        String cameraId = cmd.getCameraId();

        Integer chanNo = cmd.getChanNo();

        if (!GlobalVariable.loginMap.containsKey(cameraId)) {

            return "";

        }

        LLong loginId = (LLong) GlobalVariable.loginMap.get(cameraId);

        try {

            NET_VIDEOIN_FOCUSMODE_INFO focusModeInfo = new NET_VIDEOIN_FOCUSMODE_INFO();

            int emCfgOpType = NET_EM_CFG_OPERATE_TYPE.NET_EM_CFG_VIDEOIN_FOCUSMODE;

            boolean bool = ConfigModule.GetConfig(loginId, chanNo - 1, emCfgOpType, focusModeInfo);

            if (!bool) {

                log.error("获取失败,请稍后重试" + getErrorCodePrint());

            }

            System.out.println("配置类型:" + focusModeInfo.emCfgType);     // 具体信息，参考库里的枚举

            System.out.println("聚焦模式:" + focusModeInfo.emFocusMode);

            switch (focusModeInfo.emFocusMode) {

                case 0:

                    mode = "关闭";

                    break;

                case 1:

                    mode = "辅助聚焦";

                    break;

                case 2:

                    mode = "自动聚焦";

                    break;

                case 3:

                    mode = "半自动聚焦";

                    break;

                case 4:

                    mode = "手动聚焦";

                    break;

            }



        } catch (Exception ex) {

            log.error("获取聚焦模式异常:" + ex.getMessage());



        }

        return mode;

    }



    //透雾

    @Override

    public boolean controlDefogcfg(CameraCmd cmd) {

        String cameraId = cmd.getCameraId();

        Integer chanNo = cmd.getChanNo();

        boolean enable = cmd.isEnable();

        if (!GlobalVariable.loginMap.containsKey(cameraId)) {

            return false;

        }

        LLong loginId = (LLong) GlobalVariable.loginMap.get(cameraId);

        try {

            String command = EM_NEW_CONFIG.CFG_CMD_VIDEOINDEFOG.getValue();

            //CFG_VIDEOINDEFOG_LIST cfg_videoindefog_list=new CFG_VIDEOINDEFOG_LIST();

            boolean bool = ConfigModule.SetDevConfig(loginId, chanNo - 1, command, null);

            if (!bool) {

                log.error("控制失败,请稍后重试" + getErrorCodePrint());

            }

            return bool;

        } catch (Exception ex) {

            log.error("切换透雾异常:" + ex.getMessage());

            return false;

        }

    }



    //红外

    @Override

    public boolean controlInfrarecfg(CameraCmd cmd) {

        String cameraId = cmd.getCameraId();

        Integer chanNo = cmd.getChanNo();

        boolean enable = cmd.isEnable();

        if (!GlobalVariable.loginMap.containsKey(cameraId)) {

            return false;

        }

        LLong loginId = (LLong) GlobalVariable.loginMap.get(cameraId);

        try {

            CFG_LIGHTING_INFO cfg_lighting_info = new CFG_LIGHTING_INFO();

            cfg_lighting_info.nLightingDetailNum = 1;

            if (enable) {

                cfg_lighting_info.stuLightingDetail[0].emMode = EM_CFG_LIGHTING_MODE.EM_CFG_LIGHTING_MODE_MANUAL;

            } else {

                cfg_lighting_info.stuLightingDetail[0].emMode = EM_CFG_LIGHTING_MODE.EM_CFG_LIGHTING_MODE_OFF;

            }

            boolean bool = ConfigModule.SetDevConfig(loginId, chanNo - 1, CFG_CMD_LIGHTING, cfg_lighting_info);

            if (!bool) {

                log.error("控制失败,请稍后重试" + getErrorCodePrint());

            }

            return bool;

        } catch (Exception ex) {

            log.error("切换红外异常:" + ex.getMessage());

            return false;

        }

    }



    //获取聚焦值

    @Override

    public int getFocusPos(CameraCmd cmd) {

        int result = 0;

        try {

            String cameraId = cmd.getCameraId();

            Integer chanNo = cmd.getChanNo();

            if (!GlobalVariable.loginMap.containsKey(cameraId)) {

                return result;

            }

            LLong loginId = (LLong) GlobalVariable.loginMap.get(cameraId);

            NET_PTZ_LOCATION_INFO net_ptz_location_info = new NET_PTZ_LOCATION_INFO();

            net_ptz_location_info.nChannelID = chanNo - 1;

            boolean bool = ConfigModule.queryDevState(loginId, NET_DEVSTATE_PTZ_LOCATION, net_ptz_location_info);

            if (!bool) {

                log.error("控制失败,请稍后重试" + getErrorCodePrint());

            }

            result = net_ptz_location_info.nFocusMapValue;

        } catch (Exception ex) {

            log.error("获取聚焦值异常:" + ex.getMessage());

        }

        return result;

    }



    //设置聚焦值

    @Override

    public boolean setFocusPos(CameraCmd cmd) {

        String cameraId = cmd.getCameraId();

        Integer chanNo = cmd.getChanNo();

        boolean enable = cmd.isEnable();

        if (!GlobalVariable.loginMap.containsKey(cameraId)) {

            return false;

        }

        LLong loginId = (LLong) GlobalVariable.loginMap.get(cameraId);

        try {

            CFG_LIGHTING_INFO cfg_lighting_info = new CFG_LIGHTING_INFO();

            cfg_lighting_info.nLightingDetailNum = 1;

            if (enable) {

                cfg_lighting_info.stuLightingDetail[0].emMode = EM_CFG_LIGHTING_MODE.EM_CFG_LIGHTING_MODE_MANUAL;

            } else {

                cfg_lighting_info.stuLightingDetail[0].emMode = EM_CFG_LIGHTING_MODE.EM_CFG_LIGHTING_MODE_OFF;

            }

            boolean bool = ConfigModule.SetDevConfig(loginId, chanNo - 1, CFG_CMD_LIGHTING, cfg_lighting_info);

            if (!bool) {

                log.error("控制失败,请稍后重试" + getErrorCodePrint());

            }

            return bool;

        } catch (Exception ex) {

            log.error("设置聚焦值异常:" + ex.getMessage());

            return false;

        }

    }



    //获取码流压缩参数

    @Override

    public Map<String, Object> getVideoCompressionCfg(CameraCmd cmd) {

        Map<String, Object> map = new HashMap<>();

        try {

            String cameraId = cmd.getCameraId();

            Integer chanNo = cmd.getChanNo();

            if (!GlobalVariable.loginMap.containsKey(cameraId)) {

                return null;

            }

            LLong loginId = (LLong) GlobalVariable.loginMap.get(cameraId);

            CFG_ENCODE_INFO cfg_encode_info = new CFG_ENCODE_INFO();

            cfg_encode_info.nChannelID = chanNo - 1;

            boolean b = ConfigModule.GetNewDevConfig(loginId, chanNo - 1, CFG_CMD_ENCODE, cfg_encode_info);

            if (b) {

                int emCompression = cfg_encode_info.stuMainStream[0].stuVideoFormat.emCompression;//视频格式

                String videoEncType = "";

                switch (emCompression) {

                    case 0:

                        videoEncType = "MPEG4";

                        break;

                    case 1:

                        videoEncType = "MS-MPEG4";

                        break;

                    case 2:

                        videoEncType = "MPEG2";

                        break;

                    case 3:

                        videoEncType = "MPEG1";

                        break;

                    case 4:

                        videoEncType = "H.263";

                        break;

                    case 5:

                        videoEncType = "MJPG";

                        break;

                    case 6:

                        videoEncType = "FCC-MPEG4";

                        break;

                    case 7:

                        videoEncType = "标准h264";

                        break;

                    case 8:

                        videoEncType = "标准h265";

                        break;

                    case 9:

                        videoEncType = "SVAC";

                        break;

                    default:

                        videoEncType = "未知";

                        break;

                }

                int nBitRate = cfg_encode_info.stuMainStream[0].stuVideoFormat.nBitRate;

                int nWidth = cfg_encode_info.stuMainStream[0].stuVideoFormat.nWidth;

                int nHeight = cfg_encode_info.stuMainStream[0].stuVideoFormat.nHeight;

                String resolution = nWidth + "*" + nHeight;

                float nFrameRate = cfg_encode_info.stuMainStream[0].stuVideoFormat.nFrameRate;

                map.put("resolution", resolution);//分辨率

                map.put("videoBitrate", String.valueOf(nBitRate));//比特率

                map.put("videoEncType", videoEncType);//编码

                map.put("nFrameRate", String.valueOf(nFrameRate));//帧率

            }

        } catch (Exception ex) {

            log.error("取码流压缩参数异常:" + ex.getMessage());

        }

        return map;

    }



    //获取GIS信息数据

    @Override

    public Map<String, Object> getGisInfo(CameraCmd cmd) {

        Map<String, Object> map = new HashMap<>();

        try {

            String cameraId = cmd.getCameraId();

            Integer chanNo = cmd.getChanNo();

            if (!GlobalVariable.loginMap.containsKey(cameraId)) {

                return null;

            }

            LLong loginId = (LLong) GlobalVariable.loginMap.get(cameraId);

            DH_OUT_PTZ_VIEW_RANGE_STATUS dh_out_ptz_view_range_status = new DH_OUT_PTZ_VIEW_RANGE_STATUS();

            boolean b = ConfigModule.queryDevState(loginId, NET_DEVSTATE_PTZ_VIEW_RANGE, dh_out_ptz_view_range_status);

            if (b) {

                float nAngelH = (float) dh_out_ptz_view_range_status.nAngelH / 10;

                float nAngelV = (float) dh_out_ptz_view_range_status.nAngelV / 10;

                map = getPtz(cmd);//获取ptz

                map.put("fHorFieldAngle", nAngelH);// 水平视场角

                map.put("fVerFieldAngle", nAngelV);// 垂直视场角

            }

        } catch (Exception ex) {

            log.error("获取云台可视域异常" + ex.getMessage());

        }

        return map;

    }



    // 设备断线回调: 当设备出现断线时，SDK会调用该函数

    private static class DisConnect implements NetSDKLib.fDisConnect {

        public void invoke(LLong m_hLoginHandle, String pchDVRIP, int nDVRPort, Pointer dwUser) {

            log.warn("Device[" + pchDVRIP + ":" + nDVRPort + "] DisConnect!");

        }

    }



    // 网络连接恢复回调:设备重连成功回调，当已断线的设备重连成功时，SDK会调用该函数

    private static class HaveReConnect implements NetSDKLib.fHaveReConnect {

        @Override

        public void invoke(LLong lLoginID, String pchDVRIP, int nDVRPort, Pointer dwUser) {

            log.warn("ReConnect Device[" + pchDVRIP + ":" + nDVRPort + "]");

        }

    }



    // 抓图接收回调:当抓图成功，sdk会调用该函数

    public static class fCaptureReceiveCB implements NetSDKLib.fSnapRev {

        private String minioEndPoint;

        private String ObjectName;

        private String bucketName;



        public fCaptureReceiveCB(String minioEndPoint, String bucketName, String ObjectName) {

            this.minioEndPoint = minioEndPoint;

            this.bucketName = bucketName;

            this.ObjectName = ObjectName;

        }



        public void invoke(LLong lLoginID, Pointer pBuf, int RevLen, int EncodeType, int CmdSerial, Pointer dwUser) {

            if (pBuf != null && RevLen > 0) {

                byte[] buf = pBuf.getByteArray(0, RevLen);

                //存储到minio

                InputStream input = new ByteArrayInputStream(buf);



                try {

                    boolean b = MinioUtil.uploadObject(bucketName, ObjectName, input, input.available(), MimeTypeUtils.IMAGE_JPEG);

                    if (b) {

                        String url = minioEndPoint + "/" + bucketName + ObjectName;

                        log.debug("上传文件成功!" + url);

                    }

                } catch (IOException ex) {

                    log.error("上传文件异常：" + ex.getMessage());

                }

            }

        }

    }

package com.ruoyi.utils.sdk.dhsdk.service.impl;

import com.ruoyi.alarm.global.domain.GuidePriorityQueue;
import com.ruoyi.alarm.global.domain.GuideTask;
import com.ruoyi.common.annotation.SdkOperate;
import com.ruoyi.common.utils.file.FileUtils;
import com.ruoyi.common.utils.file.MimeTypeUtils;
import com.ruoyi.common.utils.uuid.IdUtils;
import com.ruoyi.device.camera.strategy.SdkStrategy;
import com.ruoyi.device.camera.domain.ArdCameras;
import com.ruoyi.device.camera.domain.CameraCmd;
import com.ruoyi.device.camera.service.IArdCamerasService;
import com.ruoyi.device.channel.domain.ArdChannel;
import com.ruoyi.device.channel.service.IArdChannelService;
import com.ruoyi.media.domain.Vtdu;
import com.ruoyi.media.service.IVtduService;
import com.ruoyi.utils.gis.GisUtil;
import com.ruoyi.utils.minio.MinioUtil;
import com.ruoyi.utils.sdk.common.GlobalVariable;
import com.ruoyi.utils.sdk.dhsdk.lib.NetSDKLib;
import com.ruoyi.utils.sdk.dhsdk.lib.enumeration.EM_NEW_CONFIG;
import com.ruoyi.utils.sdk.dhsdk.lib.enumeration.NET_EM_CFG_OPERATE_TYPE;
import com.ruoyi.utils.sdk.dhsdk.lib.structure.CFG_VIDEO_IN_FOCUS;
import com.ruoyi.utils.sdk.dhsdk.lib.structure.DH_OUT_PTZ_VIEW_RANGE_STATUS;
import com.ruoyi.utils.sdk.dhsdk.module.*;
import com.sun.jna.Pointer;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.io.*;
import java.text.DecimalFormat;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.PriorityBlockingQueue;

import static com.ruoyi.utils.sdk.dhsdk.lib.NetSDKLib.*;
import static com.ruoyi.utils.sdk.dhsdk.lib.NetSDKLib.NET_DEVSTATE_PTZ_VIEW_RANGE;
import static com.ruoyi.utils.sdk.dhsdk.lib.NetSDKLib.NET_PTZ_ControlType.NET_PTZ_POINT_MOVE_CONTROL;
import static com.ruoyi.utils.sdk.dhsdk.lib.NetSDKLib.NET_PTZ_ControlType.NET_PTZ_POINT_SET_CONTROL;
import static com.ruoyi.utils.sdk.dhsdk.lib.ToolKits.getErrorCodePrint;
import static com.ruoyi.utils.sdk.dhsdk.module.LoginModule.netsdk;

/**
 * @Description: 大华sdk策略
 * @ClassName: DhSdkStrategy
 * @Author: 刘苏义
 * @Date: 2023年11月07日10:51:09
 **/
@Slf4j(topic = "dhSdk")
@Service
public class DhSdkStrategy implements SdkStrategy {

    @Resource
    private IArdCamerasService ardCamerasService;
    @Resource
    private IArdChannelService ardChannelService;
    @Resource
    private IVtduService vtduService;
    @Value("${minio.endpoint}")
    private String minioEndPoint;


    // 设备断线通知回调
    private static DisConnect disConnect = new DisConnect();
    // 网络连接恢复
    private static HaveReConnect haveReConnect = new HaveReConnect();


    /**
     * 登录
     * 刘苏义
     * 2023/10/17 8:28:13
     * @return
     */
    @Override

    public boolean login(ArdCameras camera) {
        LoginModule.init(disConnect, haveReConnect);
        NetSDKLib.NET_DEVICEINFO_Ex m_stDeviceInfo = new NetSDKLib.NET_DEVICEINFO_Ex();
        NetSDKLib.LLong loginId = LoginModule.login(camera.getIp(), camera.getPort(), camera.getUsername(), camera.getPassword(), m_stDeviceInfo);
        if (loginId.longValue() <= 0) {
            camera.setChanNum(0);
            camera.setLoginId(-1);
            camera.setState("0");
            ardCamerasService.updateArdCameras(camera);
            //删除管理通道
            ardChannelService.deleteArdChannelByDeviceId(camera.getId());
            return false;
        }
        if (GlobalVariable.loginMap.containsKey(camera.getId())) {
            GlobalVariable.loginMap.remove(camera.getId());
        }
        //删除管理通道
        ardChannelService.deleteArdChannelByDeviceId(camera.getId());
        camera.setState("1");
        camera.setChanNum(m_stDeviceInfo.byChanNum);
        camera.setStartDChan(1);
        camera.setLoginId((int) loginId.longValue());
        ardCamerasService.updateArdCameras(camera);
        GlobalVariable.loginMap.put(camera.getId(), loginId);

        //获取最新通道
        for (int i = 1; i < m_stDeviceInfo.byChanNum + 1; i++) {
            ArdChannel channel = new ArdChannel();
            NetSDKLib.AV_CFG_ChannelName av_cfg_channelName = new NetSDKLib.AV_CFG_ChannelName();
            boolean b = ConfigModule.GetNewDevConfig(loginId, i - 1, CFG_CMD_CHANNELTITLE, av_cfg_channelName);
            if (b) {
                String chanName = null;
                try {
                    chanName = new String(av_cfg_channelName.szName, "GBK").trim();
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                }
                channel.setName(chanName);
            } else {
                channel.setName("通道" + i);
            }
            channel.setDeviceId(camera.getId());
            channel.setChanNo(i);
            ardChannelService.insertArdChannel(channel);
        }
        //配置到流媒体
        for (int i = 1; i < m_stDeviceInfo.byChanNum + 1; i++) {
            String name = camera.getId() + "_" + i;
            String rtspSource = "rtsp://" + camera.getUsername() + ":" + camera.getPassword() + "@" + camera.getIp() + ":" + camera.getRtspPort() + "/cam/realmonitor?channel=" + i + "&subtype=0";
            Vtdu vtdu = vtduService.selectVtduByName(name);
            if (vtdu != null) {
                vtduService.deleteVtduByName(name);
            }
            //添加到流媒体
            CameraCmd cmd = new CameraCmd(camera.getId(), i);
            Map<String, Object> videoCompressionCfg = getVideoCompressionCfg(cmd);
            vtdu = new Vtdu();
            if (videoCompressionCfg.get("videoEncType") != null) {
                if (videoCompressionCfg.get("videoEncType").equals("标准h264")) {
                    vtdu.setIsCode("0");//默认不转码
                } else {
                    vtdu.setIsCode("1");//默认转码
                }
            } else {
                vtdu.setIsCode("0");//默认不转码
            }
            vtdu.setRtspSource(rtspSource);
            vtdu.setName(camera.getId() + "_" + i);
            vtdu.setMode("1");//默认CPU软解码
            vtdu.setCameraId(camera.getId());
            vtduService.insertVtdu(vtdu);
        }

        //创建引导队列
        if (!GuidePriorityQueue.cameraQueueMap.containsKey(camera.getId())) {
            Comparator<GuideTask> comparator = GuidePriorityQueue.getComparator();
            PriorityBlockingQueue<GuideTask> priorityQueue = new PriorityBlockingQueue<>(1000, comparator);
            GuidePriorityQueue.cameraQueueMap.put(camera.getId(), priorityQueue);
        }
        return true;
    }

    @Override
    @Async("loginExecutor")
    public void asyncLogin(ArdCameras camera){
        LoginModule.init(disConnect, haveReConnect);
        NetSDKLib.NET_DEVICEINFO_Ex m_stDeviceInfo = new NetSDKLib.NET_DEVICEINFO_Ex();
        NetSDKLib.LLong loginId = LoginModule.login(camera.getIp(), camera.getPort(), camera.getUsername(), camera.getPassword(), m_stDeviceInfo);
        if (loginId.longValue() <= 0) {
            camera.setChanNum(0);
            camera.setLoginId(-1);
            camera.setState("0");
            ardCamerasService.updateArdCameras(camera);
            //删除管理通道
            ardChannelService.deleteArdChannelByDeviceId(camera.getId());
            return;
        }
        if (GlobalVariable.loginMap.containsKey(camera.getId())) {
            GlobalVariable.loginMap.remove(camera.getId());
        }
        //删除管理通道
        ardChannelService.deleteArdChannelByDeviceId(camera.getId());
        camera.setState("1");
        camera.setChanNum(m_stDeviceInfo.byChanNum);
        camera.setStartDChan(1);
        camera.setLoginId((int) loginId.longValue());
        ardCamerasService.updateArdCameras(camera);
        GlobalVariable.loginMap.put(camera.getId(), loginId);

        //获取最新通道
        for (int i = 1; i < m_stDeviceInfo.byChanNum + 1; i++) {
            ArdChannel channel = new ArdChannel();
            NetSDKLib.AV_CFG_ChannelName av_cfg_channelName = new NetSDKLib.AV_CFG_ChannelName();
            boolean b = ConfigModule.GetNewDevConfig(loginId, i - 1, CFG_CMD_CHANNELTITLE, av_cfg_channelName);
            if (b) {
                String chanName = null;
                try {
                    chanName = new String(av_cfg_channelName.szName, "GBK").trim();
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                }
                channel.setName(chanName);
            } else {
                channel.setName("通道" + i);
            }
            channel.setDeviceId(camera.getId());
            channel.setChanNo(i);
            ardChannelService.insertArdChannel(channel);
        }
        //配置到流媒体
        for (int i = 1; i < m_stDeviceInfo.byChanNum + 1; i++) {
            String name = camera.getId() + "_" + i;
            String rtspSource = "rtsp://" + camera.getUsername() + ":" + camera.getPassword() + "@" + camera.getIp() + ":" + camera.getRtspPort() + "/cam/realmonitor?channel=" + i + "&subtype=0";
            Vtdu vtdu = vtduService.selectVtduByName(name);
            if (vtdu != null) {
                vtduService.deleteVtduByName(name);
            }
            //添加到流媒体
            CameraCmd cmd = new CameraCmd(camera.getId(), i);
            Map<String, Object> videoCompressionCfg = getVideoCompressionCfg(cmd);
            vtdu = new Vtdu();
            if (videoCompressionCfg.get("videoEncType") != null) {
                if (videoCompressionCfg.get("videoEncType").equals("标准h264")) {
                    vtdu.setIsCode("0");//默认不转码
                } else {
                    vtdu.setIsCode("1");//默认转码
                }
            } else {
                vtdu.setIsCode("0");//默认不转码
            }
            vtdu.setRtspSource(rtspSource);
            vtdu.setName(camera.getId() + "_" + i);
            vtdu.setMode("1");//默认CPU软解码
            vtdu.setCameraId(camera.getId());
            vtduService.insertVtdu(vtdu);
        }

        //创建引导队列
        if (!GuidePriorityQueue.cameraQueueMap.containsKey(camera.getId())) {
            Comparator<GuideTask> comparator = GuidePriorityQueue.getComparator();
            PriorityBlockingQueue<GuideTask> priorityQueue = new PriorityBlockingQueue<>(1000, comparator);
            GuidePriorityQueue.cameraQueueMap.put(camera.getId(), priorityQueue);
        }
    }

    /**
     * 注销
     * 刘苏义
     * 2023/10/17 8:28:13
     * @return
     */
    @Override
    public boolean logout(String cameraId) {
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
            return false;
        }
        NetSDKLib.LLong loginId = (NetSDKLib.LLong) GlobalVariable.loginMap.get(cameraId);
        return LoginModule.logout(loginId);
    }

    /**
     * 是否在线检测
     * 刘苏义
     * 2023/10/17 8:28:13
     */
    @Override
    public boolean isOnLine(CameraCmd cmd) {
        try {
            String cameraId = cmd.getCameraId();
            if (!GlobalVariable.loginMap.containsKey(cameraId)) {
                return false;
            }
            NetSDKLib.LLong loginId = (NetSDKLib.LLong) GlobalVariable.loginMap.get(cameraId);
            NetSDKLib.NET_WORKSTATE dh_ptz_location_info = new NetSDKLib.NET_WORKSTATE();
            boolean b = ConfigModule.queryDevState(loginId, NET_DEVSTATE_ONLINE, dh_ptz_location_info);
            if (!b) {
                return false;
            }
        } catch (Exception ex) {
            log.error("检测在线异常：" + ex.getMessage());
            return false;
        }
        return true;
    }


    /**
     * 云台控制
     * 刘苏义
     * 2023/10/17 8:28:13
     */
    @Override
    public boolean pTZControl(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        boolean enable = cmd.isEnable();
        Integer chanNo = cmd.getChanNo();
        Integer speed = cmd.getSpeed();
        Integer code = cmd.getCode();
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
            return false;
        }
        NetSDKLib.LLong loginId = (NetSDKLib.LLong) GlobalVariable.loginMap.get(cameraId);
        int dwStop;
        if (enable) {
            dwStop = 0;//开启
        } else {
            dwStop = 1;//关闭
        }
        int dwPTZCommand = -1;
        switch (code) {
            /*方向*/
            case 1:
                dwPTZCommand = NetSDKLib.NET_EXTPTZ_ControlType.NET_EXTPTZ_LEFTTOP;
                break;
            case 2:
                dwPTZCommand = NetSDKLib.NET_PTZ_ControlType.NET_PTZ_UP_CONTROL;
                break;
            case 3:
                dwPTZCommand = NetSDKLib.NET_EXTPTZ_ControlType.NET_EXTPTZ_RIGHTTOP;
                break;
            case 4:
                dwPTZCommand = NetSDKLib.NET_PTZ_ControlType.NET_PTZ_LEFT_CONTROL;
                break;
            case 5:
                dwPTZCommand = NetSDKLib.NET_PTZ_ControlType.NET_PTZ_POINT_LOOP_CONTROL;
                break;
            case 6:
                dwPTZCommand = NetSDKLib.NET_PTZ_ControlType.NET_PTZ_RIGHT_CONTROL;
                break;
            case 7:
                dwPTZCommand = NetSDKLib.NET_EXTPTZ_ControlType.NET_EXTPTZ_LEFTDOWN;
                break;
            case 8:
                dwPTZCommand = NetSDKLib.NET_PTZ_ControlType.NET_PTZ_DOWN_CONTROL;
                break;
            case 9:
                dwPTZCommand = NetSDKLib.NET_EXTPTZ_ControlType.NET_EXTPTZ_RIGHTDOWN;
                break;
            /*焦距*/
            case 10:
                dwPTZCommand = NetSDKLib.NET_PTZ_ControlType.NET_PTZ_ZOOM_ADD_CONTROL;
                break;
            case 11:
                dwPTZCommand = NetSDKLib.NET_PTZ_ControlType.NET_PTZ_ZOOM_DEC_CONTROL;
                break;
            /*焦点*/
            case 12:
                dwPTZCommand = NetSDKLib.NET_PTZ_ControlType.NET_PTZ_FOCUS_ADD_CONTROL;
                break;
            case 13:
                dwPTZCommand = NetSDKLib.NET_PTZ_ControlType.NET_PTZ_FOCUS_DEC_CONTROL;
                break;
            /*光圈*/
            case 14:
                dwPTZCommand = NetSDKLib.NET_PTZ_ControlType.NET_PTZ_APERTURE_ADD_CONTROL;
                break;
            case 15:
                dwPTZCommand = NetSDKLib.NET_PTZ_ControlType.NET_PTZ_APERTURE_DEC_CONTROL;
                break;
            case 16:
                dwPTZCommand = NetSDKLib.NET_PTZ_ControlType.NET_PTZ_LAMP_CONTROL;
                break;
        }
        boolean bool = PtzControlModule.ptzControl(loginId, chanNo - 1, dwPTZCommand, speed, speed, 0, dwStop);
        if (!bool) {
            log.error("控制失败,请稍后重试" + getErrorCodePrint());
        }
        return bool;
    }

    /**
     * 获取PTZ值
     * 刘苏义
     * 2023/10/17 8:28:13
     */
    @Override
    public Map<String, Object> getPtz(CameraCmd cmd) {
        Map<String, Object> ptzMap = new HashMap<>();
        String cameraId = cmd.getCameraId();
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
            return null;
        }
        NetSDKLib.LLong loginId = (NetSDKLib.LLong) GlobalVariable.loginMap.get(cameraId);
        NetSDKLib.NET_PTZ_LOCATION_INFO dh_ptz_location_info = new NetSDKLib.NET_PTZ_LOCATION_INFO();
        boolean b = ConfigModule.queryDevState(loginId, NET_DEVSTATE_PTZ_LOCATION, dh_ptz_location_info);
        if (b) {
            DecimalFormat df = new DecimalFormat("0.0");//设置保留位数
            String nPTZPan = df.format((float) dh_ptz_location_info.nPTZPan / 10);
            float t = (float) dh_ptz_location_info.nPTZTilt / 10 * -1;
            String nPTZTilt = df.format(t < 0 ? t + 360 : t);
            String nPTZZoom = df.format((float) dh_ptz_location_info.nPTZZoom);
            ptzMap.put("p", nPTZPan);
            ptzMap.put("t", nPTZTilt);
            ptzMap.put("z", nPTZZoom);
        }
        return ptzMap;
    }

    @Override
    public Map<String, Object> getPtzScope(CameraCmd cmd) {
        return null;
    }

    /**
     * @描述 设置ptz信息
     * @参数 [userId, channelNum]
     * @返回值 boolean
     * @创建人 刘苏义
     * @创建时间 2023/1/17 16:36
     * @修改人和其它信息 注意俯仰角度负值需要加上360得到的正值进行设置
     */
    @Override
    public boolean setPtz(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        Integer chanNo = cmd.getChanNo();
        Map<String, Double> ptz = cmd.getPtzMap();
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
            return false;
        }
        LLong loginId = (LLong) GlobalVariable.loginMap.get(cameraId);
        try {
            int p = (int) (ptz.get("p") * 10);
            int t = (int) (ptz.get("t") * 10);
            t = t > 900 ? 3600 - t : t * -1;

            int z = ptz.get("z").intValue() == 0 ? 1 : ptz.get("z").intValue();
            boolean bool = netsdk.CLIENT_DHPTZControlEx(loginId, chanNo - 1, NetSDKLib.NET_EXTPTZ_ControlType.NET_EXTPTZ_EXACTGOTO, p, t, z, 0);
            if (!bool) {
                log.error("控制失败,请稍后重试" + getErrorCodePrint());
            }
            return bool;
        } catch (Exception ex) {
            log.error(ex.getMessage());
            return false;
        }
    }

    /**
     * @描述 设置零方位角
     * @参数 [userId, channelNum]
     * @返回值 boolean
     * @创建人 刘苏义
     * @创建时间 2023/1/17 16:36
     * @修改人和其它信息 注意俯仰角度负值需要加上360得到的正值进行设置
     */
    @Override
    public boolean setZeroPtz(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        Integer chanNo = cmd.getChanNo();
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
            return false;
        }
        LLong loginId = (LLong) GlobalVariable.loginMap.get(cameraId);
        boolean bool = NetSDKLib.NETSDK_INSTANCE.CLIENT_DHPTZControlEx(loginId, chanNo - 1, NetSDKLib.NET_EXTPTZ_ControlType.NET_EXTPTZ_RESETZERO, 0, 0, 0, 0);
        if (!bool) {
            log.error("控制失败,请稍后重试" + getErrorCodePrint());
        }
        return bool;
    }

    /**
     * @描述 截图 存服务器
     * @参数 [cameraId, channelNum]
     * @返回值 java.lang.String
     * @创建人 刘苏义
     * @创建时间 2023/2/2 14:59
     * @修改人和其它信息
     */
    @Override
    public String picCutCate(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        Integer chanNo = cmd.getChanNo();
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
            return "";
        }
        LLong loginId = (LLong) GlobalVariable.loginMap.get(cameraId);
        String bucketName = "pic";
        String picUrl = "";
        String bucketObject = "/capture/" + IdUtils.simpleUUID() + ".jpeg";
        fCaptureReceiveCB m_CaptureReceiveCB = new fCaptureReceiveCB(minioEndPoint, bucketName, bucketObject);
        CapturePictureModule.setSnapRevCallBack(m_CaptureReceiveCB);
        boolean b = CapturePictureModule.remoteCapturePicture(loginId, chanNo - 1);
        if (b) {
            picUrl = minioEndPoint + "/" + bucketName + bucketObject;
        }
        return picUrl;

    }

    /**
     * @描述 短时录像
     * @参数 [userId, channelNum, enable]
     * @返回值 void
     * @创建人 刘苏义
     * @创建时间 2023/1/20 11:18
     * @修改人和其它信息
     */
    @Override
    public String record(CameraCmd cmd) {
        try {
            String url = "";
            String cameraId = cmd.getCameraId();
            Integer chanNo = cmd.getChanNo();
            String path = FileUtils.createFile("D:/recordTemp/" + cameraId + ".mp4");
            boolean enable = cmd.isEnable();
            if (!GlobalVariable.loginMap.containsKey(cameraId)) {
                return "";
            }
            LLong loginId = (LLong) GlobalVariable.loginMap.get(cameraId);

            if (enable) {
                LLong lRealHandle = new LLong(0);
                if (!GlobalVariable.previewMap.containsKey(cameraId)) {
                    lRealHandle = RealPlayModule.startRealPlay(loginId, chanNo - 1, path);
                    if (lRealHandle.longValue() <= 0) {
                        log.error("取流失败" + getErrorCodePrint());
                        return "";
                    }
                    log.debug("取流成功");
                    GlobalVariable.previewMap.put(cameraId, lRealHandle.intValue());
                }
                log.debug("录像开始");
            } else {
                if (GlobalVariable.previewMap.containsKey(cameraId)) {
                    LLong lRealHandle = new LLong(GlobalVariable.previewMap.get(cameraId));
                    RealPlayModule.stopRealPlay(lRealHandle);
                    GlobalVariable.previewMap.remove(cameraId);
                }
                log.debug("录像停止");
            }
            return url;
        } catch (Exception ex) {
            log.error("录像异常" + ex.getMessage());
            return "";
        }
    }

    @Override
    public boolean recordStart(CameraCmd cmd) {
        try {
            String cameraId = cmd.getCameraId();
            Integer chanNo = cmd.getChanNo();
            String path = FileUtils.createFile("D:/recordTemp/" + cameraId + ".mp4");
            if (!GlobalVariable.loginMap.containsKey(cameraId)) {
                return false;
            }
            LLong loginId = (LLong) GlobalVariable.loginMap.get(cameraId);
            LLong lRealHandle;
            if (GlobalVariable.previewMap.containsKey(cameraId)) {
                lRealHandle = new LLong(GlobalVariable.previewMap.get(cameraId));
                RealPlayModule.stopRealPlay(lRealHandle);
                GlobalVariable.previewMap.remove(cameraId);
                log.debug("停止当前录像");
            }
            lRealHandle = RealPlayModule.startRealPlay(loginId, chanNo - 1, path);
            if (lRealHandle.longValue() <= 0) {
                log.error("取流失败" + getErrorCodePrint());
            }
            log.debug("取流成功");
            GlobalVariable.previewMap.put(cameraId, lRealHandle.intValue());
            GlobalVariable.threadMap.put(cameraId, Thread.currentThread().getName());
            //if (!netsdk.CLIENT_SaveRealData(lRealHandle, path)) {
            //    log.error("保存视频文件到临时文件夹失败 错误码为:  " +getErrorCodePrint());
            //    return false;
            //}
            log.debug("录像开始");
            return true;
        } catch (Exception ex) {
            log.error("开始录像异常" + ex.getMessage());
            return false;
        }
    }

    @Override
    public String recordStopToMinio(CameraCmd cmd) {
        String url = "";
        try {
            String cameraId = cmd.getCameraId();
            String path = FileUtils.createFile("D:/recordTemp/" + cameraId + ".mp4");
            if (!GlobalVariable.loginMap.containsKey(cameraId)) {
                return "";
            }
            LLong lRealHandle;
            if (GlobalVariable.previewMap.containsKey(cameraId)) {
                lRealHandle = new LLong(GlobalVariable.previewMap.get(cameraId));
                RealPlayModule.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 boolean recordStopNotToMinio(CameraCmd cmd) {
        boolean result = false;
        try {
            String cameraId = cmd.getCameraId();
            if (!GlobalVariable.loginMap.containsKey(cameraId)) {
                return false;
            }
            LLong lRealHandle;
            if (GlobalVariable.previewMap.containsKey(cameraId)) {
                lRealHandle = new LLong(GlobalVariable.previewMap.get(cameraId));
                RealPlayModule.stopRealPlay(lRealHandle);
                GlobalVariable.previewMap.remove(cameraId);
                log.debug("停止当前录像");
            }

            result = true;
        } catch (Exception ex) {
            log.error("录像异常" + ex.getMessage());
        }
        return result;
    }

    @Override
    public List<ArdChannel> getCameraChannelList(ArdCameras camera) {
        return null;
    }

    /**
     * 引导目标位置
     * 刘苏义
     * 2023/10/17 8:27:48
     */
    @Override
    public boolean guideTargetPosition(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        Integer chanNo = cmd.getChanNo();
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
            return false;
        }
        LLong loginId = (LLong) GlobalVariable.loginMap.get(cameraId);
        try {
            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);
            int p = (int) (cameraPTZ[0] * 10);
            int t = (int) (cameraPTZ[1] * 10);
            int z = (int) (cameraPTZ[2]);
            boolean bool = netsdk.CLIENT_DHPTZControlEx(loginId, chanNo - 1, NetSDKLib.NET_EXTPTZ_ControlType.NET_EXTPTZ_EXACTGOTO, p, t, z, 0);
            if (!bool) {
                log.error("控制失败,请稍后重试" + getErrorCodePrint());
            }
            return bool;
        } catch (Exception ex) {
            log.error("引导异常:" + ex.getMessage());
            return false;
        }
    }

    //转至预置点
    @Override
    public boolean gotoPreset(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        Integer chanNo = cmd.getChanNo();
        Integer PresetIndex = cmd.getPresetIndex();
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
            return false;
        }
        LLong loginId = (LLong) GlobalVariable.loginMap.get(cameraId);
        try {

            boolean bool = netsdk.CLIENT_DHPTZControlEx(loginId, chanNo - 1, NET_PTZ_POINT_MOVE_CONTROL, 0, PresetIndex, 0, 0);
            if (!bool) {
                log.error("控制失败,请稍后重试" + getErrorCodePrint());
            }
            return bool;
        } catch (Exception ex) {
            log.error("转至预置点异常:" + ex.getMessage());
            return false;
        }
    }

    @Override
    //设置预置位
    public boolean setPreset(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        Integer chanNo = cmd.getChanNo();
        Integer PresetIndex = cmd.getPresetIndex();
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
            return false;
        }
        LLong loginId = (LLong) GlobalVariable.loginMap.get(cameraId);
        try {

            boolean bool = netsdk.CLIENT_DHPTZControlEx(loginId, chanNo - 1, NET_PTZ_POINT_SET_CONTROL, 0, PresetIndex, 0, 0);
            if (!bool) {
                log.error("控制失败,请稍后重试" + getErrorCodePrint());
            }
            return bool;
        } catch (Exception ex) {
            log.error("设置预置点异常:" + ex.getMessage());
            return false;
        }
    }

    //切换聚焦模式
    @Override
    public boolean controlFocusMode(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        Integer chanNo = cmd.getChanNo();
        boolean enable = cmd.isEnable();
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
            return false;
        }
        LLong loginId = (LLong) GlobalVariable.loginMap.get(cameraId);
        try {
            CFG_VIDEO_IN_FOCUS cfg_video_in_focus = new CFG_VIDEO_IN_FOCUS();
            cfg_video_in_focus.nVideoInFocusRealNum = 3;//配置使用个数
            for (int i = 0; i < 3; i++) {
                cfg_video_in_focus.stVideoInFocusUnit[i].nSensitivity = 1;//聚焦灵敏度, 0-高, 1-默认, 2-低

                cfg_video_in_focus.stVideoInFocusUnit[i].nIRCorrection = 2;//红外光聚焦修正, 0-不修正, 1-修正, 2-自动修正
                cfg_video_in_focus.stVideoInFocusUnit[i].nFocusLimit = 10000;//聚焦极限值, 单位毫米
                if (enable) {//聚焦模式, 0-关闭, 1-辅助聚焦, 2-自动聚焦, 3-半自动聚焦, 4-手动聚焦
                    cfg_video_in_focus.stVideoInFocusUnit[i].nMode = 4;//手动聚焦
                    cfg_video_in_focus.stVideoInFocusUnit[i].emFocusMode = 0;//聚焦极限Manual
                    log.debug("当前为手动聚焦模式");
                } else {
                    cfg_video_in_focus.stVideoInFocusUnit[i].nMode = 2;//自动聚焦
                    cfg_video_in_focus.stVideoInFocusUnit[i].emFocusMode = 1;//聚焦极限Auto
                    log.debug("当前为自动聚焦模式");
                }
            }
            cfg_video_in_focus.nChannelIndex = chanNo - 1;
            boolean bool = ConfigModule.SetDevConfig(loginId, chanNo - 1, NetSDKLib.CFG_CMD_VIDEOIN_FOCUS, cfg_video_in_focus);
            if (!bool) {
                log.error("控制失败,请稍后重试" + getErrorCodePrint());
            }
            return bool;
        } catch (Exception ex) {
            log.error("切换聚焦模式异常:" + ex.getMessage());
            return false;
        }
    }

    @Override
    public String getFocusMode(CameraCmd cmd) {
        String mode = "";
        String cameraId = cmd.getCameraId();
        Integer chanNo = cmd.getChanNo();
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
            return "";
        }
        LLong loginId = (LLong) GlobalVariable.loginMap.get(cameraId);
        try {
            NET_VIDEOIN_FOCUSMODE_INFO focusModeInfo = new NET_VIDEOIN_FOCUSMODE_INFO();
            int emCfgOpType = NET_EM_CFG_OPERATE_TYPE.NET_EM_CFG_VIDEOIN_FOCUSMODE;
            boolean bool = ConfigModule.GetConfig(loginId, chanNo - 1, emCfgOpType, focusModeInfo);
            if (!bool) {
                log.error("获取失败,请稍后重试" + getErrorCodePrint());
            }
            System.out.println("配置类型:" + focusModeInfo.emCfgType);     // 具体信息，参考库里的枚举
            System.out.println("聚焦模式:" + focusModeInfo.emFocusMode);
            switch (focusModeInfo.emFocusMode) {
                case 0:
                    mode = "关闭";
                    break;
                case 1:
                    mode = "辅助聚焦";
                    break;
                case 2:
                    mode = "自动聚焦";
                    break;
                case 3:
                    mode = "半自动聚焦";
                    break;
                case 4:
                    mode = "手动聚焦";
                    break;
            }

        } catch (Exception ex) {
            log.error("获取聚焦模式异常:" + ex.getMessage());

        }
        return mode;
    }

    @Override
    public boolean controlPTHeateRpwron(CameraCmd cmd) {
        return false;
    }

    @Override
    public boolean controlCameraDeicing(CameraCmd cmd) {
        return false;
    }

    @Override
    public int getPTZLockInfo(CameraCmd cmd) {
        return 0;
    }

    @Override
    public String captureJPEGPicture(CameraCmd cmd) {
        return null;
    }

    //透雾
    @Override
    public boolean controlDefogcfg(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        Integer chanNo = cmd.getChanNo();
        boolean enable = cmd.isEnable();
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
            return false;
        }
        LLong loginId = (LLong) GlobalVariable.loginMap.get(cameraId);
        try {
            String command = EM_NEW_CONFIG.CFG_CMD_VIDEOINDEFOG.getValue();
            //CFG_VIDEOINDEFOG_LIST cfg_videoindefog_list=new CFG_VIDEOINDEFOG_LIST();
            boolean bool = ConfigModule.SetDevConfig(loginId, chanNo - 1, command, null);
            if (!bool) {
                log.error("控制失败,请稍后重试" + getErrorCodePrint());
            }
            return bool;
        } catch (Exception ex) {
            log.error("切换透雾异常:" + ex.getMessage());
            return false;
        }
    }

    //红外
    @Override
    public boolean controlInfrarecfg(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        Integer chanNo = cmd.getChanNo();
        boolean enable = cmd.isEnable();
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
            return false;
        }
        LLong loginId = (LLong) GlobalVariable.loginMap.get(cameraId);
        try {
            CFG_LIGHTING_INFO cfg_lighting_info = new CFG_LIGHTING_INFO();
            cfg_lighting_info.nLightingDetailNum = 1;
            if (enable) {
                cfg_lighting_info.stuLightingDetail[0].emMode = EM_CFG_LIGHTING_MODE.EM_CFG_LIGHTING_MODE_MANUAL;
            } else {
                cfg_lighting_info.stuLightingDetail[0].emMode = EM_CFG_LIGHTING_MODE.EM_CFG_LIGHTING_MODE_OFF;
            }
            boolean bool = ConfigModule.SetDevConfig(loginId, chanNo - 1, CFG_CMD_LIGHTING, cfg_lighting_info);
            if (!bool) {
                log.error("控制失败,请稍后重试" + getErrorCodePrint());
            }
            return bool;
        } catch (Exception ex) {
            log.error("切换红外异常:" + ex.getMessage());
            return false;
        }
    }

    //获取聚焦值
    @Override
    public int getFocusPos(CameraCmd cmd) {
        int result = 0;
        try {
            String cameraId = cmd.getCameraId();
            Integer chanNo = cmd.getChanNo();
            if (!GlobalVariable.loginMap.containsKey(cameraId)) {
                return result;
            }
            LLong loginId = (LLong) GlobalVariable.loginMap.get(cameraId);
            NET_PTZ_LOCATION_INFO net_ptz_location_info = new NET_PTZ_LOCATION_INFO();
            net_ptz_location_info.nChannelID = chanNo - 1;
            boolean bool = ConfigModule.queryDevState(loginId, NET_DEVSTATE_PTZ_LOCATION, net_ptz_location_info);
            if (!bool) {
                log.error("控制失败,请稍后重试" + getErrorCodePrint());
            }
            result = net_ptz_location_info.nFocusMapValue;
        } catch (Exception ex) {
            log.error("获取聚焦值异常:" + ex.getMessage());
        }
        return result;
    }

    //设置聚焦值
    @Override
    public boolean setFocusPos(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        Integer chanNo = cmd.getChanNo();
        boolean enable = cmd.isEnable();
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
            return false;
        }
        LLong loginId = (LLong) GlobalVariable.loginMap.get(cameraId);
        try {
            CFG_LIGHTING_INFO cfg_lighting_info = new CFG_LIGHTING_INFO();
            cfg_lighting_info.nLightingDetailNum = 1;
            if (enable) {
                cfg_lighting_info.stuLightingDetail[0].emMode = EM_CFG_LIGHTING_MODE.EM_CFG_LIGHTING_MODE_MANUAL;
            } else {
                cfg_lighting_info.stuLightingDetail[0].emMode = EM_CFG_LIGHTING_MODE.EM_CFG_LIGHTING_MODE_OFF;
            }
            boolean bool = ConfigModule.SetDevConfig(loginId, chanNo - 1, CFG_CMD_LIGHTING, cfg_lighting_info);
            if (!bool) {
                log.error("控制失败,请稍后重试" + getErrorCodePrint());
            }
            return bool;
        } catch (Exception ex) {
            log.error("设置聚焦值异常:" + ex.getMessage());
            return false;
        }
    }

    //获取码流压缩参数
    @Override
    public Map<String, Object> getVideoCompressionCfg(CameraCmd cmd) {
        Map<String, Object> map = new HashMap<>();
        try {
            String cameraId = cmd.getCameraId();
            Integer chanNo = cmd.getChanNo();
            if (!GlobalVariable.loginMap.containsKey(cameraId)) {
                return null;
            }
            LLong loginId = (LLong) GlobalVariable.loginMap.get(cameraId);
            CFG_ENCODE_INFO cfg_encode_info = new CFG_ENCODE_INFO();
            cfg_encode_info.nChannelID = chanNo - 1;
            boolean b = ConfigModule.GetNewDevConfig(loginId, chanNo - 1, CFG_CMD_ENCODE, cfg_encode_info);
            if (b) {
                int emCompression = cfg_encode_info.stuMainStream[0].stuVideoFormat.emCompression;//视频格式
                String videoEncType = "";
                switch (emCompression) {
                    case 0:
                        videoEncType = "MPEG4";
                        break;
                    case 1:
                        videoEncType = "MS-MPEG4";
                        break;
                    case 2:
                        videoEncType = "MPEG2";
                        break;
                    case 3:
                        videoEncType = "MPEG1";
                        break;
                    case 4:
                        videoEncType = "H.263";
                        break;
                    case 5:
                        videoEncType = "MJPG";
                        break;
                    case 6:
                        videoEncType = "FCC-MPEG4";
                        break;
                    case 7:
                        videoEncType = "标准h264";
                        break;
                    case 8:
                        videoEncType = "标准h265";
                        break;
                    case 9:
                        videoEncType = "SVAC";
                        break;
                    default:
                        videoEncType = "未知";
                        break;
                }
                int nBitRate = cfg_encode_info.stuMainStream[0].stuVideoFormat.nBitRate;
                int nWidth = cfg_encode_info.stuMainStream[0].stuVideoFormat.nWidth;
                int nHeight = cfg_encode_info.stuMainStream[0].stuVideoFormat.nHeight;
                String resolution = nWidth + "*" + nHeight;
                float nFrameRate = cfg_encode_info.stuMainStream[0].stuVideoFormat.nFrameRate;
                map.put("resolution", resolution);//分辨率
                map.put("videoBitrate", String.valueOf(nBitRate));//比特率
                map.put("videoEncType", videoEncType);//编码
                map.put("nFrameRate", String.valueOf(nFrameRate));//帧率
            }
        } catch (Exception ex) {
            log.error("取码流压缩参数异常:" + ex.getMessage());
        }
        return map;
    }

    //获取GIS信息数据
    @Override
    public Map<String, Object> getGisInfo(CameraCmd cmd) {
        Map<String, Object> map = new HashMap<>();
        try {
            String cameraId = cmd.getCameraId();
            Integer chanNo = cmd.getChanNo();
            if (!GlobalVariable.loginMap.containsKey(cameraId)) {
                return null;
            }
            LLong loginId = (LLong) GlobalVariable.loginMap.get(cameraId);
            DH_OUT_PTZ_VIEW_RANGE_STATUS dh_out_ptz_view_range_status = new DH_OUT_PTZ_VIEW_RANGE_STATUS();
            boolean b = ConfigModule.queryDevState(loginId, NET_DEVSTATE_PTZ_VIEW_RANGE, dh_out_ptz_view_range_status);
            if (b) {
                float nAngelH = (float) dh_out_ptz_view_range_status.nAngelH / 10;
                float nAngelV = (float) dh_out_ptz_view_range_status.nAngelV / 10;
                map = getPtz(cmd);//获取ptz
                map.put("fHorFieldAngle", nAngelH);// 水平视场角
                map.put("fVerFieldAngle", nAngelV);// 垂直视场角
            }
        } catch (Exception ex) {
            log.error("获取云台可视域异常" + ex.getMessage());
        }
        return map;
    }

    // 设备断线回调: 当设备出现断线时，SDK会调用该函数
    private static class DisConnect implements NetSDKLib.fDisConnect {
        public void invoke(LLong m_hLoginHandle, String pchDVRIP, int nDVRPort, Pointer dwUser) {
            log.warn("Device[" + pchDVRIP + ":" + nDVRPort + "] DisConnect!");
        }
    }

    // 网络连接恢复回调:设备重连成功回调，当已断线的设备重连成功时，SDK会调用该函数
    private static class HaveReConnect implements NetSDKLib.fHaveReConnect {
        @Override
        public void invoke(LLong lLoginID, String pchDVRIP, int nDVRPort, Pointer dwUser) {
            log.warn("ReConnect Device[" + pchDVRIP + ":" + nDVRPort + "]");
        }
    }

    // 抓图接收回调:当抓图成功，sdk会调用该函数
    public static class fCaptureReceiveCB implements NetSDKLib.fSnapRev {
        private String minioEndPoint;
        private String ObjectName;
        private String bucketName;

        public fCaptureReceiveCB(String minioEndPoint, String bucketName, String ObjectName) {
            this.minioEndPoint = minioEndPoint;
            this.bucketName = bucketName;
            this.ObjectName = ObjectName;
        }

        public void invoke(LLong lLoginID, Pointer pBuf, int RevLen, int EncodeType, int CmdSerial, Pointer dwUser) {
            if (pBuf != null && RevLen > 0) {
                byte[] buf = pBuf.getByteArray(0, RevLen);
                //存储到minio
                InputStream input = new ByteArrayInputStream(buf);

                try {
                    boolean b = MinioUtil.uploadObject(bucketName, ObjectName, input, input.available(), MimeTypeUtils.IMAGE_JPEG);
                    if (b) {
                        String url = minioEndPoint + "/" + bucketName + ObjectName;
                        log.debug("上传文件成功!" + url);
                    }
                } catch (IOException ex) {
                    log.error("上传文件异常：" + ex.getMessage());
                }
            }
        }
    }

}

 ard-work/src/main/java/com/ruoyi/utils/sdk/hiksdk/controller/HikSdkController.java

@@ -8,9 +8,9 @@
import com.ruoyi.device.camera.domain.ArdCameras;

import com.ruoyi.device.camera.domain.CameraCmd;

import com.ruoyi.device.camera.service.IArdCamerasService;

import com.ruoyi.utils.sdk.hiksdk.service.IHikClientService;

import com.ruoyi.common.annotation.Anonymous;

import com.ruoyi.common.core.domain.AjaxResult;

import com.ruoyi.utils.sdk.hiksdk.service.impl.HikSdkStrategy;

import io.swagger.annotations.Api;

import io.swagger.annotations.ApiOperation;

import org.springframework.stereotype.Controller;

@@ -35,7 +35,7 @@
public class HikSdkController extends BaseController {



    @Resource

    private IHikClientService sdk;

    private HikSdkStrategy sdk;

    @Resource

    private IArdCamerasService ardCamerasService;



@@ -85,7 +85,7 @@
    public @ResponseBody

    AjaxResult PTZControlWithSpeed(@RequestBody CameraCmd cmd) {

        cmd.setOperator(SecurityUtils.getUserId());

        return toAjax(sdk.pTZControlWithSpeed(cmd));

        return toAjax(sdk.pTZControl(cmd));

    }



    @ApiOperation("调用预置点")


 ard-work/src/main/java/com/ruoyi/utils/sdk/hiksdk/lib/LoginResultCallBack.java

@@ -9,12 +9,11 @@
import com.ruoyi.device.channel.domain.ArdChannel;

import com.ruoyi.device.channel.service.IArdChannelService;

import com.ruoyi.utils.sdk.common.GlobalVariable;

import com.ruoyi.utils.sdk.hiksdk.service.IHikClientService;

import com.ruoyi.media.domain.Vtdu;

import com.ruoyi.media.service.IVtduService;

import com.ruoyi.utils.sdk.hiksdk.service.impl.HikSdkStrategy;

import com.sun.jna.Pointer;

import lombok.extern.slf4j.Slf4j;



import java.util.Comparator;

import java.util.List;

import java.util.concurrent.PriorityBlockingQueue;

@@ -39,7 +38,7 @@
    public int invoke(int lUserID, int dwResult, HCNetSDK.NET_DVR_DEVICEINFO_V30 lpDeviceinfo, Pointer pUser) {

        IVtduService vtduService = SpringUtils.getBean(IVtduService.class);

        IArdChannelService ardChannelService = SpringUtils.getBean(IArdChannelService.class);

        IHikClientService hikClientService = SpringUtils.getBean(IHikClientService.class);

        HikSdkStrategy hikClientService = SpringUtils.getBean(HikSdkStrategy.class);

        IArdCamerasService ardCamerasService = SpringUtils.getBean(IArdCamerasService.class);

        if (GlobalVariable.loginMap.containsKey(camera.getId())) {

            GlobalVariable.loginMap.remove(camera.getId());


 ard-work/src/main/java/com/ruoyi/utils/sdk/hiksdk/service/impl/HikSdkStrategy.java

文件名从 ard-work/src/main/java/com/ruoyi/utils/sdk/hiksdk/service/impl/HikClientServiceImpl.java 修改
@@ -1,1693 +1,1764 @@
package com.ruoyi.utils.sdk.hiksdk.service.impl;



import com.ruoyi.alarm.global.domain.GuidePriorityQueue;

import com.ruoyi.alarm.global.domain.GuideTask;

import com.ruoyi.common.annotation.SdkOperate;

import com.ruoyi.common.utils.file.FileUtils;

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.service.IArdCamerasService;

import com.ruoyi.device.channel.domain.ArdChannel;

import com.ruoyi.device.channel.service.IArdChannelService;

import com.ruoyi.utils.sdk.common.GlobalVariable;

import com.ruoyi.device.camera.domain.ArdCameras;

import com.ruoyi.utils.sdk.hiksdk.lib.ExceptionCallBack;

import com.ruoyi.media.domain.Vtdu;

import com.ruoyi.media.service.IVtduService;

import com.ruoyi.utils.gis.GisUtil;

import com.ruoyi.utils.sdk.hiksdk.lib.HCNetSDK;

import com.ruoyi.utils.sdk.hiksdk.service.IHikClientService;

import com.ruoyi.utils.sdk.hiksdk.lib.LoginResultCallBack;

import com.ruoyi.utils.minio.MinioUtil;

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.stereotype.Service;



import java.util.Base64;

import javax.annotation.Resource;

import java.io.*;

import java.math.BigDecimal;

import java.nio.ByteBuffer;

import java.text.DecimalFormat;

import java.util.*;

import java.util.concurrent.PriorityBlockingQueue;



import static com.ruoyi.utils.sdk.hiksdk.lib.HCNetSDK.*;



/**

 * @ClassName: hikClientServiceImpl

 * @Description: 海康操作客户端实现类

 * @Author: Administrator

 * @Date: 2023年01月17日 11:25

 * @Version: 1.2

 **/

@Slf4j(topic = "hikSdk")

@Service

public class HikClientServiceImpl implements IHikClientService {



    @Resource

    private IArdCamerasService ardCamerasService;

    @Resource

    private IArdChannelService ardChannelService;

    @Resource

    private IVtduService vtduService;

    private final Object lock = new Object();

    public static HCNetSDK hCNetSDK = HCNetSDK.hCNetSDK;

    private static FExceptionCallBack fExceptionCallBack;//异常回调





    /**

     * @描述 注册登录 只支持同步登陆，且官方不建议直接在此接口下写耗时操作

     * @参数 [dvrLogin]

     * @返回值 java.lang.Integer

     * @创建人 刘苏义

     * @创建时间 2023/1/17 16:12

     * @修改人和其它信息

     */

    @Override

    public void login(ArdCameras camera) {

        try {

            // 初始化

            if (!hCNetSDK.NET_DVR_Init()) {

                log.error("SDK初始化失败");

            }

            //打印海康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 {

                hCNetSDK.NET_DVR_SetLogToFile(3, "/home/ardLog/hiklog", true);

            }

            String m_sDeviceIP = camera.getIp();

            String m_sUsername = camera.getUsername();

            String m_sPassword = camera.getPassword();

            short m_sPort = camera.getPort().shortValue();

            //设置连接时间与重连时间

            hCNetSDK.NET_DVR_SetConnectTime(2000, 1);

            hCNetSDK.NET_DVR_SetReconnect(5000, true);

            //设备信息, 输出参数

            HCNetSDK.NET_DVR_DEVICEINFO_V40 m_strDeviceInfo = new HCNetSDK.NET_DVR_DEVICEINFO_V40();

            HCNetSDK.NET_DVR_USER_LOGIN_INFO m_strLoginInfo = new HCNetSDK.NET_DVR_USER_LOGIN_INFO();



            // 注册设备-登录参数，包括设备地址、登录用户、密码等

            m_strLoginInfo.sDeviceAddress = new byte[HCNetSDK.NET_DVR_DEV_ADDRESS_MAX_LEN];

            System.arraycopy(m_sDeviceIP.getBytes(), 0, m_strLoginInfo.sDeviceAddress, 0, m_sDeviceIP.length());

            m_strLoginInfo.sUserName = new byte[HCNetSDK.NET_DVR_LOGIN_USERNAME_MAX_LEN];

            System.arraycopy(m_sUsername.getBytes(), 0, m_strLoginInfo.sUserName, 0, m_sUsername.length());

            m_strLoginInfo.sPassword = new byte[HCNetSDK.NET_DVR_LOGIN_PASSWD_MAX_LEN];

            System.arraycopy(m_sPassword.getBytes(), 0, m_strLoginInfo.sPassword, 0, m_sPassword.length());

            m_strLoginInfo.wPort = m_sPort;

            m_strLoginInfo.byVerifyMode = 0;

            m_strLoginInfo.byLoginMode = 0;

            //是否异步登录：0- 否，1- 是  windowsSDK里是true和false

            m_strLoginInfo.bUseAsynLogin = false;

            m_strLoginInfo.write();

            //同步登录

            int lUserID = hCNetSDK.NET_DVR_Login_V40(m_strLoginInfo, m_strDeviceInfo);

            if (lUserID < 0) {

                log.debug("Login Failed [ " + camera.getIp() + ":" + camera.getPort() + " ],错误码：" + hCNetSDK.NET_DVR_GetLastError());

                camera.setChanNum(0);

                camera.setLoginId(-1);

                camera.setState("0");

                return;

            }



            log.debug("Login Success [ " + camera.getIp() + ":" + camera.getPort() + " ]");

            if (fExceptionCallBack == null) {

                fExceptionCallBack = new ExceptionCallBack();//异常回调

                //设置异常回调函数(可在回调函数中获取设备上下线状态等)

                if (!hCNetSDK.NET_DVR_SetExceptionCallBack_V30(0, 0, fExceptionCallBack, null)) {

                    log.debug("Set fExceptionCallBack function fail");

                    return;

                } else {

                    log.debug("Set fExceptionCallBack function successfully!");

                }

            }



            if (GlobalVariable.loginMap.containsKey(camera.getId())) {

                GlobalVariable.loginMap.remove(camera.getId());

            }



            //删除管理通道

            ardChannelService.deleteArdChannelByDeviceId(camera.getId());

            GlobalVariable.loginMap.put(camera.getId(), lUserID);

            GlobalVariable.loginCameraMap.put(lUserID, camera);



            camera.setLoginId(lUserID);

            camera.setState("1");

            camera.setChanNum((int) m_strDeviceInfo.struDeviceV30.byChanNum);

            camera.setStartDChan((int) m_strDeviceInfo.struDeviceV30.byStartDChan);

            ardCamerasService.updateArdCameras(camera);

            //获取最新通道

            List<ArdChannel> cameraChannelList = getCameraChannelList(camera);

            if (cameraChannelList.size() > 0) {

                for (ArdChannel channel : cameraChannelList) {

                    channel.setId(IdUtils.simpleUUID());

                    ardChannelService.insertArdChannel(channel);

                }

                //添加到流媒体

                for (ArdChannel channel : cameraChannelList) {

                    String name = camera.getId() + "_" + channel.getChanNo();

                    String rtspSource = "rtsp://" + camera.getUsername() + ":" + camera.getPassword() + "@" + camera.getIp() + ":" + camera.getRtspPort() + "/h264/ch" + channel.getChanNo() + "/main/av_stream";

                    Vtdu vtdu = vtduService.selectVtduByName(name);

                    if (vtdu != null) {

                        vtduService.deleteVtduByName(name);

                    }

                    //添加到流媒体

                    vtdu = new Vtdu();

                    vtdu.setRtspSource(rtspSource);

                    vtdu.setName(camera.getId() + "_" + channel.getChanNo());

                    CameraCmd cmd = new CameraCmd(camera.getId(), channel.getChanNo());

                    Map<String, Object> videoCompressionCfg = getVideoCompressionCfg(cmd);

                    if (videoCompressionCfg.get("videoEncType").equals("标准h264")) {

                        vtdu.setIsCode("0");//默认不转码

                    } else {

                        vtdu.setIsCode("1");//默认转码

                    }

                    vtdu.setMode("1");//默认CPU软解码

                    vtdu.setCameraId(camera.getId());

                    vtduService.insertVtdu(vtdu);

                }

            }

            //创建引导队列

            if (!GuidePriorityQueue.cameraQueueMap.containsKey(camera.getId())) {

                Comparator<GuideTask> comparator = GuidePriorityQueue.getComparator();

                PriorityBlockingQueue<GuideTask> priorityQueue = new PriorityBlockingQueue<>(1000, comparator);

                GuidePriorityQueue.cameraQueueMap.put(camera.getId(), priorityQueue);

            }



        } catch (Exception ex) {

            log.error("注册设备异常", ex);

        }

    }



    /**

     * @描述 注册登录 集成于NET_DVR_Login_V30，支持同步和异步登录

     * @参数 [dvrLogin]

     * @返回值 java.lang.Integer

     * @创建人 刘苏义

     * @创建时间 2023/1/17 16:12

     * @修改人和其它信息

     */

    @Override

    public void asyncLogin(ArdCameras camera) {

        // 初始化

        if (!hCNetSDK.NET_DVR_Init()) {

            log.error("SDK初始化失败");

        }

        //打印海康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 {

            hCNetSDK.NET_DVR_SetLogToFile(3, "/home/ardLog/hiklog", true);

        }

        String m_sDeviceIP = camera.getIp();

        String m_sUsername = camera.getUsername();

        String m_sPassword = camera.getPassword();

        short m_sPort = camera.getPort().shortValue();

        //设置连接时间与重连时间

        hCNetSDK.NET_DVR_SetConnectTime(2000, 1);

        hCNetSDK.NET_DVR_SetReconnect(100000, true);

        //设备信息, 输出参数

        HCNetSDK.NET_DVR_DEVICEINFO_V40 m_strDeviceInfo = new HCNetSDK.NET_DVR_DEVICEINFO_V40();

        HCNetSDK.NET_DVR_USER_LOGIN_INFO m_strLoginInfo = new HCNetSDK.NET_DVR_USER_LOGIN_INFO();



        // 注册设备-登录参数，包括设备地址、登录用户、密码等

        m_strLoginInfo.sDeviceAddress = new byte[HCNetSDK.NET_DVR_DEV_ADDRESS_MAX_LEN];

        System.arraycopy(m_sDeviceIP.getBytes(), 0, m_strLoginInfo.sDeviceAddress, 0, m_sDeviceIP.length());

        m_strLoginInfo.sUserName = new byte[HCNetSDK.NET_DVR_LOGIN_USERNAME_MAX_LEN];

        System.arraycopy(m_sUsername.getBytes(), 0, m_strLoginInfo.sUserName, 0, m_sUsername.length());

        m_strLoginInfo.sPassword = new byte[HCNetSDK.NET_DVR_LOGIN_PASSWD_MAX_LEN];

        System.arraycopy(m_sPassword.getBytes(), 0, m_strLoginInfo.sPassword, 0, m_sPassword.length());

        m_strLoginInfo.wPort = m_sPort;

        m_strLoginInfo.byVerifyMode = 0;

        m_strLoginInfo.byLoginMode = 0;

        //是否异步登录：0- 否，1- 是  windowsSDK里是true和false

        m_strLoginInfo.bUseAsynLogin = true;

        //异步登录回调

        m_strLoginInfo.cbLoginResult = new LoginResultCallBack(camera);

        m_strLoginInfo.write();

        int i = hCNetSDK.NET_DVR_Login_V40(m_strLoginInfo, m_strDeviceInfo);

        if (i < 0) {

            int errorCode = hCNetSDK.NET_DVR_GetLastError();

            log.error("登录异常：" + errorCode);

        }



    }





    /**

     * @描述 注销登录

     * @参数 [dvrLogin]

     * @返回值 java.lang.Integer

     * @创建人 刘苏义

     * @创建时间 2023/1/17 16:12

     * @修改人和其它信息

     */

    @Override

    public boolean logout(String cameraId) {

        if (!GlobalVariable.loginMap.containsKey(cameraId)) {

            return false;

        }

        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);

        boolean b = hCNetSDK.NET_DVR_Logout(userId);

        if (b) {

            GlobalVariable.loginMap.remove(cameraId);

        }

        return b;

    }



    /**

     * 是否在线

     *

     * @param cmd 相机命令

     */

    @Override

    public boolean isOnLine(CameraCmd cmd) {

        try {

            String cameraId = cmd.getCameraId();

            if (!GlobalVariable.loginMap.containsKey(cameraId)) {

                return false;

            }

            Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);

            return hCNetSDK.NET_DVR_RemoteControl(userId, NET_DVR_CHECK_USER_STATUS, null, 0);

        } catch (Exception ex) {

            log.error("检测在线异常：" + ex.getMessage());

            return false;

        }

    }



    /**

     * @描述 带速度的云台控制操作

     * Code:1-左上 2-上 3-右上 4-左 5-巡航 6-右 7-左下 8-下 9-右下 10-焦距变大 11-焦距变小

     * 12-焦点前调 13-焦点后调 14-光圈扩大 15-光圈缩小 16-雨刷开启

     * @参数 [userId, channelNum, speed]

     * @返回值 boolean

     * @创建人 刘苏义

     * @创建时间 2023/1/17 16:14

     * @修改人和其它信息

     */

    @Override

    @SdkOperate

    public boolean pTZControlWithSpeed(CameraCmd cmd) {

        String cameraId = cmd.getCameraId();

        boolean enable = cmd.isEnable();

        Integer channelNum = cmd.getChanNo();

        Integer speed = cmd.getSpeed();

        Integer code = cmd.getCode();

        if (!GlobalVariable.loginMap.containsKey(cameraId)) {

            return false;

        }

        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);

        int dwStop;

        if (enable) {

            dwStop = 0;//开启

        } else {

            dwStop = 1;//关闭

        }

        int dwPTZCommand = -1;

        switch (code) {

            /*方向*/

            case 1:

                dwPTZCommand = HCNetSDK.UP_LEFT;

                break;

            case 2:

                dwPTZCommand = HCNetSDK.TILT_UP;

                break;

            case 3:

                dwPTZCommand = HCNetSDK.UP_RIGHT;

                break;

            case 4:

                dwPTZCommand = HCNetSDK.PAN_LEFT;

                break;

            case 5:

                dwPTZCommand = HCNetSDK.RUN_SEQ;

                break;

            case 6:

                dwPTZCommand = HCNetSDK.PAN_RIGHT;

                break;

            case 7:

                dwPTZCommand = HCNetSDK.DOWN_LEFT;

                break;

            case 8:

                dwPTZCommand = HCNetSDK.TILT_DOWN;

                break;

            case 9:

                dwPTZCommand = HCNetSDK.DOWN_RIGHT;

                break;

            /*焦距*/

            case 10:

                dwPTZCommand = HCNetSDK.ZOOM_IN;

                break;

            case 11:

                dwPTZCommand = HCNetSDK.ZOOM_OUT;

                break;

            /*焦点*/

            case 12:

                dwPTZCommand = HCNetSDK.FOCUS_NEAR;

                break;

            case 13:

                dwPTZCommand = HCNetSDK.FOCUS_FAR;

                break;

            /*光圈*/

            case 14:

                dwPTZCommand = HCNetSDK.IRIS_OPEN;

                break;

            case 15:

                dwPTZCommand = HCNetSDK.IRIS_CLOSE;

                break;

            /*雨刷*/

            case 16:

                dwPTZCommand = HCNetSDK.WIPER_PWRON;

                break;

        }

        boolean bool = hCNetSDK.NET_DVR_PTZControlWithSpeed_Other(userId, channelNum, dwPTZCommand, dwStop, speed);

        if (!bool) {

            int errorCode = hCNetSDK.NET_DVR_GetLastError();

            log.error("控制失败,请稍后重试" + errorCode);

        }

        return bool;

    }



    /**

     * 设置聚焦值

     *

     * @param cmd 相机命令

     */

    @Override

    public boolean setFocusPos(CameraCmd cmd) {

        String cameraId = cmd.getCameraId();

        Integer channelNum = cmd.getChanNo();

        Integer dwFocusPos = cmd.getDwFocusPos();

        if (!GlobalVariable.loginMap.containsKey(cameraId)) {

            return false;

        }

        // 获取参数

        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);

        HCNetSDK.NET_DVR_STD_CONFIG struStdCfg = new HCNetSDK.NET_DVR_STD_CONFIG();

        HCNetSDK.NET_DVR_GIS_INFO struGisInfo = new HCNetSDK.NET_DVR_GIS_INFO();

        struGisInfo.struPtzPosEx.dwFocus = dwFocusPos;

        struStdCfg.read();

        IntByReference lchannel = new IntByReference(channelNum);

        struStdCfg.lpInBuffer = struGisInfo.getPointer();

        struStdCfg.lpCondBuffer = lchannel.getPointer();

        struStdCfg.dwCondSize = 4;

        struStdCfg.dwInSize = struGisInfo.size();

        struStdCfg.write();//设置前之前要write()

        boolean bool = hCNetSDK.NET_DVR_SetSTDConfig(userId, NET_DVR_GET_GISINFO, struStdCfg);

        if (!bool) {

            int code = hCNetSDK.NET_DVR_GetLastError();

            log.error("设置GIS信息数据失败,请稍后重试" + code);

            return false;

        } else {

            return true;

        }

    }



    /**

     * 获取聚焦值

     *

     * @param cmd 相机命令

     */

    @Override

    public int getFocusPos(CameraCmd cmd) {

        int result = 0;

        String cameraId = cmd.getCameraId();

        Integer channelNum = cmd.getChanNo();

        if (!GlobalVariable.loginMap.containsKey(cameraId)) {

            return result;

        }

        // 获取参数

        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);

        HCNetSDK.NET_DVR_STD_CONFIG struStdCfg = new HCNetSDK.NET_DVR_STD_CONFIG();

        HCNetSDK.NET_DVR_GIS_INFO struGisInfo = new HCNetSDK.NET_DVR_GIS_INFO();

        struStdCfg.read();

        IntByReference lchannel = new IntByReference(channelNum);

        struStdCfg.lpCondBuffer = lchannel.getPointer();

        struStdCfg.dwCondSize = 4;

        struStdCfg.lpOutBuffer = struGisInfo.getPointer();

        struStdCfg.dwOutSize = struGisInfo.size();

        struStdCfg.write();//设置前之前要write()

        boolean bool = hCNetSDK.NET_DVR_GetSTDConfig(userId, NET_DVR_GET_GISINFO, struStdCfg);

        if (!bool) {

            int code = hCNetSDK.NET_DVR_GetLastError();

            log.error("获取GIS信息数据失败,请稍后重试" + code);

            return result;

        } else {

            struGisInfo.read();

            result = struGisInfo.struPtzPosEx.dwFocus;

        }

        return result;

    }



    /**

     * 设置预置点

     *

     * @param cmd 相机命令

     */

    @Override

    public boolean setPreset(CameraCmd cmd) {

        String cameraId = cmd.getCameraId();

        Integer channelNum = cmd.getChanNo();

        Integer PresetIndex = cmd.getPresetIndex();

        if (!GlobalVariable.loginMap.containsKey(cameraId)) {

            return false;

        }

        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);

        boolean bool = hCNetSDK.NET_DVR_PTZPreset_Other(userId, channelNum, SET_PRESET, PresetIndex);

        if (!bool) {

            int code = hCNetSDK.NET_DVR_GetLastError();

            log.error("预置点设置失败,请稍后重试" + code);

        }

        return bool;

    }



    /**

     * 转到预置点

     *

     * @param cmd 相机命令

     */

    @Override

    public boolean gotoPreset(CameraCmd cmd) {

        String cameraId = cmd.getCameraId();

        Integer channelNum = cmd.getChanNo();

        Integer PresetIndex = cmd.getPresetIndex();

        if (!GlobalVariable.loginMap.containsKey(cameraId)) {

            return false;

        }

        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);

        boolean bool = hCNetSDK.NET_DVR_PTZPreset_Other(userId, channelNum, GOTO_PRESET, PresetIndex);

        if (!bool) {

            int code = hCNetSDK.NET_DVR_GetLastError();

            log.error("预置点设置失败,请稍后重试" + code);

        }

        return bool;

    }



    /**

     * @描述 获取通道压缩参数

     * @参数 [cameraId, channelNum]

     * @返回值 java.lang.String

     * @创建人 刘苏义

     * @创建时间 2023/2/3 8:36

     * @修改人和其它信息

     */

    @Override

    public Map<String, Object> getVideoCompressionCfg(CameraCmd cmd) {



        Map<String, Object> map = new HashMap<>();

        try {

            String cameraId = cmd.getCameraId();

            Integer chanNo = cmd.getChanNo();

            if (!GlobalVariable.loginMap.containsKey(cameraId)) {

                return null;

            }

            Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);



            NET_DVR_COMPRESSIONCFG_V30 compressioncfg = new NET_DVR_COMPRESSIONCFG_V30();

            compressioncfg.write();

            Pointer pioint = compressioncfg.getPointer();

            IntByReference ibrBytesReturned = new IntByReference(0);



            boolean bool = hCNetSDK.NET_DVR_GetDVRConfig(userId, HCNetSDK.NET_DVR_GET_COMPRESSCFG_V30, chanNo, pioint, compressioncfg.size(), ibrBytesReturned);

            if (bool) {

                compressioncfg.read();

                //码流类型：0-视频流，1-复合流，0xfe- 自动（和源一致）

                String streamType = "";

                switch (compressioncfg.struNormHighRecordPara.byStreamType) {

                    case 0:

                        streamType = "视频流";

                        break;

                    case 1:

                        streamType = "复合流";

                        break;

                    default:

                        streamType = "未知";

                        break;

                }

                //视频编码类型：0-私有264，1-标准h264，2-标准mpeg4，7-M-JPEG，8-MPEG2，9-SVAC，10-标准h265，0xfe- 自动（和源一致），0xff-无效

                String videoEncType = "";

                switch (compressioncfg.struNormHighRecordPara.byVideoEncType) {

                    case 0:

                        videoEncType = "私有264";

                        break;

                    case 1:

                        videoEncType = "标准h264";

                        break;

                    case 2:

                        videoEncType = "标准mpeg4";

                        break;

                    case 7:

                        videoEncType = "M-JPEG";

                        break;

                    case 8:

                        videoEncType = "MPEG2";

                        break;

                    case 9:

                        videoEncType = "SVAC";

                        break;

                    case 10:

                        videoEncType = "标准h265";

                        break;

                    default:

                        videoEncType = "未知";

                        break;

                }

                //视频码率

                String videoBitrate = "";

                switch (compressioncfg.struNormHighRecordPara.dwVideoBitrate) {

                    case 0:

                        videoBitrate = "保留";

                        break;

                    case 1:

                        videoBitrate = "16(保留)";

                        break;

                    case 2:

                        videoBitrate = "32";

                        break;

                    case 3:

                        videoBitrate = "48";

                        break;

                    case 4:

                        videoBitrate = "64";

                        break;

                    case 5:

                        videoBitrate = "80";

                        break;

                    case 6:

                        videoBitrate = "96";

                        break;

                    case 7:

                        videoBitrate = "128";

                        break;

                    case 8:

                        videoBitrate = "160";

                        break;

                    case 9:

                        videoBitrate = "192";

                        break;

                    case 10:

                        videoBitrate = "224";

                        break;

                    case 11:

                        videoBitrate = "256";

                        break;

                    case 12:

                        videoBitrate = "320";

                        break;

                    case 13:

                        videoBitrate = "384";

                        break;

                    case 14:

                        videoBitrate = "448";

                        break;

                    case 15:

                        videoBitrate = "512";

                        break;

                    case 16:

                        videoBitrate = "640";

                        break;

                    case 17:

                        videoBitrate = "768";

                        break;

                    case 18:

                        videoBitrate = "896";

                        break;

                    case 19:

                        videoBitrate = "1024";

                        break;

                    case 20:

                        videoBitrate = "1280";

                        break;

                    case 21:

                        videoBitrate = "1536";

                        break;

                    case 22:

                        videoBitrate = "1792";

                        break;

                    case 23:

                        videoBitrate = "2048K";

                        break;

                    case 24:

                        videoBitrate = "3072";

                        break;

                    case 25:

                        videoBitrate = "4096";

                        break;

                    case 26:

                        videoBitrate = "8192";

                        break;

                    case 27:

                        videoBitrate = "16384";

                        break;

                    default:

                        videoBitrate = "其他";

                        break;

                }

                //视频输出口分辨率：0- 1024x768，1- 1280x720，2-1280x1024，3- 1680x1050，4- 1920x1080，5- 3840*2160

                String resolution = "";

                switch (compressioncfg.struNormHighRecordPara.byResolution) {

                    case 0:

                        resolution = "528*384/528*320";

                        break;

                    case 1:

                        resolution = "352*288/352*240";

                        break;

                    case 2:

                        resolution = "176*144/176*120";

                        break;

                    case 3:

                        resolution = "704*576/704*480";

                        break;

                    case 4:

                        resolution = "704*288/704*240";

                        break;

                    case 6:

                        resolution = "320*240";

                        break;

                    case 7:

                        resolution = "160*120";

                        break;

                    case 16:

                        resolution = "640*480";

                        break;

                    case 17:

                        resolution = "1600*1200";

                        break;

                    case 18:

                        resolution = "800*600";

                        break;

                    case 19:

                        resolution = "1280*720";

                        break;

                    case 20:

                        resolution = "1280*960";

                        break;

                    case 21:

                        resolution = "1600*900";

                        break;

                    case 22:

                        resolution = "1360*1024";

                        break;

                    case 23:

                        resolution = "1536*1536";

                        break;

                    case 24:

                        resolution = "1920*1920";

                        break;

                    case 27:

                        resolution = "1920*1080";

                        break;

                    case 28:

                        resolution = "2560*1920";

                        break;

                    case 29:

                        resolution = "1600*304";

                        break;

                    case 30:

                        resolution = "2048*1536";

                        break;

                    default:

                        resolution = "不在当前分辨率索引，请联系管理员添加";

                        break;

                }

                //帧率

                String nFrameRate = "";

                switch (compressioncfg.struNormHighRecordPara.dwVideoFrameRate) {

                    case 0:

                        nFrameRate = "0";

                        break;

                    case 1:

                        nFrameRate = "1/16";

                        break;

                    case 2:

                        nFrameRate = "1/8";

                        break;

                    case 3:

                        nFrameRate = "1/4";

                        break;

                    case 4:

                        nFrameRate = "1/2";

                        break;

                    case 5:

                        nFrameRate = "1";

                        break;

                    case 6:

                        nFrameRate = "2";

                        break;

                    case 7:

                        nFrameRate = "4";

                        break;

                    case 8:

                        nFrameRate = "6";

                        break;

                    case 9:

                        nFrameRate = "8";

                        break;

                    case 10:

                        nFrameRate = "10";

                        break;

                    case 11:

                        nFrameRate = "12";

                        break;

                    case 12:

                        nFrameRate = "16";

                        break;

                    case 13:

                        nFrameRate = "20";

                        break;

                    case 14:

                        nFrameRate = "15";

                        break;

                    case 15:

                        nFrameRate = "18";

                        break;

                    case 16:

                        nFrameRate = "22";

                        break;

                    case 17:

                        nFrameRate = "25";

                        break;

                    case 18:

                        nFrameRate = "30";

                        break;

                    case 19:

                        nFrameRate = "35";

                        break;

                    case 20:

                        nFrameRate = "40";

                        break;

                    default:

                        nFrameRate = "未知";

                        break;

                }

                map.put("resolution", resolution);//分辨率

                map.put("videoBitrate", videoBitrate);//比特率

                map.put("videoEncType", videoEncType);//编码

                map.put("nFrameRate", nFrameRate);//帧率



            } else {

                int code = hCNetSDK.NET_DVR_GetLastError();

                log.error("控制失败,请稍后重试" + code);

            }

        } catch (Exception ex) {

            log.error(ex.getMessage());

        }

        return map;

    }



    /**

     * @描述 获取ptz信息

     * @参数 [userId, channelNum]

     * @返回值 boolean

     * @创建人 刘苏义

     * @创建时间 2023/1/17 16:36

     * @修改人和其它信息

     */

    @Override

    public Map<String, Object> getPtz(CameraCmd cmd) {

        String cameraId = cmd.getCameraId();

        Integer channelNum = cmd.getChanNo();

        if (!GlobalVariable.loginMap.containsKey(cameraId)) {

            return new HashMap<>();

        }

        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);



        NET_DVR_PTZPOS m_ptzPosCurrent = new NET_DVR_PTZPOS();

        Pointer pioint = m_ptzPosCurrent.getPointer();

        IntByReference ibrBytesReturned = new IntByReference(0);

        m_ptzPosCurrent.write();

        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");//设置保留位数

            //16进制转Integer后除10，保留小数点1位

            //实际显示的PTZ值是获取到的十六进制值的十分之一，

            //如获取的水平参数P的值是0x1750，实际显示的P值为175度；

            //获取到的垂直参数T的值是0x0789，实际显示的T值为78.9度；

            //获取到的变倍参数Z的值是0x1100，实际显示的Z值为110倍。

            BigDecimal b = new BigDecimal((float) Integer.parseInt(Integer.toHexString(m_ptzPosCurrent.wPanPos)) / 10);

            BigDecimal c = new BigDecimal((float) Integer.parseInt(Integer.toHexString(m_ptzPosCurrent.wTiltPos)) / 10);

            BigDecimal d = new BigDecimal((float) Integer.parseInt(Integer.toHexString(m_ptzPosCurrent.wZoomPos)) / 10);

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

            Map<String, Object> ptzMap = new HashMap<>();

            ptzMap.put("p", p);

            ptzMap.put("t", t);

            ptzMap.put("z", z);

            return ptzMap;

        } else {

            int code = hCNetSDK.NET_DVR_GetLastError();

            log.error("控制失败,请稍后重试" + code);

            return new HashMap<>();

        }

    }



    /**

     * @描述 设置ptz信息

     * @参数 [userId, channelNum]

     * @返回值 boolean

     * @创建人 刘苏义

     * @创建时间 2023/1/17 16:36

     * @修改人和其它信息 注意俯仰角度负值需要加上360得到的正值进行设置

     */

    @Override

    public boolean setPtz(CameraCmd cmd) {

        String cameraId = cmd.getCameraId();

        Integer channelNum = cmd.getChanNo();

        Map<String, Double> ptz = cmd.getPtzMap();

        if (!GlobalVariable.loginMap.containsKey(cameraId)) {

            return false;

        }

        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);

        NET_DVR_PTZPOS m_ptzPosCurrent = new NET_DVR_PTZPOS();

        m_ptzPosCurrent.wAction = 1;

        try {

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

            Pointer point = m_ptzPosCurrent.getPointer();

            m_ptzPosCurrent.write();

            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.error("设置ptz失败,请稍后重试" + code);

            }

            return bool;

        } catch (Exception ex) {

            log.error(ex.getMessage());

            return false;

        }

    }



    @Override

    public boolean guideTargetPosition(CameraCmd cmd) {

        String cameraId = cmd.getCameraId();

        Integer channelNum = cmd.getChanNo();

        if (!GlobalVariable.loginMap.containsKey(cameraId)) {

            return false;

        }

        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);

        NET_DVR_PTZPOS m_ptzPosCurrent = new NET_DVR_PTZPOS();

        m_ptzPosCurrent.wAction = 1;

        try {

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

            String p = String.valueOf((int) (cameraPTZ[0] * 10));

            String t = String.valueOf((int) (cameraPTZ[1] * 10));

            String z = String.valueOf((int) (cameraPTZ[2] * 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));

            Pointer point = m_ptzPosCurrent.getPointer();

            m_ptzPosCurrent.write();

            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.error("设置ptz失败,请稍后重试" + code);

            }

            return bool;

        } catch (Exception ex) {

            log.error("引导异常:" + ex.getMessage());

            return false;

        }

    }





    /**

     * @描述 获取ptz锁定信息

     * @参数 [userId, channelNum]

     * @返回值 boolean

     * @创建人 刘苏义

     * @创建时间 2023/1/17 16:36

     * @修改人和其它信息 0-解锁 1-锁定

     */

    @Override

    public int getPTZLockInfo(CameraCmd cmd) {

        String cameraId = cmd.getCameraId();

        Integer channelNum = cmd.getChanNo();

        if (!GlobalVariable.loginMap.containsKey(cameraId)) {

            return -1;

        }

        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);

        NET_DVR_PTZ_LOCKCFG netDvrPtzLockcfg = new NET_DVR_PTZ_LOCKCFG();

        Pointer point = netDvrPtzLockcfg.getPointer();

        IntByReference ibrBytesReturned = new IntByReference(0);

        netDvrPtzLockcfg.write();

        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.error("获取ptz锁定信息失败,请稍后重试" + code);

            return -1;

        } else {

            netDvrPtzLockcfg.read();

            return netDvrPtzLockcfg.byWorkMode;

        }

    }



    /**

     * @描述 设置零方位角

     * @参数 [userId, channelNum]

     * @返回值 boolean

     * @创建人 刘苏义

     * @创建时间 2023/1/17 16:36

     * @修改人和其它信息 注意俯仰角度负值需要加上360得到的正值进行设置

     */

    @Override

    @SdkOperate

    public boolean setZeroPtz(CameraCmd cmd) {

        String cameraId = cmd.getCameraId();

        Integer channelNum = cmd.getChanNo();

        if (!GlobalVariable.loginMap.containsKey(cameraId)) {

            return false;

        }

        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);

        NET_DVR_INITIALPOSITIONCTRL initialpositionctrl = new NET_DVR_INITIALPOSITIONCTRL();



        initialpositionctrl.dwSize = initialpositionctrl.size();

        initialpositionctrl.byWorkMode = 0;

        initialpositionctrl.dwChan = Short.parseShort(channelNum.toString());



        Pointer point = initialpositionctrl.getPointer();

        initialpositionctrl.write();

        boolean bool = hCNetSDK.NET_DVR_RemoteControl(userId, NET_DVR_PTZ_INITIALPOSITIONCTRL, point, initialpositionctrl.size());

        if (!bool) {

            int i = hCNetSDK.NET_DVR_GetLastError();

            log.error("错误码：" + i);

        }

        return bool;

    }



    /**

     * @描述 获取球机PTZ参数取值范围

     * @参数 [cameraId, channelNum]

     * @返回值 java.util.Map<java.lang.String, java.lang.Object>

     * @创建人 刘苏义

     * @创建时间 2023/2/8 10:58

     * @修改人和其它信息

     */

    @Override

    public Map<String, Object> getPtzScope(CameraCmd cmd) {

        String cameraId = cmd.getCameraId();

        Integer channelNum = cmd.getChanNo();

        if (!GlobalVariable.loginMap.containsKey(cameraId)) {

            return new HashMap<>();

        }

        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);

        NET_DVR_PTZSCOPE m_ptzPosCurrent = new NET_DVR_PTZSCOPE();

        Pointer point = m_ptzPosCurrent.getPointer();

        IntByReference ibrBytesReturned = new IntByReference(0);

        m_ptzPosCurrent.write();

        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.error("设置ptz失败,请稍后重试" + code);

            return new HashMap<>();

        } else {

            m_ptzPosCurrent.read();

            DecimalFormat df = new DecimalFormat("0.0");//设置保留位数



            String wPanPosMax = df.format((float) Integer.parseInt(Integer.toHexString(m_ptzPosCurrent.wPanPosMax)) / 10);

            String wPanPosMin = df.format((float) Integer.parseInt(Integer.toHexString(m_ptzPosCurrent.wTiltPosMax)) / 10);

            String wTiltPosMax = df.format((float) Integer.parseInt(Integer.toHexString(m_ptzPosCurrent.wTiltPosMax)) / 10);

            String wTiltPosMin = df.format((float) Integer.parseInt(Integer.toHexString(m_ptzPosCurrent.wTiltPosMin)) / 10);

            String wZoomPosMax = df.format((float) Integer.parseInt(Integer.toHexString(m_ptzPosCurrent.wZoomPosMax)) / 10);

            String wZoomPosMin = df.format((float) Integer.parseInt(Integer.toHexString(m_ptzPosCurrent.wZoomPosMin)) / 10);

            Map<String, Object> ptzScopeMap = new HashMap<>();

            ptzScopeMap.put("pMax", wPanPosMax);

            ptzScopeMap.put("pMin", wPanPosMin);

            ptzScopeMap.put("tMax", wTiltPosMax);

            ptzScopeMap.put("tMin", wTiltPosMin);

            ptzScopeMap.put("zMax", wZoomPosMax);

            ptzScopeMap.put("zMin", wZoomPosMin);

            return ptzScopeMap;

        }



    }



    /**

     * @描述 透雾开关

     * @参数 [userId, channelNum, enable]

     * @返回值 boolean

     * @创建人 刘苏义

     * @创建时间 2023/1/18 13:07

     * @修改人和其它信息

     */

    @Override

    public boolean controlDefogcfg(CameraCmd cmd) {

        String cameraId = cmd.getCameraId();

        boolean enable = cmd.isEnable();

        Integer channelNum = cmd.getChanNo();

        if (!GlobalVariable.loginMap.containsKey(cameraId)) {

            return false;

        }

        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);

        NET_DVR_CAMERAPARAMCFG_EX struCameraParam = new NET_DVR_CAMERAPARAMCFG_EX();

        Pointer point = struCameraParam.getPointer();

        IntByReference ibrBytesReturned = new IntByReference(0);

        boolean b_GetCameraParam = hCNetSDK.NET_DVR_GetDVRConfig(userId, NET_DVR_GET_CCDPARAMCFG_EX, channelNum, point, struCameraParam.size(), ibrBytesReturned);

        if (!b_GetCameraParam) {

            log.error("获取前端参数失败，错误码：" + hCNetSDK.NET_DVR_GetLastError());

        }

        struCameraParam.read();

        log.debug("是否开启透雾：" + struCameraParam.struDefogCfg.byMode);



        NET_DVR_DEFOGCFG defogcfg = new NET_DVR_DEFOGCFG();

        if (enable) {

            defogcfg.byMode = 2;//0-不启用 1-自动模式 2-常开模式

            defogcfg.byLevel = 100;//取值范围0-100

        } else {

            defogcfg.byMode = 0;//0-不启用 1-自动模式 2-常开模式

        }

        struCameraParam.struDefogCfg = defogcfg;

        struCameraParam.write();

        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.error("设置透雾失败,请稍后重试" + code);

        }

        log.debug("设置透雾成功");

        return bool;

    }



    /**

     * @描述 红外开关

     * @参数 [userId, channelNum, enable]

     * @返回值 boolean

     * @创建人 刘苏义

     * @创建时间 2023/1/18 13:07

     * @修改人和其它信息

     */

    @Override

    public boolean controlInfrarecfg(CameraCmd cmd) {

        String cameraId = cmd.getCameraId();

        boolean enable = cmd.isEnable();

        Integer chanNo = cmd.getChanNo();

        if (!GlobalVariable.loginMap.containsKey(cameraId)) {

            return false;

        }

        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);

        NET_DVR_CAMERAPARAMCFG_EX struDayNigh = new NET_DVR_CAMERAPARAMCFG_EX();

        Pointer point = struDayNigh.getPointer();

        IntByReference ibrBytesReturned = new IntByReference(0);

        boolean b_GetCameraParam = hCNetSDK.NET_DVR_GetDVRConfig(userId, NET_DVR_GET_CCDPARAMCFG_EX, chanNo, point, struDayNigh.size(), ibrBytesReturned);

        if (!b_GetCameraParam) {

            log.error("获取前端参数失败，错误码：" + hCNetSDK.NET_DVR_GetLastError());

        }

        struDayNigh.read();

        String current = struDayNigh.struDayNight.byDayNightFilterType == 1 ? "开启" : "关闭";

        log.debug("当前状态:" + current);



        NET_DVR_DAYNIGHT daynight = new NET_DVR_DAYNIGHT();

        if (enable) {

            daynight.byDayNightFilterType = 1;//夜晚

        } else {

            daynight.byDayNightFilterType = 0;//白天

        }

        daynight.bySwitchScheduleEnabled = 1;

        daynight.byDayNightFilterTime = 60;

        struDayNigh.struDayNight = daynight;

        struDayNigh.write();

        boolean bool = hCNetSDK.NET_DVR_SetDVRConfig(userId, NET_DVR_SET_CCDPARAMCFG_EX, chanNo, point, struDayNigh.size());

        if (!bool) {

            int code = hCNetSDK.NET_DVR_GetLastError();

            log.error("设置夜视失败,请稍后重试" + code);

        }

        else {

            log.debug("设置夜视成功");

        }



        return bool;

    }



    /**

     * @描述 聚焦开关

     * @参数 [userId, channelNum, enable]

     * @返回值 boolean

     * @创建人 刘苏义

     * @创建时间 2023/1/18 13:07

     * @修改人和其它信息

     */

    @Override

    public boolean controlFocusMode(CameraCmd cmd) {

        String cameraId = cmd.getCameraId();

        boolean enable = cmd.isEnable();

        Integer channelNum = cmd.getChanNo();

        if (!GlobalVariable.loginMap.containsKey(cameraId)) {

            return false;

        }

        Integer userId = (Integer) 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);



        if (enable) {

            struFocusMode.byFocusMode = 1;//手动聚焦

        } else {

            struFocusMode.byAutoFocusMode = 1;

            struFocusMode.byFocusMode = 2;//自动聚焦

        }

        struFocusMode.byFocusDefinitionDisplay = 1;

        struFocusMode.byFocusSpeedLevel = 3;

        struFocusMode.write();

        boolean bool = hCNetSDK.NET_DVR_SetDVRConfig(userId, NET_DVR_SET_FOCUSMODECFG, channelNum, point, struFocusMode.size());

        if (!bool) {

            int code = hCNetSDK.NET_DVR_GetLastError();

            log.error("设置聚焦模式失败,请稍后重试" + code);

        }

        log.debug("设置聚焦模式成功");

        return bool;

    }



    /**

     * @描述 获取聚焦模式

     * @参数 [userId, channelNum]

     * @返回值 boolean

     * @创建人 刘苏义

     * @创建时间 2023/1/18 13:07

     * @修改人和其它信息

     */

    public String getFocusMode(CameraCmd cmd) {

        String cameraId = cmd.getCameraId();

        Integer channelNum = cmd.getChanNo();

        if (!GlobalVariable.loginMap.containsKey(cameraId)) {

            return "";

        }

        Integer userId = (Integer) 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);

    }



    /**

     * @描述 云台加热开关

     * @参数 [userId, channelNum, enable]

     * @返回值 boolean

     * @创建人 刘苏义

     * @创建时间 2023/1/18 13:07

     * @修改人和其它信息

     */

    @Override

    public boolean controlPTHeateRpwron(CameraCmd cmd) {

        String cameraId = cmd.getCameraId();

        boolean enable = cmd.isEnable();

        Integer channelNum = cmd.getChanNo();

        if (!GlobalVariable.loginMap.containsKey(cameraId)) {

            return false;

        }

        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);

        int dwStop;

        if (enable) {

            dwStop = 0;//开启

        } else {

            dwStop = 1;//关闭

        }

        boolean bool = hCNetSDK.NET_DVR_PTZControl_Other(userId, channelNum, HEATER_PWRON, dwStop);

        if (!bool) {

            int code = hCNetSDK.NET_DVR_GetLastError();

            log.error("设置云台加热失败,请稍后重试" + code);

        }

        log.debug("设置云台加热成功");

        return bool;

    }



    /**

     * @描述 镜头加热开关

     * @参数 [userId, channelNum, enable]

     * @返回值 boolean

     * @创建人 刘苏义

     * @创建时间 2023/1/18 13:07

     * @修改人和其它信息

     */

    @Override

    public boolean controlCameraDeicing(CameraCmd cmd) {

        String cameraId = cmd.getCameraId();

        boolean enable = cmd.isEnable();

        Integer channelNum = cmd.getChanNo();

        if (!GlobalVariable.loginMap.containsKey(cameraId)) {

            return false;

        }

        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);

        NET_DVR_DEVSERVER_CFG struDeicing = new NET_DVR_DEVSERVER_CFG();

        Pointer point = struDeicing.getPointer();

        IntByReference ibrBytesReturned = new IntByReference(0);

        boolean b_GetCameraParam = hCNetSDK.NET_DVR_GetDVRConfig(userId, NET_DVR_GET_DEVSERVER_CFG, channelNum, point, struDeicing.size(), ibrBytesReturned);

        if (!b_GetCameraParam) {

            log.error("获取前端参数失败，错误码：" + hCNetSDK.NET_DVR_GetLastError());

        }

        struDeicing.read();

        log.debug("是否开启除冰：" + struDeicing.byEnableDeicing);



        if (enable) {

            struDeicing.byEnableDeicing = 1;//开启

        } else {

            struDeicing.byEnableDeicing = 0;//关闭

        }

        struDeicing.write();

        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.error("设置镜头除冰失败,请稍后重试" + code);

        }

        log.debug("设置镜头除冰成功");

        return bool;

    }



    /**

     * 截图 返给前端

     *

     * @param cmd 相机命令

     */

    public String captureJPEGPicture(CameraCmd cmd) {

        String cameraId = cmd.getCameraId();

        Integer channelNum = cmd.getChanNo();

        if (!GlobalVariable.loginMap.containsKey(cameraId)) {

            return "";

        }

        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);

        NET_DVR_WORKSTATE_V30 devwork = new NET_DVR_WORKSTATE_V30();

        if (!hCNetSDK.NET_DVR_GetDVRWorkState_V30(userId, devwork)) {

            // 返回Boolean值，判断是否获取设备能力

            log.error("抓图失败，请稍后重试");

        }

        //图片质量

        NET_DVR_JPEGPARA jpeg = new NET_DVR_JPEGPARA();

        //设置图片分辨率

        jpeg.wPicSize = 0;

        //设置图片质量

        jpeg.wPicQuality = 0;

        IntByReference a = new IntByReference();

        //设置图片大小

        ByteBuffer jpegBuffer = ByteBuffer.allocate(1024 * 1024);

        // 抓图到内存，单帧数据捕获并保存成JPEG存放在指定的内存空间中

        boolean is = hCNetSDK.NET_DVR_CaptureJPEGPicture_NEW(userId, channelNum, jpeg, jpegBuffer, 1024 * 1024, a);

        log.debug("-----------这里开始图片存入内存----------" + is);



        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.debug("-----------处理完成截图数据----------");

        return png_base64;

    }



    /**

     * @描述 截图 存服务器

     * @参数 [cameraId, channelNum]

     * @返回值 java.lang.String

     * @创建人 刘苏义

     * @创建时间 2023/2/2 14:59

     * @修改人和其它信息

     */

    @Override

    public String picCutCate(CameraCmd cmd) {

        String cameraId = cmd.getCameraId();

        Integer channelNum = cmd.getChanNo();

        if (!GlobalVariable.loginMap.containsKey(cameraId)) {

            return "";

        }

        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);

        //图片信息

        NET_DVR_JPEGPARA jpeg = new NET_DVR_JPEGPARA();

        //设置图片分辨率

        //图片尺寸：0-CIF(352*288/352*240)，1-QCIF(176*144/176*120)，2-4CIF(704*576/704*480)或D1(720*576/720*486)，3-UXGA(1600*1200)，

        // 4-SVGA(800*600)，5-HD720P(1280*720)，6-VGA(640*480)，7-XVGA(1280*960)，8-HD900P(1600*900)，9-HD1080P(1920*1080)，10-2560*1920，

        // 11-1600*304，12-2048*1536，13-2448*2048，14-2448*1200，15-2448*800，16-XGA(1024*768)，17-SXGA(1280*1024)，18-WD1(960*576/960*480),

        // 19-1080I(1920*1080)，20-576*576，21-1536*1536，22-1920*1920，23-320*240，24-720*720，25-1024*768，26-1280*1280，27-1600*600，

        // 28-2048*768，29-160*120，75-336*256，78-384*256，79-384*216，80-320*256，82-320*192，83-512*384，127-480*272，128-512*272， 161-288*320，

        // 162-144*176，163-480*640，164-240*320，165-120*160，166-576*720，167-720*1280，168-576*960，180-180*240, 181-360*480, 182-540*720,

        // 183-720*960, 184-960*1280, 185-1080*1440, 500-384*288, 0xff-Auto(使用当前码流分辨率)

        jpeg.wPicSize = 0;

        //设置图片质量：0-最好，1-较好，2-一般

        jpeg.wPicQuality = 0;

        IntByReference a = new IntByReference();

        //设置图片大小

        ByteBuffer jpegBuffer = ByteBuffer.allocate(1024 * 1024);

        // 抓图到内存，单帧数据捕获并保存成JPEG存放在指定的内存空间中

        log.debug("-----------这里开始封装 NET_DVR_CaptureJPEGPicture_NEW---------");

        boolean is = hCNetSDK.NET_DVR_CaptureJPEGPicture_NEW(userId, channelNum, jpeg, jpegBuffer, 1024 * 1024, a);

        log.debug("-----------这里开始图片存入内存----------" + is);

        if (is) {

            log.debug("hksdk(抓图)-结果状态值(0表示成功):" + hCNetSDK.NET_DVR_GetLastError());

            byte[] array = jpegBuffer.array();

            //存储到minio

            String BucketName = "pic";

            String ObjectName = "capture/" + IdUtils.simpleUUID() + ".jpeg";

            InputStream input = new ByteArrayInputStream(array);

            String url = "";

            try {

                boolean b = MinioUtil.uploadObject(BucketName, ObjectName, input, input.available(), MimeTypeUtils.IMAGE_JPEG);

                if (b) {

                    url = MinioUtil.getBucketObjectUrl(BucketName, ObjectName);

                    log.debug("上传文件成功!" + url);

                }

            } catch (IOException ex) {

                log.error("上传文件异常：" + ex.getMessage());

            }

            return url;

        } else {

            int code = hCNetSDK.NET_DVR_GetLastError();

            log.error("抓图失败,请稍后重试" + code);

            return "";

        }

    }



    /**

     * @描述 短时录像

     * @参数 [userId, channelNum, enable]

     * @返回值 void

     * @创建人 刘苏义

     * @创建时间 2023/1/20 11:18

     * @修改人和其它信息

     */

    @Override

    public String record(CameraCmd cmd) {

        try {

            String cameraId = cmd.getCameraId();

            Integer channelNum = cmd.getChanNo();

            String path = FileUtils.createFile("D:/recordTemp/" + cameraId + ".mp4");

            boolean enable = cmd.isEnable();

            if (!GlobalVariable.loginMap.containsKey(cameraId)) {

                return "";

            }

            Integer userId = (Integer) 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();

            String url = "";

            if (enable) {

                if (!GlobalVariable.previewMap.containsKey(cameraId)) {

                    int lRealHandle = hCNetSDK.NET_DVR_RealPlay_V40(userId, previewinfo, null, null);

                    if (lRealHandle == -1) {

                        log.error("取流失败" + hCNetSDK.NET_DVR_GetLastError());

                        return "";

                    }

                    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.debug("录像开始");

            } else {

                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 = "record";

                String ObjectName = IdUtils.simpleUUID() + ".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 boolean recordStart(CameraCmd cmd) {

        try {

            String cameraId = cmd.getCameraId();

            Integer channelNum = cmd.getChanNo();

            String path = FileUtils.createFile("D:/recordTemp/" + cameraId + ".mp4");

            if (!GlobalVariable.loginMap.containsKey(cameraId)) {

                return false;

            }

            Integer userId = (Integer) 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("停止当前录像");

            }

            int lRealHandle = hCNetSDK.NET_DVR_RealPlay_V40(userId, previewinfo, null, null);

            if (lRealHandle == -1) {

                log.error("取流失败" + hCNetSDK.NET_DVR_GetLastError());

                return false;

            }

            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 false;

            }

            log.debug("录像开始");

            return true;

        } catch (Exception ex) {

            log.error("开始录像异常" + ex.getMessage());

            return false;

        }

    }



    @Override

    public String recordStopToMinio(CameraCmd cmd) {

        String url = "";

        try {

            String cameraId = cmd.getCameraId();

            Integer channelNum = cmd.getChanNo();

            String path = FileUtils.createFile("D:/recordTemp/" + cameraId + ".mp4");

            if (!GlobalVariable.loginMap.containsKey(cameraId)) {

                return "";

            }

            Integer userId = (Integer) 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 boolean recordStopNotToMinio(CameraCmd cmd) {

        boolean result = false;

        try {

            String cameraId = cmd.getCameraId();

            Integer channelNum = cmd.getChanNo();

            if (!GlobalVariable.loginMap.containsKey(cameraId)) {

                return false;

            }

            Integer userId = (Integer) 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("录像停止");

            result = true;

        } catch (Exception ex) {

            log.error("录像停止异常" + ex.getMessage());

            result = false;

        }

        return result;

    }



    //获取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());

        }

        return channelList;

    }



    /**

     * @描述 获取GIS信息数据

     * @参数 [userId, channelNum]

     * @返回值 boolean

     * @创建人 刘苏义

     * @创建时间 2023/1/17 16:36

     * @修改人和其它信息 0-解锁 1-锁定

     */

    @Override

    public Map<String, Object> getGisInfo(CameraCmd cmd) {

        String cameraId = cmd.getCameraId();

        Integer channelNum = cmd.getChanNo();

        if (!GlobalVariable.loginMap.containsKey(cameraId)) {

            return new HashMap<>();

        }

        // 获取参数

        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);

        HCNetSDK.NET_DVR_STD_CONFIG struStdCfg = new HCNetSDK.NET_DVR_STD_CONFIG();

        HCNetSDK.NET_DVR_GIS_INFO struGisInfo = new HCNetSDK.NET_DVR_GIS_INFO();

        struStdCfg.read();

        IntByReference lchannel = new IntByReference(channelNum);

        struStdCfg.lpCondBuffer = lchannel.getPointer();

        struStdCfg.dwCondSize = 4;

        struStdCfg.lpOutBuffer = struGisInfo.getPointer();

        struStdCfg.dwOutSize = struGisInfo.size();

        struStdCfg.write();//设置前之前要write()

        boolean bool = hCNetSDK.NET_DVR_GetSTDConfig(userId, NET_DVR_GET_GISINFO, struStdCfg);

        if (!bool) {

            int code = hCNetSDK.NET_DVR_GetLastError();

            log.error("获取GIS信息数据失败,请稍后重试" + code);

            return new HashMap<>();

        } else {

            struGisInfo.read();

            Map<String, Object> map = new HashMap<>();

            map.put("p", struGisInfo.struPtzPos.fPanPos);

            map.put("t", struGisInfo.struPtzPos.fTiltPos < 0 ? struGisInfo.struPtzPos.fTiltPos + 360 : struGisInfo.struPtzPos.fTiltPos);

            map.put("z", struGisInfo.struPtzPos.fZoomPos);

            map.put("fHorFieldAngle", struGisInfo.fHorizontalValue);// 水平视场角

            map.put("fVerFieldAngle", struGisInfo.fVerticalValue);// 垂直视场角

            return map;

        }

    }

}
package com.ruoyi.utils.sdk.hiksdk.service.impl;

import com.ruoyi.alarm.global.domain.GuidePriorityQueue;
import com.ruoyi.alarm.global.domain.GuideTask;
import com.ruoyi.common.annotation.SdkOperate;
import com.ruoyi.common.utils.file.FileUtils;
import com.ruoyi.common.utils.file.MimeTypeUtils;
import com.ruoyi.common.utils.uuid.IdUtils;
import com.ruoyi.device.camera.service.IArdCamerasService;
import com.ruoyi.device.camera.strategy.SdkStrategy;
import com.ruoyi.device.camera.domain.ArdCameras;
import com.ruoyi.device.camera.domain.CameraCmd;
import com.ruoyi.device.channel.domain.ArdChannel;
import com.ruoyi.device.channel.service.IArdChannelService;
import com.ruoyi.media.domain.Vtdu;
import com.ruoyi.media.service.IVtduService;
import com.ruoyi.utils.gis.GisUtil;
import com.ruoyi.utils.minio.MinioUtil;
import com.ruoyi.utils.sdk.common.GlobalVariable;
import com.ruoyi.utils.sdk.hiksdk.lib.ExceptionCallBack;
import com.ruoyi.utils.sdk.hiksdk.lib.HCNetSDK;
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.stereotype.Service;

import javax.annotation.Resource;
import java.io.*;
import java.math.BigDecimal;
import java.nio.ByteBuffer;
import java.text.DecimalFormat;
import java.util.*;
import java.util.concurrent.PriorityBlockingQueue;

import static com.ruoyi.utils.sdk.hiksdk.lib.HCNetSDK.*;
import static com.ruoyi.utils.sdk.hiksdk.lib.HCNetSDK.NET_DVR_GET_GISINFO;

/**
 * @Description: 海康sdk策略
 * @ClassName: DhSdkStrategy
 * @Author: 刘苏义
 * @Date: 2023年11月07日10:51:09
 **/
@Service
@Slf4j(topic = "hikSdk")
public class HikSdkStrategy implements SdkStrategy {
    @Resource
    private IArdCamerasService ardCamerasService;
    @Resource
    private IArdChannelService ardChannelService;
    @Resource
    private IVtduService vtduService;

    public static HCNetSDK hCNetSDK = HCNetSDK.hCNetSDK;
    private static HCNetSDK.FExceptionCallBack fExceptionCallBack;//异常回调

    /**
     * @描述 注册登录 只支持同步登陆，且官方不建议直接在此接口下写耗时操作
     * @参数 [dvrLogin]
     * @返回值 java.lang.Integer
     * @创建人 刘苏义
     * @创建时间 2023/1/17 16:12
     * @修改人和其它信息
     */
    @Override
    public boolean login(ArdCameras camera) {
        try {
            // 初始化
            if (!hCNetSDK.NET_DVR_Init()) {
                log.error("SDK初始化失败");
            }
            //打印海康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 {
                hCNetSDK.NET_DVR_SetLogToFile(3, "/home/ardLog/hiklog", true);
            }
            String m_sDeviceIP = camera.getIp();
            String m_sUsername = camera.getUsername();
            String m_sPassword = camera.getPassword();
            short m_sPort = camera.getPort().shortValue();
            //设置连接时间与重连时间
            hCNetSDK.NET_DVR_SetConnectTime(2000, 1);
            hCNetSDK.NET_DVR_SetReconnect(5000, true);
            //设备信息, 输出参数
            HCNetSDK.NET_DVR_DEVICEINFO_V40 m_strDeviceInfo = new HCNetSDK.NET_DVR_DEVICEINFO_V40();
            HCNetSDK.NET_DVR_USER_LOGIN_INFO m_strLoginInfo = new HCNetSDK.NET_DVR_USER_LOGIN_INFO();

            // 注册设备-登录参数，包括设备地址、登录用户、密码等
            m_strLoginInfo.sDeviceAddress = new byte[HCNetSDK.NET_DVR_DEV_ADDRESS_MAX_LEN];
            System.arraycopy(m_sDeviceIP.getBytes(), 0, m_strLoginInfo.sDeviceAddress, 0, m_sDeviceIP.length());
            m_strLoginInfo.sUserName = new byte[HCNetSDK.NET_DVR_LOGIN_USERNAME_MAX_LEN];
            System.arraycopy(m_sUsername.getBytes(), 0, m_strLoginInfo.sUserName, 0, m_sUsername.length());
            m_strLoginInfo.sPassword = new byte[HCNetSDK.NET_DVR_LOGIN_PASSWD_MAX_LEN];
            System.arraycopy(m_sPassword.getBytes(), 0, m_strLoginInfo.sPassword, 0, m_sPassword.length());
            m_strLoginInfo.wPort = m_sPort;
            m_strLoginInfo.byVerifyMode = 0;
            m_strLoginInfo.byLoginMode = 0;
            //是否异步登录：0- 否，1- 是  windowsSDK里是true和false
            m_strLoginInfo.bUseAsynLogin = false;
            m_strLoginInfo.write();
            //同步登录
            int lUserID = hCNetSDK.NET_DVR_Login_V40(m_strLoginInfo, m_strDeviceInfo);
            if (lUserID < 0) {
                log.debug("Login Failed [ " + camera.getIp() + ":" + camera.getPort() + " ],错误码：" + hCNetSDK.NET_DVR_GetLastError());
                camera.setChanNum(0);
                camera.setLoginId(-1);
                camera.setState("0");
                //删除管理通道
                ardChannelService.deleteArdChannelByDeviceId(camera.getId());
                ardCamerasService.updateArdCameras(camera);
                return false;
            }

            log.debug("Login Success [ " + camera.getIp() + ":" + camera.getPort() + " ]");
            if (fExceptionCallBack == null) {
                fExceptionCallBack = new ExceptionCallBack();//异常回调
                //设置异常回调函数(可在回调函数中获取设备上下线状态等)
                if (!hCNetSDK.NET_DVR_SetExceptionCallBack_V30(0, 0, fExceptionCallBack, null)) {
                    log.debug("Set fExceptionCallBack function fail");
                    return false;
                } else {
                    log.debug("Set fExceptionCallBack function successfully!");
                }
            }

            if (GlobalVariable.loginMap.containsKey(camera.getId())) {
                GlobalVariable.loginMap.remove(camera.getId());
            }

            //删除管理通道
            ardChannelService.deleteArdChannelByDeviceId(camera.getId());
            GlobalVariable.loginMap.put(camera.getId(), lUserID);
            GlobalVariable.loginCameraMap.put(lUserID, camera);

            camera.setLoginId(lUserID);
            camera.setState("1");
            camera.setChanNum((int) m_strDeviceInfo.struDeviceV30.byChanNum);
            camera.setStartDChan((int) m_strDeviceInfo.struDeviceV30.byStartDChan);
            ardCamerasService.updateArdCameras(camera);
            //获取最新通道
            List<ArdChannel> cameraChannelList = getCameraChannelList(camera);
            if (cameraChannelList.size() > 0) {
                for (ArdChannel channel : cameraChannelList) {
                    channel.setId(IdUtils.simpleUUID());
                    ardChannelService.insertArdChannel(channel);
                }
                //添加到流媒体
                for (ArdChannel channel : cameraChannelList) {
                    String name = camera.getId() + "_" + channel.getChanNo();
                    String rtspSource = "rtsp://" + camera.getUsername() + ":" + camera.getPassword() + "@" + camera.getIp() + ":" + camera.getRtspPort() + "/h264/ch" + channel.getChanNo() + "/main/av_stream";
                    Vtdu vtdu = vtduService.selectVtduByName(name);
                    if (vtdu != null) {
                        vtduService.deleteVtduByName(name);
                    }
                    //添加到流媒体
                    vtdu = new Vtdu();
                    vtdu.setRtspSource(rtspSource);
                    vtdu.setName(camera.getId() + "_" + channel.getChanNo());
                    CameraCmd cmd = new CameraCmd(camera.getId(), channel.getChanNo());
                    Map<String, Object> videoCompressionCfg = getVideoCompressionCfg(cmd);
                    if (videoCompressionCfg.get("videoEncType").equals("标准h264")) {
                        vtdu.setIsCode("0");//默认不转码
                    } else {
                        vtdu.setIsCode("1");//默认转码
                    }
                    vtdu.setMode("1");//默认CPU软解码
                    vtdu.setCameraId(camera.getId());
                    vtduService.insertVtdu(vtdu);
                }
            }
            //创建引导队列
            if (!GuidePriorityQueue.cameraQueueMap.containsKey(camera.getId())) {
                Comparator<GuideTask> comparator = GuidePriorityQueue.getComparator();
                PriorityBlockingQueue<GuideTask> priorityQueue = new PriorityBlockingQueue<>(1000, comparator);
                GuidePriorityQueue.cameraQueueMap.put(camera.getId(), priorityQueue);
            }

        } catch (Exception ex) {
            log.error("注册设备异常", ex);
        }
        return true;
    }

    /**
     * @描述 注册登录 集成于NET_DVR_Login_V30，支持同步和异步登录
     * @参数 [dvrLogin]
     * @返回值 java.lang.Integer
     * @创建人 刘苏义
     * @创建时间 2023/1/17 16:12
     * @修改人和其它信息
     */
    @Override
    @Async("loginExecutor")
    public void asyncLogin(ArdCameras camera) {
        try {
            // 初始化
            if (!hCNetSDK.NET_DVR_Init()) {
                log.error("SDK初始化失败");
            }
            //打印海康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 {
                hCNetSDK.NET_DVR_SetLogToFile(3, "/home/ardLog/hiklog", true);
            }
            String m_sDeviceIP = camera.getIp();
            String m_sUsername = camera.getUsername();
            String m_sPassword = camera.getPassword();
            short m_sPort = camera.getPort().shortValue();
            //设置连接时间与重连时间
            hCNetSDK.NET_DVR_SetConnectTime(2000, 1);
            hCNetSDK.NET_DVR_SetReconnect(5000, true);
            //设备信息, 输出参数
            HCNetSDK.NET_DVR_DEVICEINFO_V40 m_strDeviceInfo = new HCNetSDK.NET_DVR_DEVICEINFO_V40();
            HCNetSDK.NET_DVR_USER_LOGIN_INFO m_strLoginInfo = new HCNetSDK.NET_DVR_USER_LOGIN_INFO();

            // 注册设备-登录参数，包括设备地址、登录用户、密码等
            m_strLoginInfo.sDeviceAddress = new byte[HCNetSDK.NET_DVR_DEV_ADDRESS_MAX_LEN];
            System.arraycopy(m_sDeviceIP.getBytes(), 0, m_strLoginInfo.sDeviceAddress, 0, m_sDeviceIP.length());
            m_strLoginInfo.sUserName = new byte[HCNetSDK.NET_DVR_LOGIN_USERNAME_MAX_LEN];
            System.arraycopy(m_sUsername.getBytes(), 0, m_strLoginInfo.sUserName, 0, m_sUsername.length());
            m_strLoginInfo.sPassword = new byte[HCNetSDK.NET_DVR_LOGIN_PASSWD_MAX_LEN];
            System.arraycopy(m_sPassword.getBytes(), 0, m_strLoginInfo.sPassword, 0, m_sPassword.length());
            m_strLoginInfo.wPort = m_sPort;
            m_strLoginInfo.byVerifyMode = 0;
            m_strLoginInfo.byLoginMode = 0;
            //是否异步登录：0- 否，1- 是  windowsSDK里是true和false
            m_strLoginInfo.bUseAsynLogin = false;
            m_strLoginInfo.write();
            //同步登录
            int lUserID = hCNetSDK.NET_DVR_Login_V40(m_strLoginInfo, m_strDeviceInfo);
            if (lUserID < 0) {
                log.debug("Login Failed [ " + camera.getIp() + ":" + camera.getPort() + " ],错误码：" + hCNetSDK.NET_DVR_GetLastError());
                camera.setChanNum(0);
                camera.setLoginId(-1);
                camera.setState("0");
                //删除管理通道
                ardChannelService.deleteArdChannelByDeviceId(camera.getId());
                ardCamerasService.updateArdCameras(camera);
                return ;
            }

            log.debug("Login Success [ " + camera.getIp() + ":" + camera.getPort() + " ]");
            if (fExceptionCallBack == null) {
                fExceptionCallBack = new ExceptionCallBack();//异常回调
                //设置异常回调函数(可在回调函数中获取设备上下线状态等)
                if (!hCNetSDK.NET_DVR_SetExceptionCallBack_V30(0, 0, fExceptionCallBack, null)) {
                    log.debug("Set fExceptionCallBack function fail");
                    return ;
                } else {
                    log.debug("Set fExceptionCallBack function successfully!");
                }
            }

            if (GlobalVariable.loginMap.containsKey(camera.getId())) {
                GlobalVariable.loginMap.remove(camera.getId());
            }

            //删除管理通道
            ardChannelService.deleteArdChannelByDeviceId(camera.getId());
            GlobalVariable.loginMap.put(camera.getId(), lUserID);
            GlobalVariable.loginCameraMap.put(lUserID, camera);

            camera.setLoginId(lUserID);
            camera.setState("1");
            camera.setChanNum((int) m_strDeviceInfo.struDeviceV30.byChanNum);
            camera.setStartDChan((int) m_strDeviceInfo.struDeviceV30.byStartDChan);
            ardCamerasService.updateArdCameras(camera);
            //获取最新通道
            List<ArdChannel> cameraChannelList = getCameraChannelList(camera);
            if (cameraChannelList.size() > 0) {
                for (ArdChannel channel : cameraChannelList) {
                    channel.setId(IdUtils.simpleUUID());
                    ardChannelService.insertArdChannel(channel);
                }
                //添加到流媒体
                for (ArdChannel channel : cameraChannelList) {
                    String name = camera.getId() + "_" + channel.getChanNo();
                    String rtspSource = "rtsp://" + camera.getUsername() + ":" + camera.getPassword() + "@" + camera.getIp() + ":" + camera.getRtspPort() + "/h264/ch" + channel.getChanNo() + "/main/av_stream";
                    Vtdu vtdu = vtduService.selectVtduByName(name);
                    if (vtdu != null) {
                        vtduService.deleteVtduByName(name);
                    }
                    //添加到流媒体
                    vtdu = new Vtdu();
                    vtdu.setRtspSource(rtspSource);
                    vtdu.setName(camera.getId() + "_" + channel.getChanNo());
                    CameraCmd cmd = new CameraCmd(camera.getId(), channel.getChanNo());
                    Map<String, Object> videoCompressionCfg = getVideoCompressionCfg(cmd);
                    if (videoCompressionCfg.get("videoEncType").equals("标准h264")) {
                        vtdu.setIsCode("0");//默认不转码
                    } else {
                        vtdu.setIsCode("1");//默认转码
                    }
                    vtdu.setMode("1");//默认CPU软解码
                    vtdu.setCameraId(camera.getId());
                    vtduService.insertVtdu(vtdu);
                }
            }
            //创建引导队列
            if (!GuidePriorityQueue.cameraQueueMap.containsKey(camera.getId())) {
                Comparator<GuideTask> comparator = GuidePriorityQueue.getComparator();
                PriorityBlockingQueue<GuideTask> priorityQueue = new PriorityBlockingQueue<>(1000, comparator);
                GuidePriorityQueue.cameraQueueMap.put(camera.getId(), priorityQueue);
            }

        } catch (Exception ex) {
            log.error("注册设备异常", ex);
        }
    }

    /**
     * @描述 注销登录
     * @参数 [dvrLogin]
     * @返回值 java.lang.Integer
     * @创建人 刘苏义
     * @创建时间 2023/1/17 16:12
     * @修改人和其它信息
     */
    @Override
    public boolean logout(String cameraId) {
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
            return false;
        }
        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);
        boolean b = hCNetSDK.NET_DVR_Logout(userId);
        if (b) {
            GlobalVariable.loginMap.remove(cameraId);
        }
        return b;
    }

    /**
     * 是否在线
     *
     * @param cmd 相机命令
     */
    @Override
    public boolean isOnLine(CameraCmd cmd) {
        try {
            String cameraId = cmd.getCameraId();
            if (!GlobalVariable.loginMap.containsKey(cameraId)) {
                return false;
            }
            Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);
            return hCNetSDK.NET_DVR_RemoteControl(userId, NET_DVR_CHECK_USER_STATUS, null, 0);
        } catch (Exception ex) {
            log.error("检测在线异常：" + ex.getMessage());
            return false;
        }
    }

    /**
     * @描述 带速度的云台控制操作
     * Code:1-左上 2-上 3-右上 4-左 5-巡航 6-右 7-左下 8-下 9-右下 10-焦距变大 11-焦距变小
     * 12-焦点前调 13-焦点后调 14-光圈扩大 15-光圈缩小 16-雨刷开启
     * @参数 [userId, channelNum, speed]
     * @返回值 boolean
     * @创建人 刘苏义
     * @创建时间 2023/1/17 16:14
     * @修改人和其它信息
     */
    @Override
    public boolean pTZControl(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        boolean enable = cmd.isEnable();
        Integer channelNum = cmd.getChanNo();
        Integer speed = cmd.getSpeed();
        Integer code = cmd.getCode();
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
            return false;
        }
        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);
        int dwStop;
        if (enable) {
            dwStop = 0;//开启
        } else {
            dwStop = 1;//关闭
        }
        int dwPTZCommand = -1;
        switch (code) {
            /*方向*/
            case 1:
                dwPTZCommand = HCNetSDK.UP_LEFT;
                break;
            case 2:
                dwPTZCommand = HCNetSDK.TILT_UP;
                break;
            case 3:
                dwPTZCommand = HCNetSDK.UP_RIGHT;
                break;
            case 4:
                dwPTZCommand = HCNetSDK.PAN_LEFT;
                break;
            case 5:
                dwPTZCommand = HCNetSDK.RUN_SEQ;
                break;
            case 6:
                dwPTZCommand = HCNetSDK.PAN_RIGHT;
                break;
            case 7:
                dwPTZCommand = HCNetSDK.DOWN_LEFT;
                break;
            case 8:
                dwPTZCommand = HCNetSDK.TILT_DOWN;
                break;
            case 9:
                dwPTZCommand = HCNetSDK.DOWN_RIGHT;
                break;
            /*焦距*/
            case 10:
                dwPTZCommand = HCNetSDK.ZOOM_IN;
                break;
            case 11:
                dwPTZCommand = HCNetSDK.ZOOM_OUT;
                break;
            /*焦点*/
            case 12:
                dwPTZCommand = HCNetSDK.FOCUS_NEAR;
                break;
            case 13:
                dwPTZCommand = HCNetSDK.FOCUS_FAR;
                break;
            /*光圈*/
            case 14:
                dwPTZCommand = HCNetSDK.IRIS_OPEN;
                break;
            case 15:
                dwPTZCommand = HCNetSDK.IRIS_CLOSE;
                break;
            /*雨刷*/
            case 16:
                dwPTZCommand = HCNetSDK.WIPER_PWRON;
                break;
        }
        boolean bool = hCNetSDK.NET_DVR_PTZControlWithSpeed_Other(userId, channelNum, dwPTZCommand, dwStop, speed);
        if (!bool) {
            int errorCode = hCNetSDK.NET_DVR_GetLastError();
            log.error("控制失败,请稍后重试" + errorCode);
        }
        return bool;
    }

    /**
     * 设置聚焦值
     *
     * @param cmd 相机命令
     */
    @Override
    public boolean setFocusPos(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        Integer channelNum = cmd.getChanNo();
        Integer dwFocusPos = cmd.getDwFocusPos();
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
            return false;
        }
        // 获取参数
        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);
        HCNetSDK.NET_DVR_STD_CONFIG struStdCfg = new HCNetSDK.NET_DVR_STD_CONFIG();
        HCNetSDK.NET_DVR_GIS_INFO struGisInfo = new HCNetSDK.NET_DVR_GIS_INFO();
        struGisInfo.struPtzPosEx.dwFocus = dwFocusPos;
        struStdCfg.read();
        IntByReference lchannel = new IntByReference(channelNum);
        struStdCfg.lpInBuffer = struGisInfo.getPointer();
        struStdCfg.lpCondBuffer = lchannel.getPointer();
        struStdCfg.dwCondSize = 4;
        struStdCfg.dwInSize = struGisInfo.size();
        struStdCfg.write();//设置前之前要write()
        boolean bool = hCNetSDK.NET_DVR_SetSTDConfig(userId, NET_DVR_GET_GISINFO, struStdCfg);
        if (!bool) {
            int code = hCNetSDK.NET_DVR_GetLastError();
            log.error("设置GIS信息数据失败,请稍后重试" + code);
            return false;
        } else {
            return true;
        }
    }

    /**
     * 获取聚焦值
     *
     * @param cmd 相机命令
     */
    @Override
    public int getFocusPos(CameraCmd cmd) {
        int result = 0;
        String cameraId = cmd.getCameraId();
        Integer channelNum = cmd.getChanNo();
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
            return result;
        }
        // 获取参数
        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);
        HCNetSDK.NET_DVR_STD_CONFIG struStdCfg = new HCNetSDK.NET_DVR_STD_CONFIG();
        HCNetSDK.NET_DVR_GIS_INFO struGisInfo = new HCNetSDK.NET_DVR_GIS_INFO();
        struStdCfg.read();
        IntByReference lchannel = new IntByReference(channelNum);
        struStdCfg.lpCondBuffer = lchannel.getPointer();
        struStdCfg.dwCondSize = 4;
        struStdCfg.lpOutBuffer = struGisInfo.getPointer();
        struStdCfg.dwOutSize = struGisInfo.size();
        struStdCfg.write();//设置前之前要write()
        boolean bool = hCNetSDK.NET_DVR_GetSTDConfig(userId, NET_DVR_GET_GISINFO, struStdCfg);
        if (!bool) {
            int code = hCNetSDK.NET_DVR_GetLastError();
            log.error("获取GIS信息数据失败,请稍后重试" + code);
            return result;
        } else {
            struGisInfo.read();
            result = struGisInfo.struPtzPosEx.dwFocus;
        }
        return result;
    }

    /**
     * 设置预置点
     *
     * @param cmd 相机命令
     */
    @Override
    public boolean setPreset(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        Integer channelNum = cmd.getChanNo();
        Integer PresetIndex = cmd.getPresetIndex();
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
            return false;
        }
        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);
        boolean bool = hCNetSDK.NET_DVR_PTZPreset_Other(userId, channelNum, SET_PRESET, PresetIndex);
        if (!bool) {
            int code = hCNetSDK.NET_DVR_GetLastError();
            log.error("预置点设置失败,请稍后重试" + code);
        }
        return bool;
    }

    /**
     * 转到预置点
     *
     * @param cmd 相机命令
     */
    @Override
    public boolean gotoPreset(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        Integer channelNum = cmd.getChanNo();
        Integer PresetIndex = cmd.getPresetIndex();
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
            return false;
        }
        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);
        boolean bool = hCNetSDK.NET_DVR_PTZPreset_Other(userId, channelNum, GOTO_PRESET, PresetIndex);
        if (!bool) {
            int code = hCNetSDK.NET_DVR_GetLastError();
            log.error("预置点设置失败,请稍后重试" + code);
        }
        return bool;
    }

    /**
     * @描述 获取通道压缩参数
     * @参数 [cameraId, channelNum]
     * @返回值 java.lang.String
     * @创建人 刘苏义
     * @创建时间 2023/2/3 8:36
     * @修改人和其它信息
     */
    @Override
    public Map<String, Object> getVideoCompressionCfg(CameraCmd cmd) {

        Map<String, Object> map = new HashMap<>();
        try {
            String cameraId = cmd.getCameraId();
            Integer chanNo = cmd.getChanNo();
            if (!GlobalVariable.loginMap.containsKey(cameraId)) {
                return null;
            }
            Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);

            NET_DVR_COMPRESSIONCFG_V30 compressioncfg = new NET_DVR_COMPRESSIONCFG_V30();
            compressioncfg.write();
            Pointer pioint = compressioncfg.getPointer();
            IntByReference ibrBytesReturned = new IntByReference(0);

            boolean bool = hCNetSDK.NET_DVR_GetDVRConfig(userId, HCNetSDK.NET_DVR_GET_COMPRESSCFG_V30, chanNo, pioint, compressioncfg.size(), ibrBytesReturned);
            if (bool) {
                compressioncfg.read();
                //码流类型：0-视频流，1-复合流，0xfe- 自动（和源一致）
                String streamType = "";
                switch (compressioncfg.struNormHighRecordPara.byStreamType) {
                    case 0:
                        streamType = "视频流";
                        break;
                    case 1:
                        streamType = "复合流";
                        break;
                    default:
                        streamType = "未知";
                        break;
                }
                //视频编码类型：0-私有264，1-标准h264，2-标准mpeg4，7-M-JPEG，8-MPEG2，9-SVAC，10-标准h265，0xfe- 自动（和源一致），0xff-无效
                String videoEncType = "";
                switch (compressioncfg.struNormHighRecordPara.byVideoEncType) {
                    case 0:
                        videoEncType = "私有264";
                        break;
                    case 1:
                        videoEncType = "标准h264";
                        break;
                    case 2:
                        videoEncType = "标准mpeg4";
                        break;
                    case 7:
                        videoEncType = "M-JPEG";
                        break;
                    case 8:
                        videoEncType = "MPEG2";
                        break;
                    case 9:
                        videoEncType = "SVAC";
                        break;
                    case 10:
                        videoEncType = "标准h265";
                        break;
                    default:
                        videoEncType = "未知";
                        break;
                }
                //视频码率
                String videoBitrate = "";
                switch (compressioncfg.struNormHighRecordPara.dwVideoBitrate) {
                    case 0:
                        videoBitrate = "保留";
                        break;
                    case 1:
                        videoBitrate = "16(保留)";
                        break;
                    case 2:
                        videoBitrate = "32";
                        break;
                    case 3:
                        videoBitrate = "48";
                        break;
                    case 4:
                        videoBitrate = "64";
                        break;
                    case 5:
                        videoBitrate = "80";
                        break;
                    case 6:
                        videoBitrate = "96";
                        break;
                    case 7:
                        videoBitrate = "128";
                        break;
                    case 8:
                        videoBitrate = "160";
                        break;
                    case 9:
                        videoBitrate = "192";
                        break;
                    case 10:
                        videoBitrate = "224";
                        break;
                    case 11:
                        videoBitrate = "256";
                        break;
                    case 12:
                        videoBitrate = "320";
                        break;
                    case 13:
                        videoBitrate = "384";
                        break;
                    case 14:
                        videoBitrate = "448";
                        break;
                    case 15:
                        videoBitrate = "512";
                        break;
                    case 16:
                        videoBitrate = "640";
                        break;
                    case 17:
                        videoBitrate = "768";
                        break;
                    case 18:
                        videoBitrate = "896";
                        break;
                    case 19:
                        videoBitrate = "1024";
                        break;
                    case 20:
                        videoBitrate = "1280";
                        break;
                    case 21:
                        videoBitrate = "1536";
                        break;
                    case 22:
                        videoBitrate = "1792";
                        break;
                    case 23:
                        videoBitrate = "2048K";
                        break;
                    case 24:
                        videoBitrate = "3072";
                        break;
                    case 25:
                        videoBitrate = "4096";
                        break;
                    case 26:
                        videoBitrate = "8192";
                        break;
                    case 27:
                        videoBitrate = "16384";
                        break;
                    default:
                        videoBitrate = "其他";
                        break;
                }
                //视频输出口分辨率：0- 1024x768，1- 1280x720，2-1280x1024，3- 1680x1050，4- 1920x1080，5- 3840*2160
                String resolution = "";
                switch (compressioncfg.struNormHighRecordPara.byResolution) {
                    case 0:
                        resolution = "528*384/528*320";
                        break;
                    case 1:
                        resolution = "352*288/352*240";
                        break;
                    case 2:
                        resolution = "176*144/176*120";
                        break;
                    case 3:
                        resolution = "704*576/704*480";
                        break;
                    case 4:
                        resolution = "704*288/704*240";
                        break;
                    case 6:
                        resolution = "320*240";
                        break;
                    case 7:
                        resolution = "160*120";
                        break;
                    case 16:
                        resolution = "640*480";
                        break;
                    case 17:
                        resolution = "1600*1200";
                        break;
                    case 18:
                        resolution = "800*600";
                        break;
                    case 19:
                        resolution = "1280*720";
                        break;
                    case 20:
                        resolution = "1280*960";
                        break;
                    case 21:
                        resolution = "1600*900";
                        break;
                    case 22:
                        resolution = "1360*1024";
                        break;
                    case 23:
                        resolution = "1536*1536";
                        break;
                    case 24:
                        resolution = "1920*1920";
                        break;
                    case 27:
                        resolution = "1920*1080";
                        break;
                    case 28:
                        resolution = "2560*1920";
                        break;
                    case 29:
                        resolution = "1600*304";
                        break;
                    case 30:
                        resolution = "2048*1536";
                        break;
                    default:
                        resolution = "不在当前分辨率索引，请联系管理员添加";
                        break;
                }
                //帧率
                String nFrameRate = "";
                switch (compressioncfg.struNormHighRecordPara.dwVideoFrameRate) {
                    case 0:
                        nFrameRate = "0";
                        break;
                    case 1:
                        nFrameRate = "1/16";
                        break;
                    case 2:
                        nFrameRate = "1/8";
                        break;
                    case 3:
                        nFrameRate = "1/4";
                        break;
                    case 4:
                        nFrameRate = "1/2";
                        break;
                    case 5:
                        nFrameRate = "1";
                        break;
                    case 6:
                        nFrameRate = "2";
                        break;
                    case 7:
                        nFrameRate = "4";
                        break;
                    case 8:
                        nFrameRate = "6";
                        break;
                    case 9:
                        nFrameRate = "8";
                        break;
                    case 10:
                        nFrameRate = "10";
                        break;
                    case 11:
                        nFrameRate = "12";
                        break;
                    case 12:
                        nFrameRate = "16";
                        break;
                    case 13:
                        nFrameRate = "20";
                        break;
                    case 14:
                        nFrameRate = "15";
                        break;
                    case 15:
                        nFrameRate = "18";
                        break;
                    case 16:
                        nFrameRate = "22";
                        break;
                    case 17:
                        nFrameRate = "25";
                        break;
                    case 18:
                        nFrameRate = "30";
                        break;
                    case 19:
                        nFrameRate = "35";
                        break;
                    case 20:
                        nFrameRate = "40";
                        break;
                    default:
                        nFrameRate = "未知";
                        break;
                }
                map.put("resolution", resolution);//分辨率
                map.put("videoBitrate", videoBitrate);//比特率
                map.put("videoEncType", videoEncType);//编码
                map.put("nFrameRate", nFrameRate);//帧率

            } else {
                int code = hCNetSDK.NET_DVR_GetLastError();
                log.error("控制失败,请稍后重试" + code);
            }
        } catch (Exception ex) {
            log.error(ex.getMessage());
        }
        return map;
    }

    /**
     * @描述 获取ptz信息
     * @参数 [userId, channelNum]
     * @返回值 boolean
     * @创建人 刘苏义
     * @创建时间 2023/1/17 16:36
     * @修改人和其它信息
     */
    @Override
    public Map<String, Object> getPtz(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        Integer channelNum = cmd.getChanNo();
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
            return new HashMap<>();
        }
        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);

        NET_DVR_PTZPOS m_ptzPosCurrent = new NET_DVR_PTZPOS();
        Pointer pioint = m_ptzPosCurrent.getPointer();
        IntByReference ibrBytesReturned = new IntByReference(0);
        m_ptzPosCurrent.write();
        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");//设置保留位数
            //16进制转Integer后除10，保留小数点1位
            //实际显示的PTZ值是获取到的十六进制值的十分之一，
            //如获取的水平参数P的值是0x1750，实际显示的P值为175度；
            //获取到的垂直参数T的值是0x0789，实际显示的T值为78.9度；
            //获取到的变倍参数Z的值是0x1100，实际显示的Z值为110倍。
            BigDecimal b = new BigDecimal((float) Integer.parseInt(Integer.toHexString(m_ptzPosCurrent.wPanPos)) / 10);
            BigDecimal c = new BigDecimal((float) Integer.parseInt(Integer.toHexString(m_ptzPosCurrent.wTiltPos)) / 10);
            BigDecimal d = new BigDecimal((float) Integer.parseInt(Integer.toHexString(m_ptzPosCurrent.wZoomPos)) / 10);
            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);
            Map<String, Object> ptzMap = new HashMap<>();
            ptzMap.put("p", p);
            ptzMap.put("t", t);
            ptzMap.put("z", z);
            return ptzMap;
        } else {
            int code = hCNetSDK.NET_DVR_GetLastError();
            log.error("控制失败,请稍后重试" + code);
            return new HashMap<>();
        }
    }

    /**
     * @描述 设置ptz信息
     * @参数 [userId, channelNum]
     * @返回值 boolean
     * @创建人 刘苏义
     * @创建时间 2023/1/17 16:36
     * @修改人和其它信息 注意俯仰角度负值需要加上360得到的正值进行设置
     */
    @Override
    public boolean setPtz(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        Integer channelNum = cmd.getChanNo();
        Map<String, Double> ptz = cmd.getPtzMap();
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
            return false;
        }
        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);
        NET_DVR_PTZPOS m_ptzPosCurrent = new NET_DVR_PTZPOS();
        m_ptzPosCurrent.wAction = 1;
        try {
            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));
            Pointer point = m_ptzPosCurrent.getPointer();
            m_ptzPosCurrent.write();
            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.error("设置ptz失败,请稍后重试" + code);
            }
            return bool;
        } catch (Exception ex) {
            log.error(ex.getMessage());
            return false;
        }
    }

    @Override
    public boolean guideTargetPosition(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        Integer channelNum = cmd.getChanNo();
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
            return false;
        }
        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);
        NET_DVR_PTZPOS m_ptzPosCurrent = new NET_DVR_PTZPOS();
        m_ptzPosCurrent.wAction = 1;
        try {
            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);
            String p = String.valueOf((int) (cameraPTZ[0] * 10));
            String t = String.valueOf((int) (cameraPTZ[1] * 10));
            String z = String.valueOf((int) (cameraPTZ[2] * 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));
            Pointer point = m_ptzPosCurrent.getPointer();
            m_ptzPosCurrent.write();
            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.error("设置ptz失败,请稍后重试" + code);
            }
            return bool;
        } catch (Exception ex) {
            log.error("引导异常:" + ex.getMessage());
            return false;
        }
    }


    /**
     * @描述 获取ptz锁定信息
     * @参数 [userId, channelNum]
     * @返回值 boolean
     * @创建人 刘苏义
     * @创建时间 2023/1/17 16:36
     * @修改人和其它信息 0-解锁 1-锁定
     */
    public int getPTZLockInfo(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        Integer channelNum = cmd.getChanNo();
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
            return -1;
        }
        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);
        NET_DVR_PTZ_LOCKCFG netDvrPtzLockcfg = new NET_DVR_PTZ_LOCKCFG();
        Pointer point = netDvrPtzLockcfg.getPointer();
        IntByReference ibrBytesReturned = new IntByReference(0);
        netDvrPtzLockcfg.write();
        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.error("获取ptz锁定信息失败,请稍后重试" + code);
            return -1;
        } else {
            netDvrPtzLockcfg.read();
            return netDvrPtzLockcfg.byWorkMode;
        }
    }

    /**
     * @描述 设置零方位角
     * @参数 [userId, channelNum]
     * @返回值 boolean
     * @创建人 刘苏义
     * @创建时间 2023/1/17 16:36
     * @修改人和其它信息 注意俯仰角度负值需要加上360得到的正值进行设置
     */
    @Override
    public boolean setZeroPtz(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        Integer channelNum = cmd.getChanNo();
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
            return false;
        }
        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);
        NET_DVR_INITIALPOSITIONCTRL initialpositionctrl = new NET_DVR_INITIALPOSITIONCTRL();

        initialpositionctrl.dwSize = initialpositionctrl.size();
        initialpositionctrl.byWorkMode = 0;
        initialpositionctrl.dwChan = Short.parseShort(channelNum.toString());

        Pointer point = initialpositionctrl.getPointer();
        initialpositionctrl.write();
        boolean bool = hCNetSDK.NET_DVR_RemoteControl(userId, NET_DVR_PTZ_INITIALPOSITIONCTRL, point, initialpositionctrl.size());
        if (!bool) {
            int i = hCNetSDK.NET_DVR_GetLastError();
            log.error("错误码：" + i);
        }
        return bool;
    }

    /**
     * @描述 获取球机PTZ参数取值范围
     * @参数 [cameraId, channelNum]
     * @返回值 java.util.Map<java.lang.String, java.lang.Object>
     * @创建人 刘苏义
     * @创建时间 2023/2/8 10:58
     * @修改人和其它信息
     */
    @Override
    public Map<String, Object> getPtzScope(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        Integer channelNum = cmd.getChanNo();
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
            return new HashMap<>();
        }
        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);
        NET_DVR_PTZSCOPE m_ptzPosCurrent = new NET_DVR_PTZSCOPE();
        Pointer point = m_ptzPosCurrent.getPointer();
        IntByReference ibrBytesReturned = new IntByReference(0);
        m_ptzPosCurrent.write();
        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.error("设置ptz失败,请稍后重试" + code);
            return new HashMap<>();
        } else {
            m_ptzPosCurrent.read();
            DecimalFormat df = new DecimalFormat("0.0");//设置保留位数

            String wPanPosMax = df.format((float) Integer.parseInt(Integer.toHexString(m_ptzPosCurrent.wPanPosMax)) / 10);
            String wPanPosMin = df.format((float) Integer.parseInt(Integer.toHexString(m_ptzPosCurrent.wTiltPosMax)) / 10);
            String wTiltPosMax = df.format((float) Integer.parseInt(Integer.toHexString(m_ptzPosCurrent.wTiltPosMax)) / 10);
            String wTiltPosMin = df.format((float) Integer.parseInt(Integer.toHexString(m_ptzPosCurrent.wTiltPosMin)) / 10);
            String wZoomPosMax = df.format((float) Integer.parseInt(Integer.toHexString(m_ptzPosCurrent.wZoomPosMax)) / 10);
            String wZoomPosMin = df.format((float) Integer.parseInt(Integer.toHexString(m_ptzPosCurrent.wZoomPosMin)) / 10);
            Map<String, Object> ptzScopeMap = new HashMap<>();
            ptzScopeMap.put("pMax", wPanPosMax);
            ptzScopeMap.put("pMin", wPanPosMin);
            ptzScopeMap.put("tMax", wTiltPosMax);
            ptzScopeMap.put("tMin", wTiltPosMin);
            ptzScopeMap.put("zMax", wZoomPosMax);
            ptzScopeMap.put("zMin", wZoomPosMin);
            return ptzScopeMap;
        }

    }

    /**
     * @描述 透雾开关
     * @参数 [userId, channelNum, enable]
     * @返回值 boolean
     * @创建人 刘苏义
     * @创建时间 2023/1/18 13:07
     * @修改人和其它信息
     */
    @Override
    public boolean controlDefogcfg(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        boolean enable = cmd.isEnable();
        Integer channelNum = cmd.getChanNo();
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
            return false;
        }
        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);
        NET_DVR_CAMERAPARAMCFG_EX struCameraParam = new NET_DVR_CAMERAPARAMCFG_EX();
        Pointer point = struCameraParam.getPointer();
        IntByReference ibrBytesReturned = new IntByReference(0);
        boolean b_GetCameraParam = hCNetSDK.NET_DVR_GetDVRConfig(userId, NET_DVR_GET_CCDPARAMCFG_EX, channelNum, point, struCameraParam.size(), ibrBytesReturned);
        if (!b_GetCameraParam) {
            log.error("获取前端参数失败，错误码：" + hCNetSDK.NET_DVR_GetLastError());
        }
        struCameraParam.read();
        log.debug("是否开启透雾：" + struCameraParam.struDefogCfg.byMode);

        NET_DVR_DEFOGCFG defogcfg = new NET_DVR_DEFOGCFG();
        if (enable) {
            defogcfg.byMode = 2;//0-不启用 1-自动模式 2-常开模式
            defogcfg.byLevel = 100;//取值范围0-100
        } else {
            defogcfg.byMode = 0;//0-不启用 1-自动模式 2-常开模式
        }
        struCameraParam.struDefogCfg = defogcfg;
        struCameraParam.write();
        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.error("设置透雾失败,请稍后重试" + code);
        }
        log.debug("设置透雾成功");
        return bool;
    }

    /**
     * @描述 红外开关
     * @参数 [userId, channelNum, enable]
     * @返回值 boolean
     * @创建人 刘苏义
     * @创建时间 2023/1/18 13:07
     * @修改人和其它信息
     */
    @Override
    public boolean controlInfrarecfg(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        boolean enable = cmd.isEnable();
        Integer chanNo = cmd.getChanNo();
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
            return false;
        }
        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);
        NET_DVR_CAMERAPARAMCFG_EX struDayNigh = new NET_DVR_CAMERAPARAMCFG_EX();
        Pointer point = struDayNigh.getPointer();
        IntByReference ibrBytesReturned = new IntByReference(0);
        boolean b_GetCameraParam = hCNetSDK.NET_DVR_GetDVRConfig(userId, NET_DVR_GET_CCDPARAMCFG_EX, chanNo, point, struDayNigh.size(), ibrBytesReturned);
        if (!b_GetCameraParam) {
            log.error("获取前端参数失败，错误码：" + hCNetSDK.NET_DVR_GetLastError());
        }
        struDayNigh.read();
        String current = struDayNigh.struDayNight.byDayNightFilterType == 1 ? "开启" : "关闭";
        log.debug("当前状态:" + current);

        NET_DVR_DAYNIGHT daynight = new NET_DVR_DAYNIGHT();
        if (enable) {
            daynight.byDayNightFilterType = 1;//夜晚
        } else {
            daynight.byDayNightFilterType = 0;//白天
        }
        daynight.bySwitchScheduleEnabled = 1;
        daynight.byDayNightFilterTime = 60;
        struDayNigh.struDayNight = daynight;
        struDayNigh.write();
        boolean bool = hCNetSDK.NET_DVR_SetDVRConfig(userId, NET_DVR_SET_CCDPARAMCFG_EX, chanNo, point, struDayNigh.size());
        if (!bool) {
            int code = hCNetSDK.NET_DVR_GetLastError();
            log.error("设置夜视失败,请稍后重试" + code);
        }
        else {
            log.debug("设置夜视成功");
        }

        return bool;
    }

    /**
     * @描述 聚焦开关
     * @参数 [userId, channelNum, enable]
     * @返回值 boolean
     * @创建人 刘苏义
     * @创建时间 2023/1/18 13:07
     * @修改人和其它信息
     */
    @Override
    public boolean controlFocusMode(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        boolean enable = cmd.isEnable();
        Integer channelNum = cmd.getChanNo();
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
            return false;
        }
        Integer userId = (Integer) 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);

        if (enable) {
            struFocusMode.byFocusMode = 1;//手动聚焦
        } else {
            struFocusMode.byAutoFocusMode = 1;
            struFocusMode.byFocusMode = 2;//自动聚焦
        }
        struFocusMode.byFocusDefinitionDisplay = 1;
        struFocusMode.byFocusSpeedLevel = 3;
        struFocusMode.write();
        boolean bool = hCNetSDK.NET_DVR_SetDVRConfig(userId, NET_DVR_SET_FOCUSMODECFG, channelNum, point, struFocusMode.size());
        if (!bool) {
            int code = hCNetSDK.NET_DVR_GetLastError();
            log.error("设置聚焦模式失败,请稍后重试" + code);
        }
        log.debug("设置聚焦模式成功");
        return bool;
    }

    /**
     * @描述 获取聚焦模式
     * @参数 [userId, channelNum]
     * @返回值 boolean
     * @创建人 刘苏义
     * @创建时间 2023/1/18 13:07
     * @修改人和其它信息
     */
    public String getFocusMode(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        Integer channelNum = cmd.getChanNo();
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
            return "";
        }
        Integer userId = (Integer) 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);
    }

    /**
     * @描述 云台加热开关
     * @参数 [userId, channelNum, enable]
     * @返回值 boolean
     * @创建人 刘苏义
     * @创建时间 2023/1/18 13:07
     * @修改人和其它信息
     */
    @Override
    public boolean controlPTHeateRpwron(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        boolean enable = cmd.isEnable();
        Integer channelNum = cmd.getChanNo();
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
            return false;
        }
        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);
        int dwStop;
        if (enable) {
            dwStop = 0;//开启
        } else {
            dwStop = 1;//关闭
        }
        boolean bool = hCNetSDK.NET_DVR_PTZControl_Other(userId, channelNum, HEATER_PWRON, dwStop);
        if (!bool) {
            int code = hCNetSDK.NET_DVR_GetLastError();
            log.error("设置云台加热失败,请稍后重试" + code);
        }
        log.debug("设置云台加热成功");
        return bool;
    }

    /**
     * @描述 镜头加热开关
     * @参数 [userId, channelNum, enable]
     * @返回值 boolean
     * @创建人 刘苏义
     * @创建时间 2023/1/18 13:07
     * @修改人和其它信息
     */
    @Override
    public boolean controlCameraDeicing(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        boolean enable = cmd.isEnable();
        Integer channelNum = cmd.getChanNo();
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
            return false;
        }
        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);
        NET_DVR_DEVSERVER_CFG struDeicing = new NET_DVR_DEVSERVER_CFG();
        Pointer point = struDeicing.getPointer();
        IntByReference ibrBytesReturned = new IntByReference(0);
        boolean b_GetCameraParam = hCNetSDK.NET_DVR_GetDVRConfig(userId, NET_DVR_GET_DEVSERVER_CFG, channelNum, point, struDeicing.size(), ibrBytesReturned);
        if (!b_GetCameraParam) {
            log.error("获取前端参数失败，错误码：" + hCNetSDK.NET_DVR_GetLastError());
        }
        struDeicing.read();
        log.debug("是否开启除冰：" + struDeicing.byEnableDeicing);

        if (enable) {
            struDeicing.byEnableDeicing = 1;//开启
        } else {
            struDeicing.byEnableDeicing = 0;//关闭
        }
        struDeicing.write();
        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.error("设置镜头除冰失败,请稍后重试" + code);
        }
        log.debug("设置镜头除冰成功");
        return bool;
    }

    /**
     * 截图 返给前端
     *
     * @param cmd 相机命令
     */
    public String captureJPEGPicture(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        Integer channelNum = cmd.getChanNo();
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
            return "";
        }
        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);
        NET_DVR_WORKSTATE_V30 devwork = new NET_DVR_WORKSTATE_V30();
        if (!hCNetSDK.NET_DVR_GetDVRWorkState_V30(userId, devwork)) {
            // 返回Boolean值，判断是否获取设备能力
            log.error("抓图失败，请稍后重试");
        }
        //图片质量
        NET_DVR_JPEGPARA jpeg = new NET_DVR_JPEGPARA();
        //设置图片分辨率
        jpeg.wPicSize = 0;
        //设置图片质量
        jpeg.wPicQuality = 0;
        IntByReference a = new IntByReference();
        //设置图片大小
        ByteBuffer jpegBuffer = ByteBuffer.allocate(1024 * 1024);
        // 抓图到内存，单帧数据捕获并保存成JPEG存放在指定的内存空间中
        boolean is = hCNetSDK.NET_DVR_CaptureJPEGPicture_NEW(userId, channelNum, jpeg, jpegBuffer, 1024 * 1024, a);
        log.debug("-----------这里开始图片存入内存----------" + is);

        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.debug("-----------处理完成截图数据----------");
        return png_base64;
    }

    /**
     * @描述 截图 存服务器
     * @参数 [cameraId, channelNum]
     * @返回值 java.lang.String
     * @创建人 刘苏义
     * @创建时间 2023/2/2 14:59
     * @修改人和其它信息
     */
    @Override
    public String picCutCate(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        Integer channelNum = cmd.getChanNo();
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
            return "";
        }
        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);
        //图片信息
        NET_DVR_JPEGPARA jpeg = new NET_DVR_JPEGPARA();
        //设置图片分辨率
        //图片尺寸：0-CIF(352*288/352*240)，1-QCIF(176*144/176*120)，2-4CIF(704*576/704*480)或D1(720*576/720*486)，3-UXGA(1600*1200)，
        // 4-SVGA(800*600)，5-HD720P(1280*720)，6-VGA(640*480)，7-XVGA(1280*960)，8-HD900P(1600*900)，9-HD1080P(1920*1080)，10-2560*1920，
        // 11-1600*304，12-2048*1536，13-2448*2048，14-2448*1200，15-2448*800，16-XGA(1024*768)，17-SXGA(1280*1024)，18-WD1(960*576/960*480),
        // 19-1080I(1920*1080)，20-576*576，21-1536*1536，22-1920*1920，23-320*240，24-720*720，25-1024*768，26-1280*1280，27-1600*600，
        // 28-2048*768，29-160*120，75-336*256，78-384*256，79-384*216，80-320*256，82-320*192，83-512*384，127-480*272，128-512*272， 161-288*320，
        // 162-144*176，163-480*640，164-240*320，165-120*160，166-576*720，167-720*1280，168-576*960，180-180*240, 181-360*480, 182-540*720,
        // 183-720*960, 184-960*1280, 185-1080*1440, 500-384*288, 0xff-Auto(使用当前码流分辨率)
        jpeg.wPicSize = 0;
        //设置图片质量：0-最好，1-较好，2-一般
        jpeg.wPicQuality = 0;
        IntByReference a = new IntByReference();
        //设置图片大小
        ByteBuffer jpegBuffer = ByteBuffer.allocate(1024 * 1024);
        // 抓图到内存，单帧数据捕获并保存成JPEG存放在指定的内存空间中
        log.debug("-----------这里开始封装 NET_DVR_CaptureJPEGPicture_NEW---------");
        boolean is = hCNetSDK.NET_DVR_CaptureJPEGPicture_NEW(userId, channelNum, jpeg, jpegBuffer, 1024 * 1024, a);
        log.debug("-----------这里开始图片存入内存----------" + is);
        if (is) {
            log.debug("hksdk(抓图)-结果状态值(0表示成功):" + hCNetSDK.NET_DVR_GetLastError());
            byte[] array = jpegBuffer.array();
            //存储到minio
            String BucketName = "pic";
            String ObjectName = "capture/" + IdUtils.simpleUUID() + ".jpeg";
            InputStream input = new ByteArrayInputStream(array);
            String url = "";
            try {
                boolean b = MinioUtil.uploadObject(BucketName, ObjectName, input, input.available(), MimeTypeUtils.IMAGE_JPEG);
                if (b) {
                    url = MinioUtil.getBucketObjectUrl(BucketName, ObjectName);
                    log.debug("上传文件成功!" + url);
                }
            } catch (IOException ex) {
                log.error("上传文件异常：" + ex.getMessage());
            }
            return url;
        } else {
            int code = hCNetSDK.NET_DVR_GetLastError();
            log.error("抓图失败,请稍后重试" + code);
            return "";
        }
    }

    /**
     * @描述 短时录像
     * @参数 [userId, channelNum, enable]
     * @返回值 void
     * @创建人 刘苏义
     * @创建时间 2023/1/20 11:18
     * @修改人和其它信息
     */
    @Override
    public String record(CameraCmd cmd) {
        try {
            String cameraId = cmd.getCameraId();
            Integer channelNum = cmd.getChanNo();
            String path = FileUtils.createFile("D:/recordTemp/" + cameraId + ".mp4");
            boolean enable = cmd.isEnable();
            if (!GlobalVariable.loginMap.containsKey(cameraId)) {
                return "";
            }
            Integer userId = (Integer) 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();
            String url = "";
            if (enable) {
                if (!GlobalVariable.previewMap.containsKey(cameraId)) {
                    int lRealHandle = hCNetSDK.NET_DVR_RealPlay_V40(userId, previewinfo, null, null);
                    if (lRealHandle == -1) {
                        log.error("取流失败" + hCNetSDK.NET_DVR_GetLastError());
                        return "";
                    }
                    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.debug("录像开始");
            } else {
                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 = "record";
                String ObjectName = IdUtils.simpleUUID() + ".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 boolean recordStart(CameraCmd cmd) {
        try {
            String cameraId = cmd.getCameraId();
            Integer channelNum = cmd.getChanNo();
            String path = FileUtils.createFile("D:/recordTemp/" + cameraId + ".mp4");
            if (!GlobalVariable.loginMap.containsKey(cameraId)) {
                return false;
            }
            Integer userId = (Integer) 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("停止当前录像");
            }
            int lRealHandle = hCNetSDK.NET_DVR_RealPlay_V40(userId, previewinfo, null, null);
            if (lRealHandle == -1) {
                log.error("取流失败" + hCNetSDK.NET_DVR_GetLastError());
                return false;
            }
            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 false;
            }
            log.debug("录像开始");
            return true;
        } catch (Exception ex) {
            log.error("开始录像异常" + ex.getMessage());
            return false;
        }
    }

    @Override
    public String recordStopToMinio(CameraCmd cmd) {
        String url = "";
        try {
            String cameraId = cmd.getCameraId();
            Integer channelNum = cmd.getChanNo();
            String path = FileUtils.createFile("D:/recordTemp/" + cameraId + ".mp4");
            if (!GlobalVariable.loginMap.containsKey(cameraId)) {
                return "";
            }
            Integer userId = (Integer) 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 boolean recordStopNotToMinio(CameraCmd cmd) {
        boolean result = false;
        try {
            String cameraId = cmd.getCameraId();
            Integer channelNum = cmd.getChanNo();
            if (!GlobalVariable.loginMap.containsKey(cameraId)) {
                return false;
            }
            Integer userId = (Integer) 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("录像停止");
            result = true;
        } catch (Exception ex) {
            log.error("录像停止异常" + ex.getMessage());
            result = false;
        }
        return result;
    }

    //获取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());
        }
        return channelList;
    }

    /**
     * @描述 获取GIS信息数据
     * @参数 [userId, channelNum]
     * @返回值 boolean
     * @创建人 刘苏义
     * @创建时间 2023/1/17 16:36
     * @修改人和其它信息 0-解锁 1-锁定
     */
    @Override
    public Map<String, Object> getGisInfo(CameraCmd cmd) {
        String cameraId = cmd.getCameraId();
        Integer channelNum = cmd.getChanNo();
        if (!GlobalVariable.loginMap.containsKey(cameraId)) {
            return new HashMap<>();
        }
        // 获取参数
        Integer userId = (Integer) GlobalVariable.loginMap.get(cameraId);
        HCNetSDK.NET_DVR_STD_CONFIG struStdCfg = new HCNetSDK.NET_DVR_STD_CONFIG();
        HCNetSDK.NET_DVR_GIS_INFO struGisInfo = new HCNetSDK.NET_DVR_GIS_INFO();
        struStdCfg.read();
        IntByReference lchannel = new IntByReference(channelNum);
        struStdCfg.lpCondBuffer = lchannel.getPointer();
        struStdCfg.dwCondSize = 4;
        struStdCfg.lpOutBuffer = struGisInfo.getPointer();
        struStdCfg.dwOutSize = struGisInfo.size();
        struStdCfg.write();//设置前之前要write()
        boolean bool = hCNetSDK.NET_DVR_GetSTDConfig(userId, NET_DVR_GET_GISINFO, struStdCfg);
        if (!bool) {
            int code = hCNetSDK.NET_DVR_GetLastError();
            log.error("获取GIS信息数据失败,请稍后重试" + code);
            return new HashMap<>();
        } else {
            struGisInfo.read();
            Map<String, Object> map = new HashMap<>();
            map.put("p", struGisInfo.struPtzPos.fPanPos);
            map.put("t", struGisInfo.struPtzPos.fTiltPos < 0 ? struGisInfo.struPtzPos.fTiltPos + 360 : struGisInfo.struPtzPos.fTiltPos);
            map.put("z", struGisInfo.struPtzPos.fZoomPos);
            map.put("fHorFieldAngle", struGisInfo.fHorizontalValue);// 水平视场角
            map.put("fVerFieldAngle", struGisInfo.fVerticalValue);// 垂直视场角
            return map;
        }
    }
}

 ruoyi-common/src/main/java/com/ruoyi/common/filter/MyI18nInterceptor.java

@@ -17,7 +17,7 @@
        final String key = "language";
        String language = "en_US";//request.getHeader(key);
        // 前端传递的language必须是zh-CN格式的，中间的-必须要完整，不能只传递zh或en
        log.info("当前语言={}",language);
        log.debug("当前语言={}",language);
        Locale locale = new Locale(language.split("_")[0],language.split("_")[1]);
        // 这样赋值以后，MessageUtils.message方法就不用修改了
        LocaleContextHolder.setLocale(locale);

 ruoyi-quartz/src/main/java/com/ruoyi/quartz/task/SyncTask.java

@@ -1,25 +1,20 @@
package com.ruoyi.quartz.task;



import com.alibaba.fastjson2.JSONObject;



import com.ruoyi.common.core.domain.entity.SysUser;

import com.ruoyi.device.camera.domain.ArdCameras;

import com.ruoyi.device.camera.domain.CameraCmd;

import com.ruoyi.device.camera.service.IArdCamerasService;

import com.ruoyi.device.channel.domain.ArdChannel;

import com.ruoyi.utils.sdk.dhsdk.service.IDhClientService;

import com.ruoyi.utils.sdk.hiksdk.service.IHikClientService;

import com.ruoyi.media.domain.Items;

import com.ruoyi.media.domain.JsonsRoot;

import com.ruoyi.media.domain.Vtdu;

import com.ruoyi.media.service.IMediaService;

import com.ruoyi.media.service.IVtduService;

import com.ruoyi.rongcloud.service.RongCloudService;

import com.ruoyi.system.service.ISysUserService;

import com.ruoyi.utils.sdk.dhsdk.service.impl.DhSdkStrategy;

import com.ruoyi.utils.sdk.hiksdk.service.impl.HikSdkStrategy;

import lombok.extern.slf4j.Slf4j;

import org.springframework.stereotype.Component;



import javax.annotation.Resource;

import java.util.ArrayList;

import java.util.List;



/**

@@ -38,9 +33,9 @@
    @Resource

    IArdCamerasService iArdCamerasService;

    @Resource

    IHikClientService hikClientService;

    HikSdkStrategy hikClientService;

    @Resource

    IDhClientService dhClientService;

    DhSdkStrategy dhClientService;

    @Resource

    IVtduService vtduService;

    @Resource