增加海康SDK，整理自动抬干业务逻辑

jiazx0107@163.com

2023-07-05 a195948e2f1db9d413194f7d33c93cca6a796ca8

增加海康SDK，整理自动抬干业务逻辑

 igds-core/src/main/java/com/ld/igds/inout/InoutApiConstant.java

@@ -11,63 +11,63 @@
    /**
     * ç™»è®°å¤„车牌识别-1001
     */
    public static String DEVICE_CODE_1001 = "1001";
    public static int DEVICE_CODE_1001 = 1001;
    /**
     * ç™»è®°å¤„道闸-2001
     */
    public static String DEVICE_CODE_2001 = "2001";
    public static int DEVICE_CODE_2001 = 2001;
    /**
     * åœ°ç£…入口车牌识别-1002
     */
    public static String DEVICE_CODE_1002 = "1002";
    public static int DEVICE_CODE_1002 = 1002;
    /**
     * åœ°ç£…出口车牌识别-1003
     */
    public static String DEVICE_CODE_1003 = "1003";
    public static int DEVICE_CODE_1003 = 1003;
    /**
     * åœ°ç£…入口闸机-2002
     */
    public static String DEVICE_CODE_2002 = "2002";
    public static int DEVICE_CODE_2002 = 2002;
    /**
     * åœ°ç£…出口闸机-2003
     */
    public static String DEVICE_CODE_2003 = "2003";
    public static int DEVICE_CODE_2003 = 2003;
    /**
     * åœ°ç£…处光栅1-3001
     */
    public static String DEVICE_CODE_3001 = "3001";
    public static int DEVICE_CODE_3001 = 3001;
    /**
     * åœ°ç£…处光栅2-3002
     */
    public static String DEVICE_CODE_3002 = "3002";
    public static int DEVICE_CODE_3002 = 3002;
    /**
     * åœ°ç£…入口高频读卡器-4001
     */
    public static String DEVICE_CODE_4001 = "4001";
    public static int DEVICE_CODE_4001 = 4001;
    /**
     * åœ°ç£…出口高频读卡器-4002
     */
    public static String DEVICE_CODE_4002 = "4002";
    public static int DEVICE_CODE_4002 = 4002;
    /**
     * åœ°ç£…处身份证读卡器=5001
     */
    public static String DEVICE_CODE_5001 = "5001";
    public static int DEVICE_CODE_5001 = 5001;
    /**
     * åœ°ç£…处LED大屏-6001
     */
    public static String DEVICE_CODE_6001 = "6001";
    public static int DEVICE_CODE_6001 = 6001;
    /**
     * åœ°ç£…入口红绿灯-7001
     */
    public static String DEVICE_CODE_7001 = "7001";
    public static int DEVICE_CODE_7001 = 7001;
    /**
     * åœ°ç£…出口红绿灯-7002
     */
    public static String DEVICE_CODE_7002 = "7002";
    public static int DEVICE_CODE_7002 = 7002;
    /**
     * åœ°ç£…处广播设备-8001
     */
    public static String DEVICE_CODE_8001 = "8001";
    public static int DEVICE_CODE_8001 = 8001;

    /**
     * è®¾å¤‡æ“ä½œ-关闭，红绿灯表示 çº¢ç¯

 igds-core/src/main/java/com/ld/igds/inout/dto/ApiInoutData.java

@@ -90,7 +90,7 @@
    private String actionCode;

    //设备编号
    private String deviceId;
    private int deviceCode;


    public ApiInoutData() {
@@ -117,5 +117,6 @@
        this.snapType = conf.getSnapType();
        this.mediaAddr = conf.getMediaAddr();
        this.errorMsg = conf.getErrorMsg();
        this.deviceCode = conf.getInOrder();
    }
}

 igds-core/src/main/java/com/ld/igds/io/constant/ProtocolEnum.java

@@ -32,6 +32,8 @@
    TCP_BHZH_VERB_V2("TCP_BHZH_VERB_V2", "邦海控制柜智能有线版V2"),
    TCP_BHZH_INOUT_V1("TCP_BHZH_INOUT_V1", "邦海智能出入库控制器协议"),
    FZZY_OPENAPI_HTTP("FZZY_OPENAPI_HTTP", "风正致远API-HTTP协议");


    private String code;
    private String msg;


 igds-inout/src/main/java/com/ld/igds/inout/controller/InoutController.java

@@ -289,6 +289,8 @@
        if (null != conf) conf.setSort(sort);
        view.addObject("cardDto", conf);

        //称重页面初始化
        inoutManager.initInoutWeight(listInoutConf,sort);

        view.setViewName("admin/inout/in-weight");
        return view;

 igds-inout/src/main/java/com/ld/igds/inout/manager/InoutEventControlManager.java

@@ -400,6 +400,69 @@
        return null;
    }


    /**
     * è¢«åŠ¨æ”¶åˆ°è½¦ç‰Œè¯†åˆ«ç»“果，事件
     *
     * @param data
     */
    @Async
    public void onReceivePlateNum(ApiInoutData data) {

        InoutConf conf = this.getInoutConfBySn(data.getCompanyId(), data.getDeptId(), data.getSn());

        if (null == conf) return;

        if (0 == conf.getInOrder()) return;

        data = new ApiInoutData(conf);

        ApiInoutService inoutApiService = apiInoutManager.getApiService(conf.getProtocol());

        //获取车牌信息，开闸机
        if (InoutApiConstant.DEVICE_CODE_1002 == data.getDeviceCode()) {
            //开入口处道闸
            data.setDeviceCode(InoutApiConstant.DEVICE_CODE_2002);
            data.setActionCode(InoutApiConstant.ACTION_CODE_1);

            inoutApiService.gateControl(data);
        }


        if (InoutApiConstant.DEVICE_CODE_1003 == data.getDeviceCode()) {
            //开入口处道闸
            data.setDeviceCode(InoutApiConstant.DEVICE_CODE_2003);
            data.setActionCode(InoutApiConstant.ACTION_CODE_1);

            inoutApiService.gateControl(data);
        }

    }

    /**
     * å‡ºå…¥åº“称重页面初始化，如果有SDK车牌识别，需要进行初始化操作
     *
     * @param listInoutConf
     * @param sort
     */
    @Async
    public void initInoutWeight(List<InoutConf> listInoutConf, String sort) {

        //获取车牌配置信息
        if (null == listInoutConf) return;

        ApiInoutData apiInoutData;
        ApiInoutService inoutApiService;
        for (InoutConf conf : listInoutConf) {
            if (InoutConstant.CONF_TYPE_10.equals(conf.getType()) && sort.equals(conf.getSort())) {
                apiInoutData = new ApiInoutData(conf);
                inoutApiService = apiInoutManager.getApiService(conf.getProtocol());
                inoutApiService.initLpr(apiInoutData);
            }
        }
    }


    /**
     * å‡ºå…¥åº“登记完成触发事件，默认为异步处理
     *
@@ -430,21 +493,21 @@
        //1、通知称重显示屏，设备编号6001
        ApiInoutData apiData = new ApiInoutData(conf);
        apiData.setTime(new Date());
        apiData.setDeviceId(InoutApiConstant.DEVICE_CODE_6001);
        apiData.setDeviceCode(InoutApiConstant.DEVICE_CODE_6001);
        ApiInoutService inoutApiService = apiInoutManager.getApiService(conf.getProtocol());
        inoutApiService.noticeLed(apiData, data);

        //2、语音通知
        apiData.setDeviceId(InoutApiConstant.DEVICE_CODE_8001);
        apiData.setDeviceCode(InoutApiConstant.DEVICE_CODE_8001);
        inoutApiService.noticeRadio(apiData, data);

        //3、开闸机
        if (InoutConstant.TYPE_IN.equals(data.getType())) {
            //结算重量大于0表示二次称重
            if (data.getNetWeight() > 0) {
                apiData.setDeviceId(InoutApiConstant.DEVICE_CODE_1002);
                apiData.setDeviceCode(InoutApiConstant.DEVICE_CODE_1002);
            } else {
                apiData.setDeviceId(InoutApiConstant.DEVICE_CODE_1003);
                apiData.setDeviceCode(InoutApiConstant.DEVICE_CODE_1003);
            }
            apiData.setActionCode(InoutApiConstant.ACTION_CODE_1);

@@ -452,9 +515,9 @@
        } else {
            //结算重量大于0表示二次称重
            if (data.getNetWeight() > 0) {
                apiData.setDeviceId(InoutApiConstant.DEVICE_CODE_1003);
                apiData.setDeviceCode(InoutApiConstant.DEVICE_CODE_1003);
            } else {
                apiData.setDeviceId(InoutApiConstant.DEVICE_CODE_1002);
                apiData.setDeviceCode(InoutApiConstant.DEVICE_CODE_1002);
            }
            apiData.setActionCode(InoutApiConstant.ACTION_CODE_1);
            inoutApiService.gateControl(apiData);
@@ -464,9 +527,9 @@
        if (InoutConstant.TYPE_IN.equals(data.getType())) {
            //结算重量大于0表示二次称重
            if (data.getNetWeight() > 0) {
                apiData.setDeviceId(InoutApiConstant.DEVICE_CODE_7001);
                apiData.setDeviceCode(InoutApiConstant.DEVICE_CODE_7001);
            } else {
                apiData.setDeviceId(InoutApiConstant.DEVICE_CODE_7002);
                apiData.setDeviceCode(InoutApiConstant.DEVICE_CODE_7002);
            }
            apiData.setActionCode(InoutApiConstant.ACTION_CODE_1);

@@ -474,14 +537,14 @@
        } else {
            //结算重量大于0表示二次称重
            if (data.getNetWeight() > 0) {
                apiData.setDeviceId(InoutApiConstant.DEVICE_CODE_7002);
                apiData.setDeviceCode(InoutApiConstant.DEVICE_CODE_7002);
            } else {
                apiData.setDeviceId(InoutApiConstant.DEVICE_CODE_7001);
                apiData.setDeviceCode(InoutApiConstant.DEVICE_CODE_7001);
            }
            apiData.setActionCode(InoutApiConstant.ACTION_CODE_1);
            inoutApiService.lightControl(apiData);
        }
        

    }


@@ -671,5 +734,24 @@
        return result;
    }

    private InoutConf getInoutConfBySn(String companyId, String deptId, String sn) {

        if (null == sn) return null;

        // èŽ·å–出入库配置信息
        List<InoutConf> listInoutConf = inoutCommonService.getCacheInoutConf(companyId, deptId);

        if (null == listInoutConf) return null;

        for (InoutConf conf : listInoutConf) {

            if (null == conf.getSn()) continue;

            if (sn.equals(conf.getSn())) return conf;
        }

        return null;
    }


}

 igds-inout/src/main/java/com/ld/igds/inout/manager/InoutManager.java

@@ -1021,4 +1021,8 @@
        }
    }

    public void initInoutWeight(List<InoutConf> listInoutConf,String sort) {
        inoutEventControl.initInoutWeight(listInoutConf,sort);
    }

}

 igds-protocol-sdk/pom.xml

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,98 @@
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.ld.igds</groupId>
    <artifactId>igds-protocol-sdk</artifactId>
    <version>4.0.0-RELEASE</version>
    <packaging>jar</packaging>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <java.version>1.8</java.version>
        <igds.version>4.0.0-RELEASE</igds.version>
    </properties>

    <dependencies>

        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.6</version>
        </dependency>


        <!-- å‡ºå…¥åº“模块 -->
        <dependency>
            <groupId>com.ld.igds</groupId>
            <artifactId>igds-inout</artifactId>
            <version>${igds.version}</version>
        </dependency>

        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.3.1</version>
        </dependency>

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>


        <dependency>
            <groupId>com.sun.jna</groupId>
            <artifactId>examples</artifactId>
            <version>3.0.9</version>
            <scope>system</scope>
            <systemPath>${project.basedir}/src/main/resources/lib/examples.jar</systemPath>
        </dependency>

        <!--        <dependency>-->
        <!--        <groupId>com.sun.jna</groupId>-->
        <!--        <artifactId>jna</artifactId>-->
        <!--        <version>3.0.5</version>-->
        <!--        <scope>system</scope>-->
        <!--        <systemPath>${project.basedir}/src/main/resources/lib/jna.jar</systemPath>-->
        <!--    </dependency>-->

        <dependency>
            <groupId>com.sun.jna</groupId>
            <artifactId>jna</artifactId>
            <version>3.0.9</version>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <compilerArguments>
                        <extdirs>src\main\webapp\WEB-INF\lib</extdirs>
                    </compilerArguments>
                </configuration>
            </plugin>
        </plugins>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.js</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
            </resource>
        </resources>
    </build>

</project>

 igds-protocol-sdk/src/main/java/com/ld/igds/protocol/hk/HKConstant.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,104 @@
package com.ld.igds.protocol.hk;

import com.ld.igds.constant.Constant;
import com.ld.igds.inout.dto.ApiInoutData;

import java.io.File;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

/**
 * å¸¸é‡é…ç½®
 */
public class HKConstant {

    //验证是否为历史数据 10分钟
    public static long CHECK_TIME = 30 * 60 * 1000;

    public static Map<String, ApiInoutData> contextLprMap = new HashMap<>();


    //SDK ç»å¯¹è·¯å¾„地址
    public static String SDK_DIR_WIN = "D:\\IGDS\\SDK\\hk-win64";

    //SDK ç»å¯¹è·¯å¾„地址
    public static String SDK_DIR_LINUX = "usr/app/data";


    //图片地址 -{yyyyMM} ä¸ºè¡¨è¾¾å¼
    public static String IMG_DIR_WIN = "D:\\IGDS\\INOUT\\{yyyyMM}\\";

    //图片地址 -{yyyyMM} ä¸ºè¡¨è¾¾å¼
    public static String IMG_DIR_LINUX = "usr/app/data/IGDS/INOUT/{yyyyMM}/";


    //日志目录
    public static String LOG_DIR_WIN = "D:\\IGDS\\log-hk\\";

    //日志目录
    public static String LOG_DIR_LINUX = "usr/app/data/log-hk/";


    public static String RESULT_SUCCESS = "SUCCESS";


    /**
     * èŽ·å–LOG日志目录，
     *
     * @param isLinux æ˜¯å¦Linux
     *                ç³»ç»Ÿ
     * @return
     */
    public static String getLogBasePath(boolean isLinux) {
        String base = LOG_DIR_WIN;
        if (isLinux) base = LOG_DIR_LINUX;

        File f = new File(base);
        if (!f.exists()) {
            f.mkdirs();
        }
        return base;
    }


    /**
     * èŽ·å–图片地址
     *
     * @param isLinux æ˜¯å¦Linux
     *                ç³»ç»Ÿ
     * @return
     */
    public static String getImgBasePath(boolean isLinux) {
        String base = IMG_DIR_WIN;
        if (isLinux) base = IMG_DIR_LINUX;

        SimpleDateFormat sf = new SimpleDateFormat("yyyyMMdd");
        base = base.replace("{yyyyMM}", sf.format(new Date()));

        File f = new File(base);
        if (!f.exists()) {
            f.mkdirs();
        }
        return base;
    }

    public static void updateLprMap(String sn, ApiInoutData data) {
        contextLprMap.put(sn, data);
    }

    public static void offLine(String sn) {
        ApiInoutData data = getDataBySn(sn);
        if (null == data) {
            contextLprMap.put(sn, null);
        } else {
            data.setStatus(Constant.YN_N);
        }
        updateLprMap(sn, data);
    }

    public static ApiInoutData getDataBySn(String sn) {
        return contextLprMap.get(sn);
    }
}

 igds-protocol-sdk/src/main/java/com/ld/igds/protocol/hk/HkApiInoutService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,118 @@
package com.ld.igds.protocol.hk;

import com.ld.igds.inout.ApiInoutService;
import com.ld.igds.inout.dto.ApiInoutData;
import com.ld.igds.inout.dto.InoutData;
import com.ld.igds.protocol.hk.lpr.AlarmLpr;
import com.ld.igds.constant.Constant;

import lombok.extern.slf4j.Slf4j;

import org.springframework.stereotype.Component;

/**
 * æµ·åº·è­¦å‘Šç±»åž‹è½¦ç‰Œè¯†åˆ«JDK调用
 */
@Slf4j
@Component
public class HkApiInoutService implements ApiInoutService {

    private AlarmLpr alarmLpr = new AlarmLpr();

    @Override
    public String getProtocol() {
        return "HIK_SDK";
    }

    @Override
    public ApiInoutData getIcCardNum(ApiInoutData param) {
        return null;
    }

    @Override
    public ApiInoutData getPlateNum(ApiInoutData param) {

        // èŽ·å–缓存数据
        ApiInoutData lPrData = HKConstant.getDataBySn(param.getSn());

        if (null == lPrData) {
            param.setErrorMsg("ERROR:系统未获取到当前设备信息");
            return param;
        }

        if (Constant.YN_N.equals(lPrData.getStatus())) {
            param.setErrorMsg("ERROR:当前车牌识别认证登陆失败，请重置车牌识别");
            return param;
        }

        log.info("-------------请求参数----------------------{}", param.getSn());
        if (HKConstant.RESULT_SUCCESS.equals(lPrData.getErrorMsg())) {
            // éªŒè¯æ—¶é—´
            if (System.currentTimeMillis() - lPrData.getTime().getTime() < HKConstant.CHECK_TIME) {
                param.setPlateNum(lPrData.getPlateNum());
            } else {
                param.setErrorMsg("未识别到车牌，请重新尝试");
            }
            param.setPlateNum(lPrData.getPlateNum());
        } else {
            param.setErrorMsg(lPrData.getErrorMsg());
        }
        return param;
    }

    @Override
    public String initLpr(ApiInoutData param) {

        try {
            String msg = alarmLpr.initSdk();

            log.info("--------初始化HK-SDK-------{}", msg);

            Thread.sleep(500);

            ApiInoutData cacheData = HKConstant.getDataBySn(param.getSn());

            if (null != cacheData && Constant.YN_Y.equals(cacheData.getStatus())) {
                return null;
            }

            // ç™»é™†
            msg = alarmLpr.login(param.getDeviceCode(), param.getIp(), param.getPort(), param.getLoginId(), param.getPwd());

            if (HKConstant.RESULT_SUCCESS.equals(msg)) {
                param.setStatus(Constant.YN_Y);
            } else {
                param.setStatus(Constant.YN_N);
            }
            param.setErrorMsg(msg);
            HKConstant.updateLprMap(param.getSn(), param);

            return msg;

        } catch (Exception e) {
            log.error("----------------初始化车牌识别执行识别----------------------");
        }

        return null;
    }

    @Override
    public String gateControl(ApiInoutData param) {
        return null;
    }

    @Override
    public String lightControl(ApiInoutData param) {
        return null;
    }

    @Override
    public String noticeRadio(ApiInoutData param, InoutData data) {
        return null;
    }

    @Override
    public String noticeLed(ApiInoutData param, InoutData data) {
        return null;
    }
}

 igds-protocol-sdk/src/main/java/com/ld/igds/protocol/hk/common/Alarm.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,307 @@
package com.ld.igds.protocol.hk.common;

import com.ld.igds.protocol.hk.HKConstant;
import com.sun.jna.Native;
import com.sun.jna.Pointer;

import java.util.Scanner;


public class Alarm {


    static HCNetSDK hCNetSDK = null;
    static int[] lUserID = new int[]{0, 0, 0, 0, 0};//用户句柄 å®žçŽ°å¯¹è®¾å¤‡ç™»å½•
    static int[] lAlarmHandle = new int[]{-1, -1, -1, -1, -1};//报警布防句柄
    static int[] lAlarmHandle_V50 = new int[]{-1, -1, -1, -1, -1}; //v50报警布防句柄
    static int lListenHandle = -1;//报警监听句柄
    static FMSGCallBack_V31 fMSFCallBack_V31 = null;


    /**
     * @param args
     */
    @SuppressWarnings("resource")
    public static void main(String[] args) throws InterruptedException {

        if (hCNetSDK == null) {
            if (!CreateSDKInstance()) {
                System.out.println("Load SDK fail");
                return;
            }
        }
        //linux系统建议调用以下接口加载组件库
        if (OsSelect.isLinux()) {
            HCNetSDK.BYTE_ARRAY ptrByteArray1 = new HCNetSDK.BYTE_ARRAY(256);
            HCNetSDK.BYTE_ARRAY ptrByteArray2 = new HCNetSDK.BYTE_ARRAY(256);
            //这里是库的绝对路径，请根据实际情况修改，注意改路径必须有访问权限
            // String strPath1 = System.getProperty("user.dir") + "/lib/libcrypto.so.1.1";
            // String strPath2 = System.getProperty("user.dir") + "/lib/libssl.so.1.1";

            String strPath1 = HKConstant.SDK_DIR_LINUX + "/libcrypto.so.1.1";
            String strPath2 = HKConstant.SDK_DIR_LINUX + "/libssl.so.1.1";

            System.arraycopy(strPath1.getBytes(), 0, ptrByteArray1.byValue, 0, strPath1.length());
            ptrByteArray1.write();
            hCNetSDK.NET_DVR_SetSDKInitCfg(3, ptrByteArray1.getPointer());

            System.arraycopy(strPath2.getBytes(), 0, ptrByteArray2.byValue, 0, strPath2.length());
            ptrByteArray2.write();
            hCNetSDK.NET_DVR_SetSDKInitCfg(4, ptrByteArray2.getPointer());

            //String strPathCom = System.getProperty("user.dir") + "/lib";
            String strPathCom = HKConstant.SDK_DIR_LINUX;
            HCNetSDK.NET_DVR_LOCAL_SDK_PATH struComPath = new HCNetSDK.NET_DVR_LOCAL_SDK_PATH();
            System.arraycopy(strPathCom.getBytes(), 0, struComPath.sPath, 0, strPathCom.length());
            struComPath.write();
            hCNetSDK.NET_DVR_SetSDKInitCfg(2, struComPath.getPointer());
        }

        /**初始化*/
        hCNetSDK.NET_DVR_Init();
        /**加载日志*/
        hCNetSDK.NET_DVR_SetLogToFile(3, "../sdklog", false);
        //设置报警回调函数
        if (fMSFCallBack_V31 == null) {
            fMSFCallBack_V31 = new FMSGCallBack_V31();
            Pointer pUser = null;
            if (!hCNetSDK.NET_DVR_SetDVRMessageCallBack_V31(fMSFCallBack_V31, pUser)) {
                System.out.println("设置回调函数失败!");
                return;
            } else {
                System.out.println("设置回调函数成功!");
            }
        }


        /** è®¾å¤‡ä¸Šä¼ çš„报警信息是COMM_VCA_ALARM(0x4993)类型，
         åœ¨SDK初始化之后增加调用NET_DVR_SetSDKLocalCfg(enumType为NET_DVR_LOCAL_CFG_TYPE_GENERAL)设置通用参数NET_DVR_LOCAL_GENERAL_CFG的byAlarmJsonPictureSeparate为1，
         å°†Json数据和图片数据分离上传，这样设置之后，报警布防回调函数里面接收到的报警信息类型为COMM_ISAPI_ALARM(0x6009)，
         æŠ¥è­¦ä¿¡æ¯ç»“构体为NET_DVR_ALARM_ISAPI_INFO（与设备无关，SDK封装的数据结构），更便于解析。*/
        HCNetSDK.NET_DVR_LOCAL_GENERAL_CFG struNET_DVR_LOCAL_GENERAL_CFG = new HCNetSDK.NET_DVR_LOCAL_GENERAL_CFG();
        struNET_DVR_LOCAL_GENERAL_CFG.byAlarmJsonPictureSeparate = 1;   //设置JSON透传报警数据和图片分离
        struNET_DVR_LOCAL_GENERAL_CFG.write();
        Pointer pStrNET_DVR_LOCAL_GENERAL_CFG = struNET_DVR_LOCAL_GENERAL_CFG.getPointer();
        hCNetSDK.NET_DVR_SetSDKLocalCfg(17, pStrNET_DVR_LOCAL_GENERAL_CFG);

        //Alarm.Login_V40(0, "218.21.29.30", (short) 8001, "admin", "km2039766");

        Alarm.Login_V40(2, "218.21.29.30", (short) 8002, "admin", "km2039766");

        Alarm.SetAlarm(0);

        while (true) {
            //这里加入控制台输入控制，是为了保持连接状态，当输入Y表示布防结束
            System.out.print("请选择是否撤出布防(Y/N)：");
            Scanner input = new Scanner(System.in);
            String str = input.next();
            if (str.equals("Y")) {
                break;
            }
        }
        Alarm.Logout(0);
    }


    /**
     * è®¾å¤‡ç™»å½•V40 ä¸ŽV30功能一致
     *
     * @param i    ç™»å½•è®¾å¤‡ç¼–号
     * @param ip   è®¾å¤‡IP
     * @param port SDK端口，默认设备的8000端口
     * @param user è®¾å¤‡ç”¨æˆ·å
     * @param psw  è®¾å¤‡å¯†ç 
     */
    public static void Login_V40(int i, String ip, short port, String user, String psw) {
        //注册
        HCNetSDK.NET_DVR_USER_LOGIN_INFO m_strLoginInfo = new HCNetSDK.NET_DVR_USER_LOGIN_INFO();//设备登录信息
        HCNetSDK.NET_DVR_DEVICEINFO_V40 m_strDeviceInfo = new HCNetSDK.NET_DVR_DEVICEINFO_V40();//设备信息

        String m_sDeviceIP = ip;//设备ip地址
        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());

        String m_sUsername = user;//设备用户名
        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());

        String m_sPassword = psw;//设备密码
        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 = port;
        m_strLoginInfo.bUseAsynLogin = false; //是否异步登录：0- å¦ï¼Œ1- æ˜¯
//        m_strLoginInfo.byLoginMode=1;  //ISAPI登录
        m_strLoginInfo.write();

        lUserID[i] = hCNetSDK.NET_DVR_Login_V40(m_strLoginInfo, m_strDeviceInfo);
        if (lUserID[i] == -1) {
            System.out.println("登录失败，错误码为" + hCNetSDK.NET_DVR_GetLastError());
            return;
        } else {
            System.out.println(ip + ":设备登录成功！");
            return;
        }
    }

    /**
     * è®¾å¤‡ç™»å½•V30
     *
     * @param i    ç™»å½•è®¾å¤‡ç¼–号
     * @param ip   è®¾å¤‡IP
     * @param port SDK端口，默认设备的8000端口
     * @param user è®¾å¤‡ç”¨æˆ·å
     * @param psw  è®¾å¤‡å¯†ç 
     */
    public static void Login_V30(int i, String ip, short port, String user, String psw) {
        HCNetSDK.NET_DVR_DEVICEINFO_V30 m_strDeviceInfo = new HCNetSDK.NET_DVR_DEVICEINFO_V30();
        lUserID[i] = hCNetSDK.NET_DVR_Login_V30(ip, port, user, psw, m_strDeviceInfo);
        System.out.println("UsID:" + lUserID[i]);
        if ((lUserID[i] == -1) || (lUserID[i] == 0xFFFFFFFF)) {
            System.out.println("登录失败，错误码为" + hCNetSDK.NET_DVR_GetLastError());
            return;
        } else {
            System.out.println(ip + ":设备登录成功！");
            return;
        }
    }

    /**
     * æŠ¥è­¦å¸ƒé˜²æŽ¥å£
     *
     * @param i
     */
    public static void SetAlarm(int i) {
        if (lAlarmHandle[i] < 0)//尚未布防,需要布防
        {
            //报警布防参数设置
            HCNetSDK.NET_DVR_SETUPALARM_PARAM m_strAlarmInfo = new HCNetSDK.NET_DVR_SETUPALARM_PARAM();
            m_strAlarmInfo.dwSize = m_strAlarmInfo.size();
            m_strAlarmInfo.byLevel = 1;  //布防等级 0 ä¸€çº§ï¼Œ1二级
            m_strAlarmInfo.byAlarmInfoType = 1;   // æ™ºèƒ½äº¤é€šæŠ¥è­¦ä¿¡æ¯ä¸Šä¼ ç±»åž‹ï¼š0- è€æŠ¥è­¦ä¿¡æ¯ï¼ˆNET_DVR_PLATE_RESULT），1- æ–°æŠ¥è­¦ä¿¡æ¯(NET_ITS_PLATE_RESULT)
            m_strAlarmInfo.byDeployType = 0;   //布防类型：0-客户端布防，1-实时布防
            m_strAlarmInfo.write();
            lAlarmHandle[i] = hCNetSDK.NET_DVR_SetupAlarmChan_V41(lUserID[i], m_strAlarmInfo);
            System.out.println("lAlarmHandle: " + lAlarmHandle[i]);
            if (lAlarmHandle[i] == -1) {
                System.out.println("布防失败，错误码为" + hCNetSDK.NET_DVR_GetLastError());
                return;
            } else {
                System.out.println("布防成功");
            }
        } else {
            System.out.println("设备已经布防，请先撤防！");
        }
        return;

    }


    /**
     * æŠ¥è­¦å¸ƒé˜²V50接口，功能和V41一致
     *
     * @param i
     */
    public static void setAlarm_V50(int i) {

        if (lAlarmHandle_V50[i] < 0)//尚未布防,需要布防
        {
            //报警布防参数设置
            HCNetSDK.NET_DVR_SETUPALARM_PARAM_V50 m_strAlarmInfo = new HCNetSDK.NET_DVR_SETUPALARM_PARAM_V50();
            m_strAlarmInfo.dwSize = m_strAlarmInfo.size();
            m_strAlarmInfo.byLevel = 1;  //布防等级
            m_strAlarmInfo.byAlarmInfoType = 1;   // æ™ºèƒ½äº¤é€šæŠ¥è­¦ä¿¡æ¯ä¸Šä¼ ç±»åž‹ï¼š0- è€æŠ¥è­¦ä¿¡æ¯ï¼ˆNET_DVR_PLATE_RESULT），1- æ–°æŠ¥è­¦ä¿¡æ¯(NET_ITS_PLATE_RESULT)
            m_strAlarmInfo.byDeployType = 1;   //布防类型 0：客户端布防 1：实时布防
            m_strAlarmInfo.write();
            lAlarmHandle[i] = hCNetSDK.NET_DVR_SetupAlarmChan_V50(lUserID[i], m_strAlarmInfo, Pointer.NULL, 0);
            System.out.println("lAlarmHandle: " + lAlarmHandle[i]);
            if (lAlarmHandle[i] == -1) {
                System.out.println("布防失败，错误码为" + hCNetSDK.NET_DVR_GetLastError());
                return;
            } else {
                System.out.println("布防成功");

            }

        } else {

            System.out.println("设备已经布防，请先撤防！");
        }
        return;

    }


    /**
     * å¼€å¯ç›‘听
     *
     * @param ip   ç›‘听IP
     * @param port ç›‘听端口
     */
    public static void StartListen(String ip, short port) {
        if (fMSFCallBack_V31 == null) {
            fMSFCallBack_V31 = new FMSGCallBack_V31();
        }
        lListenHandle = hCNetSDK.NET_DVR_StartListen_V30(ip, (short) port, fMSFCallBack_V31, null);
        if (lListenHandle == -1) {
            System.out.println("监听失败" + hCNetSDK.NET_DVR_GetLastError());
            return;
        } else {
            System.out.println("监听成功");
        }
    }

    /**
     * è®¾å¤‡æ³¨é”€
     *
     * @param i
     */
    public static void Logout(int i) {
        if (lAlarmHandle[i] > -1) {
            if (!hCNetSDK.NET_DVR_CloseAlarmChan(lAlarmHandle[i])) {
                System.out.println("撤防成功");
            }
        }
        if (lListenHandle > -1) {
            if (!hCNetSDK.NET_DVR_StopListen_V30(lListenHandle)) {
                System.out.println("停止监听成功");
            }
        }
        if (hCNetSDK.NET_DVR_Logout(lUserID[i])) {
            System.out.println("注销成功");
        }
        hCNetSDK.NET_DVR_Cleanup();
        return;
    }

    /**
     * åŠ¨æ€åº“加载
     *
     * @return
     */
    private static boolean CreateSDKInstance() {
        if (hCNetSDK == null) {
            synchronized (HCNetSDK.class) {
                String strDllPath = "";
                try {
                    if (OsSelect.isWindows())
                        //win系统加载库路径
                        //strDllPath = System.getProperty("user.dir") + "\\lib\\HCNetSDK.dll";

                        strDllPath = HKConstant.SDK_DIR_WIN + "\\HCNetSDK.dll";
                    else if (OsSelect.isLinux())
                        //Linux系统加载库路径
                        // strDllPath = System.getProperty("user.dir") + "/lib/libhcnetsdk.so";

                        strDllPath = HKConstant.SDK_DIR_LINUX + "/libhcnetsdk.so";

                    hCNetSDK = (HCNetSDK) Native.loadLibrary(strDllPath, HCNetSDK.class);
                } catch (Exception ex) {
                    System.out.println("loadLibrary: " + strDllPath + " Error: " + ex.getMessage());
                    return false;
                }
            }
        }
        return true;
    }
}

 igds-protocol-sdk/src/main/java/com/ld/igds/protocol/hk/common/CommonUtil.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,25 @@


package com.ld.igds.protocol.hk.common;

/**
 * @author
 * @create 2022-03-22-11:13
 */
public class CommonUtil {

    //SDK时间解析
    public static String parseTime(int time) {
        int year = (time >> 26) + 2000;
        int month = (time >> 22) & 15;
        int day = (time >> 17) & 31;
        int hour = (time >> 12) & 31;
        int min = (time >> 6) & 63;
        int second = (time >> 0) & 63;
        String sTime = year + "-" + month + "-" + day + "-" + hour + ":" + min + ":" + second;
//        System.out.println(sTime);
        return sTime;
    }


}

 igds-protocol-sdk/src/main/java/com/ld/igds/protocol/hk/common/FMSGCallBack_V31.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,1364 @@

package com.ld.igds.protocol.hk.common;

import com.ld.igds.protocol.hk.HKConstant;
import com.sun.jna.Pointer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.nio.ByteBuffer;
import java.text.SimpleDateFormat;
import java.util.Date;


public class FMSGCallBack_V31 implements HCNetSDK.FMSGCallBack_V31 {

    Logger log = LoggerFactory.getLogger(FMSGCallBack_V31.class);


    //报警信息回调函数
    public boolean invoke(int lCommand, HCNetSDK.NET_DVR_ALARMER pAlarmer, Pointer pAlarmInfo, int dwBufLen, Pointer pUser) {
        AlarmDataHandle(lCommand, pAlarmer, pAlarmInfo, dwBufLen, pUser);
        return true;
    }

    public void AlarmDataHandle(int lCommand, HCNetSDK.NET_DVR_ALARMER pAlarmer, Pointer pAlarmInfo, int dwBufLen, Pointer pUser) {
        log.warn("报警事件类型： lCommand:" + Integer.toHexString(lCommand));

        String sTime;
        String MonitoringSiteID;
        //lCommand是传的报警类型
        switch (lCommand) {

            case HCNetSDK.COMM_ITS_PLATE_RESULT://交通抓拍结果(新报警信息)
                HCNetSDK.NET_ITS_PLATE_RESULT strItsPlateResult = new HCNetSDK.NET_ITS_PLATE_RESULT();
                strItsPlateResult.write();
                Pointer pItsPlateInfo = strItsPlateResult.getPointer();
                pItsPlateInfo.write(0, pAlarmInfo.getByteArray(0, strItsPlateResult.size()), 0, strItsPlateResult.size());
                strItsPlateResult.read();
                try {
                    String sLicense = new String(strItsPlateResult.struPlateInfo.sLicense, "GBK");
                    byte VehicleType = strItsPlateResult.byVehicleType;  //0-其他车辆，1-小型车，2-大型车，3- è¡Œäººè§¦å‘，4- äºŒè½®è½¦è§¦å‘，5- ä¸‰è½®è½¦è§¦å‘，6- æœºåŠ¨è½¦è§¦å‘
                    MonitoringSiteID = new String(strItsPlateResult.byMonitoringSiteID);
                    log.warn("车牌号：" + sLicense + ":车辆类型：" + VehicleType + ":监控点编号：" + MonitoringSiteID);

                } catch (UnsupportedEncodingException e1) {
                    // TODO Auto-generated catch block
                    e1.printStackTrace();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }


                //报警图片保存，车牌，车辆图片
                for (int i = 0; i < strItsPlateResult.dwPicNum; i++) {
                    if (strItsPlateResult.struPicInfo[i].dwDataLen > 0) {
                        SimpleDateFormat sf = new SimpleDateFormat("yyyyMMddHHmmss");
                        String newName = sf.format(new Date());
                        FileOutputStream fout;
                        try {
                            // String filename = "../pic/" + newName + "_type[" + strItsPlateResult.struPicInfo[i].byType + "]_ItsPlate.jpg";

                            String basePath = HKConstant.getImgBasePath(false);

                            String filename = basePath + newName + ".jpg";

                            fout = new FileOutputStream(filename);
                            //将字节写入文件
                            long offset = 0;
                            ByteBuffer buffers = strItsPlateResult.struPicInfo[i].pBuffer.getByteBuffer(offset, strItsPlateResult.struPicInfo[i].dwDataLen);
                            byte[] bytes = new byte[strItsPlateResult.struPicInfo[i].dwDataLen];
                            buffers.rewind();
                            buffers.get(bytes);
                            fout.write(bytes);
                            fout.close();
                        } catch (FileNotFoundException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        } catch (IOException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                }
                break;
            case HCNetSDK.COMM_ALARM_TFS: //道路违章取证报警
                HCNetSDK.NET_DVR_TFS_ALARM strTfsAlarm = new HCNetSDK.NET_DVR_TFS_ALARM();
                strTfsAlarm.write();
                Pointer pTfsAlarm = strTfsAlarm.getPointer();
                pTfsAlarm.write(0, pAlarmInfo.getByteArray(0, strTfsAlarm.size()), 0, strTfsAlarm.size());
                strTfsAlarm.read();
                sTime = CommonUtil.parseTime(strTfsAlarm.dwAbsTime); //报警绝对时间
                int IllegalType = strTfsAlarm.dwIllegalType; // è¿ç« ç±»åž‹
                MonitoringSiteID = strTfsAlarm.byMonitoringSiteID.toString(); //监控点编号
                // è½¦ç‰Œä¿¡æ¯
                try {
                    String PlateInfo = "车牌号：" + new String(strTfsAlarm.struPlateInfo.sLicense, "GBK");
                    System.out.println("【道路违章取证报警】时间：" + sTime + "违章类型：" + IllegalType + "车牌信息：" + PlateInfo);
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                }
                //报警图片信息
                for (int i = 0; i < strTfsAlarm.dwPicNum; i++) {
                    if (strTfsAlarm.struPicInfo[i].dwDataLen > 0) {
                        SimpleDateFormat sf = new SimpleDateFormat("yyyyMMddHHmmss");
                        String newName = sf.format(new Date());
                        FileOutputStream fout;
                        try {
                            //  String filename = "../pic/" + newName + "_type[" + strTfsAlarm.struPicInfo[i].byType + "]_TfsPlate.jpg";
                            String filename = "D:/IGDS/pic/" + newName + "_type[" + strTfsAlarm.struPicInfo[i].byType + "]_TfsPlate.jpg";
                            fout = new FileOutputStream(filename);
                            //将字节写入文件
                            long offset = 0;
                            ByteBuffer buffers = strTfsAlarm.struPicInfo[i].pBuffer.getByteBuffer(offset, strTfsAlarm.struPicInfo[i].dwDataLen);
                            byte[] bytes = new byte[strTfsAlarm.struPicInfo[i].dwDataLen];
                            buffers.rewind();
                            buffers.get(bytes);
                            fout.write(bytes);
                            fout.close();
                        } catch (FileNotFoundException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        } catch (IOException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                }
                break;
            case HCNetSDK.COMM_ALARM_AID_V41: //道路事件检测
                HCNetSDK.NET_DVR_AID_ALARM_V41 strAIDAlarmV41 = new HCNetSDK.NET_DVR_AID_ALARM_V41();
                strAIDAlarmV41.write();
                Pointer pstrAIDAlarmV41 = strAIDAlarmV41.getPointer();
                pstrAIDAlarmV41.write(0, pAlarmInfo.getByteArray(0, strAIDAlarmV41.size()), 0, strAIDAlarmV41.size());
                strAIDAlarmV41.read();
                sTime = CommonUtil.parseTime(strAIDAlarmV41.dwAbsTime); //报警触发绝对时间
                MonitoringSiteID = strAIDAlarmV41.byMonitoringSiteID.toString(); //监控点编号
                int AIDType = strAIDAlarmV41.struAIDInfo.dwAIDType; //    äº¤é€šäº‹ä»¶ç±»åž‹
                int AIDTypeEx = strAIDAlarmV41.struAIDInfo.dwAIDTypeEx; //交通事件类型扩展
                System.out.println("【道路事件检测】" + "时间：" + sTime + "监控点：" + MonitoringSiteID + "交通事件类型：" + AIDType + "交通事件类型扩展：" + AIDTypeEx);
                //报警图片信息
                if (strAIDAlarmV41.dwPicDataLen > 0 && strAIDAlarmV41.pImage != null) {
                    SimpleDateFormat sf = new SimpleDateFormat("yyyyMMddHHmmss");
                    String newName = sf.format(new Date());
                    FileOutputStream fout;
                    try {
                        String filename = "../pic/" + newName + "_AIDalarm.jpg";
                        fout = new FileOutputStream(filename);
                        //将字节写入文件
                        long offset = 0;
                        ByteBuffer buffers = strAIDAlarmV41.pImage.getByteBuffer(offset, strAIDAlarmV41.dwPicDataLen);
                        byte[] bytes = new byte[strAIDAlarmV41.dwPicDataLen];
                        buffers.rewind();
                        buffers.get(bytes);
                        fout.write(bytes);
                        fout.close();
                    } catch (FileNotFoundException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                break;
            case HCNetSDK.COMM_ALARM_TPS_V41://交通数据统计的报警
                HCNetSDK.NET_DVR_TPS_ALARM_V41 strTPSalarmV41 = new HCNetSDK.NET_DVR_TPS_ALARM_V41();
                strTPSalarmV41.write();
                Pointer pstrTPSalarmV41 = strTPSalarmV41.getPointer();
                pstrTPSalarmV41.write(0, pAlarmInfo.getByteArray(0, strTPSalarmV41.size()), 0, strTPSalarmV41.size());
                strTPSalarmV41.read();
                sTime = CommonUtil.parseTime(strTPSalarmV41.dwAbsTime);
                MonitoringSiteID = strTPSalarmV41.byMonitoringSiteID.toString(); //监控点编号
                String StartTime = CommonUtil.parseTime(strTPSalarmV41.dwStartTime); //开始统计时间；
                String StopTime = CommonUtil.parseTime(strTPSalarmV41.dwStopTime); //结束统计时间；
                System.out.println("【交通数据统计】" + "时间：" + sTime + "监控点编号：" + MonitoringSiteID + "开始统计时间：" + StartTime + "结束统计时间：" + StopTime);
                //车道统计参数信息
                for (int i = 0; i <= HCNetSDK.MAX_TPS_RULE; i++) {
                    byte LaneNo = strTPSalarmV41.struTPSInfo.struLaneParam[i].byLaneNo; //车道号
                    byte TrafficState = strTPSalarmV41.struTPSInfo.struLaneParam[i].byTrafficState; //车道状态 0-无效，1-畅通，2-拥挤，3-堵塞
                    int TpsType = strTPSalarmV41.struTPSInfo.struLaneParam[i].dwTpsType; //数据变化类型标志，表示当前上传的统计参数中，哪些数据有效，按位区分
                    int LaneVolume = strTPSalarmV41.struTPSInfo.struLaneParam[i].dwLaneVolume; //车道流量
                    int LaneVelocity = strTPSalarmV41.struTPSInfo.struLaneParam[i].dwLaneVelocity; //车道平均速度
                    float SpaceOccupyRation = strTPSalarmV41.struTPSInfo.struLaneParam[i].fSpaceOccupyRation;  //车道占有率，百分比计算（空间上，车辆长度与监控路段总长度的比值)
                    System.out.println("车道号：" + LaneNo + "车道状态：" + TrafficState + "车道流量：" + LaneVolume + "车道占有率：" + SpaceOccupyRation + "\n");
                }
                break;
            case HCNetSDK.COMM_ALARM_TPS_REAL_TIME: //实时过车数据数据
                HCNetSDK.NET_DVR_TPS_REAL_TIME_INFO netDvrTpsParam = new HCNetSDK.NET_DVR_TPS_REAL_TIME_INFO();
                netDvrTpsParam.write();
                Pointer pItsParkVehicle = netDvrTpsParam.getPointer();
                pItsParkVehicle.write(0, pAlarmInfo.getByteArray(0, netDvrTpsParam.size()), 0, netDvrTpsParam.size());
                netDvrTpsParam.read();
                String struTime = "" + String.format("%04d", netDvrTpsParam.struTime.wYear) +
                        String.format("%02d", netDvrTpsParam.struTime.byMonth) +
                        String.format("%02d", netDvrTpsParam.struTime.byDay) +
                        String.format("%02d", netDvrTpsParam.struTime.byDay) +
                        String.format("%02d", netDvrTpsParam.struTime.byHour) +
                        String.format("%02d", netDvrTpsParam.struTime.byMinute) +
                        String.format("%02d", netDvrTpsParam.struTime.bySecond);
                Short wDeviceID = new Short(netDvrTpsParam.struTPSRealTimeInfo.wDeviceID);//设备ID
                int channel = netDvrTpsParam.dwChan; //触发报警通道号
                String byLane = new String(String.valueOf(netDvrTpsParam.struTPSRealTimeInfo.byLane)).trim();// å¯¹åº”车道号
                String bySpeed = new String(String.valueOf(netDvrTpsParam.struTPSRealTimeInfo.bySpeed)).trim();// å¯¹åº”车速（KM/H)
                int dwDownwardFlow = netDvrTpsParam.struTPSRealTimeInfo.dwDownwardFlow;//当前车道 ä»Žä¸Šåˆ°ä¸‹è½¦æµé‡
                int dwUpwardFlow = netDvrTpsParam.struTPSRealTimeInfo.dwUpwardFlow;       //当前车道 ä»Žä¸‹åˆ°ä¸Šè½¦æµé‡
                System.out.println("通道号：" + channel + "; æ—¶é—´ï¼š" + struTime + ";对应车道号：" + byLane + ";当前车道 ä»Žä¸Šåˆ°ä¸‹è½¦æµé‡ï¼š" + dwDownwardFlow + ";dwUpwardFlow：" + dwUpwardFlow);
                break;

            case HCNetSDK.COMM_ALARM_TPS_STATISTICS: //统计过车数据
                HCNetSDK.NET_DVR_TPS_STATISTICS_INFO netDvrTpsStatisticsInfo = new HCNetSDK.NET_DVR_TPS_STATISTICS_INFO();
                netDvrTpsStatisticsInfo.write();
                Pointer pTpsVehicle = netDvrTpsStatisticsInfo.getPointer();
                pTpsVehicle.write(0, pAlarmInfo.getByteArray(0, netDvrTpsStatisticsInfo.size()), 0, netDvrTpsStatisticsInfo.size());
                netDvrTpsStatisticsInfo.read();
                int Tpschannel = netDvrTpsStatisticsInfo.dwChan; //触发报警通道号
                //统计开始时间
                String struStartTime = "" + String.format("%04d", netDvrTpsStatisticsInfo.struTPSStatisticsInfo.struStartTime.wYear) +
                        String.format("%02d", netDvrTpsStatisticsInfo.struTPSStatisticsInfo.struStartTime.byMonth) +
                        String.format("%02d", netDvrTpsStatisticsInfo.struTPSStatisticsInfo.struStartTime.byDay) +
                        String.format("%02d", netDvrTpsStatisticsInfo.struTPSStatisticsInfo.struStartTime.byDay) +
                        String.format("%02d", netDvrTpsStatisticsInfo.struTPSStatisticsInfo.struStartTime.byHour) +
                        String.format("%02d", netDvrTpsStatisticsInfo.struTPSStatisticsInfo.struStartTime.byMinute) +
                        String.format("%02d", netDvrTpsStatisticsInfo.struTPSStatisticsInfo.struStartTime.bySecond);
                byte TotalLaneNum = netDvrTpsStatisticsInfo.struTPSStatisticsInfo.byTotalLaneNum; //有效车道总数
                System.out.println("通道号：" + Tpschannel + "; å¼€å§‹ç»Ÿè®¡æ—¶é—´ï¼š" + struStartTime + "有效车道总数：" + TotalLaneNum);
                break;
            case HCNetSDK.COMM_ITS_PARK_VEHICLE: //停车场数据上传
                HCNetSDK.NET_ITS_PARK_VEHICLE strParkVehicle = new HCNetSDK.NET_ITS_PARK_VEHICLE();
                strParkVehicle.write();
                Pointer pstrParkVehicle = strParkVehicle.getPointer();
                pstrParkVehicle.write(0, pAlarmInfo.getByteArray(0, strParkVehicle.size()), 0, strParkVehicle.size());
                strParkVehicle.read();
                try {
                    byte ParkError = strParkVehicle.byParkError; //停车异常：0- æ­£å¸¸ï¼Œ1- å¼‚常
                    String ParkingNo = new String(strParkVehicle.byParkingNo, "UTF-8"); //车位编号
                    byte LocationStatus = strParkVehicle.byLocationStatus; //车位车辆状态 0- æ— è½¦ï¼Œ1- æœ‰è½¦
                    MonitoringSiteID = strParkVehicle.byMonitoringSiteID.toString();
                    String plateNo = new String(strParkVehicle.struPlateInfo.sLicense, "GBK"); //车牌号
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                }
                //报警图片信息
                for (int i = 0; i < strParkVehicle.dwPicNum; i++) {
                    if (strParkVehicle.struPicInfo[i].dwDataLen > 0) {
                        SimpleDateFormat sf = new SimpleDateFormat("yyyyMMddHHmmss");
                        String newName = sf.format(new Date());
                        FileOutputStream fout;
                        try {
                            String filename = "../pic/" + newName + "_ParkVehicle.jpg";
                            fout = new FileOutputStream(filename);
                            //将字节写入文件
                            long offset = 0;
                            ByteBuffer buffers = strParkVehicle.struPicInfo[i].pBuffer.getByteBuffer(offset, strParkVehicle.struPicInfo[i].dwDataLen);
                            byte[] bytes = new byte[strParkVehicle.struPicInfo[i].dwDataLen];
                            buffers.rewind();
                            buffers.get(bytes);
                            fout.write(bytes);
                            fout.close();
                        } catch (FileNotFoundException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        } catch (IOException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                }
                break;
            case HCNetSDK.COMM_ALARMHOST_CID_ALARM://报警主机CID报告报警上传
                HCNetSDK.NET_DVR_CID_ALARM strCIDalarm = new HCNetSDK.NET_DVR_CID_ALARM();
                strCIDalarm.write();
                Pointer pstrCIDalarm = strCIDalarm.getPointer();
                pstrCIDalarm.write(0, pAlarmInfo.getByteArray(0, strCIDalarm.size()), 0, strCIDalarm.size());
                strCIDalarm.read();
                try {
                    String TriggerTime = "" + String.format("%04d", strCIDalarm.struTriggerTime.wYear) +
                            String.format("%02d", strCIDalarm.struTriggerTime.byMonth) +
                            String.format("%02d", strCIDalarm.struTriggerTime.byDay) +
                            String.format("%02d", strCIDalarm.struTriggerTime.byDay) +
                            String.format("%02d", strCIDalarm.struTriggerTime.byHour) +
                            String.format("%02d", strCIDalarm.struTriggerTime.byMinute) +
                            String.format("%02d", strCIDalarm.struTriggerTime.bySecond);  //触发报警时间
                    String sCIDCode = new String(strCIDalarm.sCIDCode, "GBK"); //CID事件号
                    String sCIDDescribe = new String(strCIDalarm.sCIDDescribe, "GBK"); //CID事件名
                    byte bySubSysNo = strCIDalarm.bySubSysNo; //子系统号；
                    short wDefenceNo = strCIDalarm.wDefenceNo; //防区编号
                    System.out.println("【CID事件】" + "触发时间：" + TriggerTime + "CID事件号：" + sCIDCode + "CID事件名：" + sCIDDescribe + "子系统号：" +
                            bySubSysNo + "防区编号：" + wDefenceNo);
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                }
                break;
            case HCNetSDK.COMM_IPC_AUXALARM_RESULT: //PIR报警、无线报警、呼救报警信息
                System.out.println("PIR报警、无线报警、呼救报警触发");
                break;
            case HCNetSDK.COMM_ISAPI_ALARM: //ISAPI协议报警信息
                HCNetSDK.NET_DVR_ALARM_ISAPI_INFO struEventISAPI = new HCNetSDK.NET_DVR_ALARM_ISAPI_INFO();
                struEventISAPI.write();
                Pointer pEventISAPI = struEventISAPI.getPointer();
                pEventISAPI.write(0, pAlarmInfo.getByteArray(0, struEventISAPI.size()), 0, struEventISAPI.size());
                struEventISAPI.read();
                String sAlarmInfo = new String(pAlarmer.sDeviceIP);
                //报警数据类型：0- invalid，1- xml，2- json
                sAlarmInfo = "报警设备IP：" + sAlarmInfo + "：ISAPI协议报警信息, æ•°æ®æ ¼å¼:" + struEventISAPI.byDataType +
                        ", å›¾ç‰‡ä¸ªæ•°:" + struEventISAPI.byPicturesNumber;
                System.out.println(sAlarmInfo);

                //报警数据保存
                SimpleDateFormat sf1 = new SimpleDateFormat("yyyyMMddHHmmss");
                String curTime1 = sf1.format(new Date());
                FileOutputStream foutdata;
                try {
                    String jsonfilename = "../pic/" + new String(pAlarmer.sDeviceIP).trim() + curTime1 + "_ISAPI_Alarm_" + ".json";
                    foutdata = new FileOutputStream(jsonfilename);
                    //将字节写入文件
                    ByteBuffer jsonbuffers = struEventISAPI.pAlarmData.getByteBuffer(0, struEventISAPI.dwAlarmDataLen);
                    byte[] jsonbytes = new byte[struEventISAPI.dwAlarmDataLen];
                    jsonbuffers.rewind();
                    jsonbuffers.get(jsonbytes);
                    foutdata.write(jsonbytes);
                    foutdata.close();
                } catch (FileNotFoundException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                //图片数据保存
                for (int i = 0; i < struEventISAPI.byPicturesNumber; i++) {
                    HCNetSDK.NET_DVR_ALARM_ISAPI_PICDATA struPicData = new HCNetSDK.NET_DVR_ALARM_ISAPI_PICDATA();
                    struPicData.write();
                    Pointer pPicData = struPicData.getPointer();
                    pPicData.write(0, struEventISAPI.pPicPackData.getByteArray(i * struPicData.size(), struPicData.size()), 0, struPicData.size());
                    struPicData.read();

                    FileOutputStream fout;
                    try {
                        String filename = "../pic/" + new String(pAlarmer.sDeviceIP).trim() + curTime1 +
                                "_ISAPIPic_" + i + "_" + new String(struPicData.szFilename).trim() + ".jpg";
                        fout = new FileOutputStream(filename);
                        //将字节写入文件
                        long offset = 0;
                        ByteBuffer buffers = struPicData.pPicData.getByteBuffer(offset, struPicData.dwPicLen);
                        byte[] bytes = new byte[struPicData.dwPicLen];
                        buffers.rewind();
                        buffers.get(bytes);
                        fout.write(bytes);
                        fout.close();
                    } catch (FileNotFoundException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                break;
            case HCNetSDK.COMM_VCA_ALARM:  // æ™ºèƒ½æ£€æµ‹é€šç”¨æŠ¥è­¦(Json或者XML数据结构)
                sAlarmInfo = new String(pAlarmer.sDeviceIP);
                //报警数据类型：0- invalid，1- xml，2- json
                sAlarmInfo = "报警设备IP：" + sAlarmInfo;
                System.out.println(sAlarmInfo);

                SimpleDateFormat sf0 = new SimpleDateFormat("yyyyMMddHHmmss");
                String curTime0 = sf0.format(new Date());
                FileOutputStream Data;
                String jsonfile = "../pic" + new String(pAlarmer.sDeviceIP).trim() + curTime0 + "_VCA_ALARM_" + ".json";
                try {
                    Data = new FileOutputStream(jsonfile);
                    //将字节写入文件
                    ByteBuffer dataBuffer = pAlarmInfo.getByteBuffer(0, dwBufLen);
                    byte[] dataByte = new byte[dwBufLen];
                    dataBuffer.rewind();
                    dataBuffer.get(dataByte);
                    Data.write(dataByte);
                    Data.close();
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                break;

            //行为分析信息
            case HCNetSDK.COMM_ALARM_RULE:
                HCNetSDK.NET_VCA_RULE_ALARM strVcaAlarm = new HCNetSDK.NET_VCA_RULE_ALARM();
                strVcaAlarm.write();
                Pointer pVCAInfo = strVcaAlarm.getPointer();
                pVCAInfo.write(0, pAlarmInfo.getByteArray(0, strVcaAlarm.size()), 0, strVcaAlarm.size());
                strVcaAlarm.read();

                switch (strVcaAlarm.struRuleInfo.wEventTypeEx) {
                    case 1: //穿越警戒面 (越界侦测)
                        System.out.println("穿越警戒面报警发生");
                        break;
                    case 2: //目标进入区域

                        System.out.println("目标进入区域报警发生");

                        break;
                    case 3: //目标离开区域
                        System.out.println("目标离开区域报警触发");
                    case 4: //周界入侵

                        System.out.println("周界入侵报警发生");

                        break;
                    case 5: //徘徊
                        System.out.println("徘徊事件触发");

                        break;
                    case 8: //快速移动(奔跑)，
                        System.out.println("快速移动(奔跑)事件触发");
                        break;
                    case 15: //离岗
                        System.out.println("离岗事件触发");
                    case 20: //倒地检测
                        System.out.println("倒地事件触发");
                        break;
                    case 44: //玩手机

                        System.out.println("玩手机报警发生");

                        if ((strVcaAlarm.dwPicDataLen > 0) && (strVcaAlarm.byPicTransType == 0)) {
                            SimpleDateFormat sf = new SimpleDateFormat("yyyyMMddHHmmss");
                            String newName = sf.format(new Date());
                            FileOutputStream fout;
                            try {
                                String filename = "../pic/" + newName + "PLAY_CELLPHONE_" + ".jpg";
                                fout = new FileOutputStream(filename);
                                //将字节写入文件
                                long offset = 0;
                                ByteBuffer buffers = strVcaAlarm.pImage.getByteBuffer(offset, strVcaAlarm.dwPicDataLen);
                                byte[] bytes = new byte[strVcaAlarm.dwPicDataLen];
                                buffers.rewind();
                                buffers.get(bytes);
                                fout.write(bytes);
                                fout.close();
                            } catch (FileNotFoundException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                            } catch (IOException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                            }
                        }
                        break;
                    case 45: //持续检测
                        System.out.println("持续检测事件触发");
                    default:
                        System.out.println("行为事件类型:" + strVcaAlarm.struRuleInfo.wEventTypeEx);
                        break;
                }
                break;
            case HCNetSDK.COMM_ALARM_ACS: //门禁主机报警信息
                HCNetSDK.NET_DVR_ACS_ALARM_INFO strACSInfo = new HCNetSDK.NET_DVR_ACS_ALARM_INFO();
                strACSInfo.write();
                Pointer pACSInfo = strACSInfo.getPointer();
                pACSInfo.write(0, pAlarmInfo.getByteArray(0, strACSInfo.size()), 0, strACSInfo.size());
                strACSInfo.read();
                /**门禁事件的详细信息解析，通过主次类型的可以判断当前的具体门禁类型，例如（主类型：0X5 æ¬¡ç±»åž‹ï¼š0x4b è¡¨ç¤ºäººè„¸è®¤è¯é€šè¿‡ï¼Œ
                 ä¸»ç±»åž‹ï¼š0X5 æ¬¡ç±»åž‹ï¼š0x4c è¡¨ç¤ºäººè„¸è®¤è¯å¤±è´¥ï¼‰*/
                System.out.println("【门禁主机报警信息】卡号：" + new String(strACSInfo.struAcsEventInfo.byCardNo).trim() + "，卡类型：" +
                        strACSInfo.struAcsEventInfo.byCardType + "，报警主类型：" + Integer.toHexString(strACSInfo.dwMajor) + "，报警次类型：" + Integer.toHexString(strACSInfo.dwMinor));
                System.out.println("工号1：" + strACSInfo.struAcsEventInfo.dwEmployeeNo);
                //温度信息（如果设备支持测温功能，人脸温度信息从NET_DVR_ACS_EVENT_INFO_EXTEND_V20结构体获取）
                if (strACSInfo.byAcsEventInfoExtendV20 == 1) {
                    HCNetSDK.NET_DVR_ACS_EVENT_INFO_EXTEND_V20 strAcsInfoExV20 = new HCNetSDK.NET_DVR_ACS_EVENT_INFO_EXTEND_V20();
                    strAcsInfoExV20.write();
                    Pointer pAcsInfoExV20 = strAcsInfoExV20.getPointer();
                    pAcsInfoExV20.write(0, strACSInfo.pAcsEventInfoExtendV20.getByteArray(0, strAcsInfoExV20.size()), 0, strAcsInfoExV20.size());
                    strAcsInfoExV20.read();
                    System.out.println("实时温度值：" + strAcsInfoExV20.fCurrTemperature);
                }
                //考勤状态
                if (strACSInfo.byAcsEventInfoExtend == 1) {
                    HCNetSDK.NET_DVR_ACS_EVENT_INFO_EXTEND strAcsInfoEx = new HCNetSDK.NET_DVR_ACS_EVENT_INFO_EXTEND();
                    strAcsInfoEx.write();
                    Pointer pAcsInfoEx = strAcsInfoEx.getPointer();
                    pAcsInfoEx.write(0, strACSInfo.pAcsEventInfoExtend.getByteArray(0, strAcsInfoEx.size()), 0, strAcsInfoEx.size());
                    strAcsInfoEx.read();
                    System.out.println("考勤状态：" + strAcsInfoEx.byAttendanceStatus);
                    System.out.println("工号2：" + new String(strAcsInfoEx.byEmployeeNo).trim());
                }

                /**
                 * æŠ¥è­¦æ—¶é—´
                 */
                String year = Integer.toString(strACSInfo.struTime.dwYear);
                String SwipeTime = year + strACSInfo.struTime.dwMonth + strACSInfo.struTime.dwDay + strACSInfo.struTime.dwHour + strACSInfo.struTime.dwMinute +
                        strACSInfo.struTime.dwSecond;
                if (strACSInfo.dwPicDataLen > 0) {
//                    SimpleDateFormat sf = new SimpleDateFormat("yyyyMMddHHmmss");
//                    String newName = sf.format(new Date());
                    FileOutputStream fout;
                    try {
                        /**
                         * äººè„¸ä¿å­˜è·¯å¾„
                         */
                        String filename = "../pic/" + SwipeTime + "_ACS_Event_" + new String(strACSInfo.struAcsEventInfo.byCardNo).trim() + ".jpg";
                        fout = new FileOutputStream(filename);
                        //将字节写入文件
                        long offset = 0;
                        ByteBuffer buffers = strACSInfo.pPicData.getByteBuffer(offset, strACSInfo.dwPicDataLen);
                        byte[] bytes = new byte[strACSInfo.dwPicDataLen];
                        buffers.rewind();
                        buffers.get(bytes);
                        fout.write(bytes);
                        fout.close();
                    } catch (FileNotFoundException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                break;
            case HCNetSDK.COMM_ID_INFO_ALARM: //身份证信息
                HCNetSDK.NET_DVR_ID_CARD_INFO_ALARM strIDCardInfo = new HCNetSDK.NET_DVR_ID_CARD_INFO_ALARM();
                strIDCardInfo.write();
                Pointer pIDCardInfo = strIDCardInfo.getPointer();
                pIDCardInfo.write(0, pAlarmInfo.getByteArray(0, strIDCardInfo.size()), 0, strIDCardInfo.size());
                strIDCardInfo.read();
                System.out.println("报警主类型：" + Integer.toHexString(strIDCardInfo.dwMajor) + "，报警次类型：" + Integer.toHexString(strIDCardInfo.dwMinor));
                /**
                 * èº«ä»½è¯ä¿¡æ¯
                 */
                String IDnum = new String(strIDCardInfo.struIDCardCfg.byIDNum).trim();
                System.out.println("【身份证信息】：身份证号码：" + IDnum + "，姓名：" +
                        new String(strIDCardInfo.struIDCardCfg.byName).trim() + "，住址：" + new String(strIDCardInfo.struIDCardCfg.byAddr));

                /**
                 * æŠ¥è­¦æ—¶é—´
                 */
                String year1 = Integer.toString(strIDCardInfo.struSwipeTime.wYear);
                String SwipeTime1 = year1 + strIDCardInfo.struSwipeTime.byMonth + strIDCardInfo.struSwipeTime.byDay + strIDCardInfo.struSwipeTime.byHour + strIDCardInfo.struSwipeTime.byMinute +
                        strIDCardInfo.struSwipeTime.bySecond;
                /**
                 * ä¿å­˜å›¾ç‰‡
                 */
                //身份证图片
                if (strIDCardInfo.dwPicDataLen > 0 || strIDCardInfo.pPicData != null) {
//                    SimpleDateFormat sf = new SimpleDateFormat("yyyyMMddHHmmss");
//                    String nowtime = sf.format(new Date());
                    FileOutputStream fout;
                    try {
                        String filename = "../pic/" + SwipeTime1 + "_" + IDnum + ".jpg";
                        fout = new FileOutputStream(filename);
                        //将字节写入文件
                        long offset = 0;
                        ByteBuffer buffers = strIDCardInfo.pPicData.getByteBuffer(offset, strIDCardInfo.dwPicDataLen);
                        byte[] bytes = new byte[strIDCardInfo.dwPicDataLen];
                        buffers.rewind();
                        buffers.get(bytes);
                        fout.write(bytes);
                        fout.close();
                    } catch (FileNotFoundException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }

                if (strIDCardInfo.dwCapturePicDataLen > 0 || strIDCardInfo.pCapturePicData != null) {
//                    SimpleDateFormat sf = new SimpleDateFormat("yyyyMMddHHmmss");
//                    String nowtime = sf.format(new Date());
                    FileOutputStream fout;
                    try {
                        /**
                         * äººè„¸å›¾ç‰‡ä¿å­˜è·¯å¾„
                         */
                        String filename = "../pic/" + SwipeTime1 + "_CapturePic_" + ".jpg";
                        fout = new FileOutputStream(filename);
                        //将字节写入文件
                        long offset = 0;
                        ByteBuffer buffers = strIDCardInfo.pCapturePicData.getByteBuffer(offset, strIDCardInfo.dwCapturePicDataLen);
                        byte[] bytes = new byte[strIDCardInfo.dwCapturePicDataLen];
                        buffers.rewind();
                        buffers.get(bytes);
                        fout.write(bytes);
                        fout.close();
                    } catch (FileNotFoundException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                break;

            case HCNetSDK.COMM_ALARM_VIDEO_INTERCOM: //可视对讲报警信息
                System.out.println("可视对讲报警触发");


                break;
            case HCNetSDK.COMM_UPLOAD_VIDEO_INTERCOM_EVENT: //可视对讲事件记录信息
                System.out.println("可视对讲事件记录报警触发");


                break;

            case HCNetSDK.COMM_UPLOAD_FACESNAP_RESULT: //实时人脸抓拍上传
                System.out.println("UPLOAD_FACESNAP_Alarm");
                HCNetSDK.NET_VCA_FACESNAP_RESULT strFaceSnapInfo = new HCNetSDK.NET_VCA_FACESNAP_RESULT();
                strFaceSnapInfo.write();
                Pointer pFaceSnapInfo = strFaceSnapInfo.getPointer();
                pFaceSnapInfo.write(0, pAlarmInfo.getByteArray(0, strFaceSnapInfo.size()), 0, strFaceSnapInfo.size());
                strFaceSnapInfo.read();

                //事件时间
                int dwYear = (strFaceSnapInfo.dwAbsTime >> 26) + 2000;
                int dwMonth = (strFaceSnapInfo.dwAbsTime >> 22) & 15;
                int dwDay = (strFaceSnapInfo.dwAbsTime >> 17) & 31;
                int dwHour = (strFaceSnapInfo.dwAbsTime >> 12) & 31;
                int dwMinute = (strFaceSnapInfo.dwAbsTime >> 6) & 63;
                int dwSecond = (strFaceSnapInfo.dwAbsTime >> 0) & 63;

                String strAbsTime = "" + String.format("%04d", dwYear) +
                        String.format("%02d", dwMonth) +
                        String.format("%02d", dwDay) +
                        String.format("%02d", dwHour) +
                        String.format("%02d", dwMinute) +
                        String.format("%02d", dwSecond);

                //人脸属性信息
                String sFaceAlarmInfo = "Abs时间:" + strAbsTime + ",年龄:" + strFaceSnapInfo.struFeature.byAge +
                        ",性别：" + strFaceSnapInfo.struFeature.bySex + ",是否戴口罩：" +
                        strFaceSnapInfo.struFeature.byMask + ",是否微笑：" + strFaceSnapInfo.struFeature.bySmile;
                System.out.println("人脸信息：" + sFaceAlarmInfo);

                //人脸测温信息
                if (strFaceSnapInfo.byAddInfo == 1) {
                    HCNetSDK.NET_VCA_FACESNAP_ADDINFO strAddInfo = new HCNetSDK.NET_VCA_FACESNAP_ADDINFO();
                    strAddInfo.write();
                    Pointer pAddInfo = strAddInfo.getPointer();
                    pAddInfo.write(0, strFaceSnapInfo.pAddInfoBuffer.getByteArray(0, strAddInfo.size()), 0, strAddInfo.size());
                    strAddInfo.read();

                    String sTemperatureInfo = "测温是否开启：" + strAddInfo.byFaceSnapThermometryEnabled + "人脸温度：" + strAddInfo.fFaceTemperature + "温度是否异常"
                            + strAddInfo.byIsAbnomalTemperature + "报警温度阈值：" + strAddInfo.fAlarmTemperature;
                    System.out.println("人脸温度信息:" + sTemperatureInfo);

                }

                try {
                    SimpleDateFormat df = new SimpleDateFormat("yyyyMMddHHmmss");//设置日期格式
                    String time = df.format(new Date());// new Date()为获取当前系统时间

                    //人脸图片写文件
                    FileOutputStream small = new FileOutputStream("../pic/" + time + "small.jpg");
                    FileOutputStream big = new FileOutputStream("../pic/" + time + "big.jpg");
                    try {
                        small.write(strFaceSnapInfo.pBuffer1.getByteArray(0, strFaceSnapInfo.dwFacePicLen), 0, strFaceSnapInfo.dwFacePicLen);
                        small.close();
                    } catch (IOException ex) {
                        ex.printStackTrace();
                    }
                    try {
                        big.write(strFaceSnapInfo.pBuffer2.getByteArray(0, strFaceSnapInfo.dwBackgroundPicLen), 0, strFaceSnapInfo.dwBackgroundPicLen);
                        big.close();
                    } catch (IOException ex) {
                        ex.printStackTrace();
                    }

                } catch (FileNotFoundException ex) {
                    ex.printStackTrace();
                }
                break;

            case HCNetSDK.COMM_SNAP_MATCH_ALARM:    //人脸黑名单比对报警
                HCNetSDK.NET_VCA_FACESNAP_MATCH_ALARM strFaceSnapMatch = new HCNetSDK.NET_VCA_FACESNAP_MATCH_ALARM();
                strFaceSnapMatch.write();
                Pointer pFaceSnapMatch = strFaceSnapMatch.getPointer();
                pFaceSnapMatch.write(0, pAlarmInfo.getByteArray(0, strFaceSnapMatch.size()), 0, strFaceSnapMatch.size());
                strFaceSnapMatch.read();
                //比对结果，0-保留，1-比对成功，2-比对失败
                String sFaceSnapMatchInfo = "比对结果：" + strFaceSnapMatch.byContrastStatus + ",相似度：" + strFaceSnapMatch.fSimilarity;
                System.out.println(sFaceSnapMatchInfo);
                if (strFaceSnapMatch.struBlockListInfo.dwFDIDLen > 0) {
                    long offset1 = 0;
                    ByteBuffer buffers1 = strFaceSnapMatch.struBlockListInfo.pFDID.getByteBuffer(offset1, strFaceSnapMatch.struBlockListInfo.dwFDIDLen);
                    byte[] bytes1 = new byte[strFaceSnapMatch.struBlockListInfo.dwFDIDLen];
                    buffers1.get(bytes1);
                    System.out.println("人脸库ID:" + new String(bytes1));
                }
                if (strFaceSnapMatch.struBlockListInfo.dwPIDLen > 0) {
                    long offset2 = 0;
                    ByteBuffer buffers2 = strFaceSnapMatch.struBlockListInfo.pPID.getByteBuffer(offset2, strFaceSnapMatch.struBlockListInfo.dwPIDLen);
                    byte[] bytes2 = new byte[strFaceSnapMatch.struBlockListInfo.dwPIDLen];
                    buffers2.get(bytes2);
                    System.out.println("图片ID：" + new String(bytes2));
                }
                //抓拍库附加信息解析（解析人脸测温温度,人脸温度存放在附件信息的XML报文中，节点：  <currTemperature> ï¼‰
                SimpleDateFormat sf2 = new SimpleDateFormat("yyyyMMddHHmmss");
                String curTime2 = sf2.format(new Date());
                FileOutputStream AddtionData;
                String AddtionFile = "../pic" + new String(pAlarmer.sDeviceIP).trim() + curTime2 + "_FCAdditionInfo_" + ".xml";
                try {
                    Data = new FileOutputStream(AddtionFile);
                    //将字节写入文件
                    ByteBuffer dataBuffer = strFaceSnapMatch.struBlockListInfo.struBlockListInfo.pFCAdditionInfoBuffer.getByteBuffer(0, strFaceSnapMatch.struBlockListInfo.struBlockListInfo.dwFCAdditionInfoLen);
                    byte[] dataByte = new byte[dwBufLen];
                    dataBuffer.rewind();
                    dataBuffer.get(dataByte);
                    Data.write(dataByte);
                    Data.close();
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }

                //人脸比对报警图片保存，图片格式二进制
                if ((strFaceSnapMatch.dwSnapPicLen > 0) && (strFaceSnapMatch.byPicTransType == 0)) {
                    SimpleDateFormat sf = new SimpleDateFormat("yyyyMMddHHmmss");
                    String newName = sf.format(new Date());
                    FileOutputStream fout;
                    try {
                        String filename = "../pic/" + newName + "_pSnapPicBuffer" + ".jpg";
                        fout = new FileOutputStream(filename);
                        //将字节写入文件
                        long offset = 0;
                        ByteBuffer buffers = strFaceSnapMatch.pSnapPicBuffer.getByteBuffer(offset, strFaceSnapMatch.dwSnapPicLen);
                        byte[] bytes = new byte[strFaceSnapMatch.dwSnapPicLen];
                        buffers.rewind();
                        buffers.get(bytes);
                        fout.write(bytes);
                        fout.close();
                    } catch (FileNotFoundException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                if ((strFaceSnapMatch.struSnapInfo.dwSnapFacePicLen > 0) && (strFaceSnapMatch.byPicTransType == 0)) {
                    SimpleDateFormat sf = new SimpleDateFormat("yyyyMMddHHmmss");
                    String newName = sf.format(new Date());
                    FileOutputStream fout;
                    try {
                        String filename = "../pic/" + newName + "_struSnapInfo_pBuffer1" + ".jpg";
                        fout = new FileOutputStream(filename);
                        //将字节写入文件
                        long offset = 0;
                        ByteBuffer buffers = strFaceSnapMatch.struSnapInfo.pBuffer1.getByteBuffer(offset, strFaceSnapMatch.struSnapInfo.dwSnapFacePicLen);
                        byte[] bytes = new byte[strFaceSnapMatch.struSnapInfo.dwSnapFacePicLen];
                        buffers.rewind();
                        buffers.get(bytes);
                        fout.write(bytes);
                        fout.close();
                    } catch (FileNotFoundException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                if ((strFaceSnapMatch.struBlockListInfo.dwBlockListPicLen > 0) && (strFaceSnapMatch.byPicTransType == 0)) {
                    SimpleDateFormat sf = new SimpleDateFormat("yyyyMMddHHmmss");
                    String newName = sf.format(new Date());
                    FileOutputStream fout;
                    try {
                        String filename = "../pic/" + newName + "_fSimilarity_" + strFaceSnapMatch.fSimilarity + "_struBlackListInfo_pBuffer1" + ".jpg";
                        fout = new FileOutputStream(filename);
                        //将字节写入文件
                        long offset = 0;
                        ByteBuffer buffers = strFaceSnapMatch.struBlockListInfo.pBuffer1.getByteBuffer(offset, strFaceSnapMatch.struBlockListInfo.dwBlockListPicLen);
                        byte[] bytes = new byte[strFaceSnapMatch.struBlockListInfo.dwBlockListPicLen];
                        buffers.rewind();
                        buffers.get(bytes);
                        fout.write(bytes);
                        fout.close();
                    } catch (FileNotFoundException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                //人脸比对报警图片保存，图片格式URL格式
                if ((strFaceSnapMatch.dwSnapPicLen > 0) && (strFaceSnapMatch.byPicTransType == 1)) {

                    long offset = 0;
                    ByteBuffer buffers = strFaceSnapMatch.pSnapPicBuffer.getByteBuffer(offset, strFaceSnapMatch.dwSnapPicLen);
                    byte[] bytes = new byte[strFaceSnapMatch.dwSnapPicLen];
                    buffers.rewind();
                    buffers.get(bytes);
                    String SnapPicUrl = new String(bytes);
                    System.out.println("抓拍图URL：" + SnapPicUrl);
                }
                if ((strFaceSnapMatch.struSnapInfo.dwSnapFacePicLen > 0) && (strFaceSnapMatch.byPicTransType == 1)) {

                    long offset = 0;
                    ByteBuffer buffers = strFaceSnapMatch.struSnapInfo.pBuffer1.getByteBuffer(offset, strFaceSnapMatch.struSnapInfo.dwSnapFacePicLen);
                    byte[] bytes = new byte[strFaceSnapMatch.struSnapInfo.dwSnapFacePicLen];
                    buffers.rewind();
                    buffers.get(bytes);
                    String SnapPicUrl = new String(bytes);
                    System.out.println("抓拍人脸子图URL：" + SnapPicUrl);
                }
                if ((strFaceSnapMatch.struBlockListInfo.dwBlockListPicLen > 0) && (strFaceSnapMatch.byPicTransType == 1)) {

                    long offset = 0;
                    ByteBuffer buffers = strFaceSnapMatch.struBlockListInfo.pBuffer1.getByteBuffer(offset, strFaceSnapMatch.struBlockListInfo.dwBlockListPicLen);
                    byte[] bytes = new byte[strFaceSnapMatch.struBlockListInfo.dwBlockListPicLen];
                    buffers.rewind();
                    buffers.get(bytes);
                    String SnapPicUrl = new String(bytes);
                    System.out.println("人脸库人脸图的URL：" + SnapPicUrl);
                }


                break;
            //  å®¢æµé‡æŠ¥è­¦ä¿¡æ¯
            case HCNetSDK.COMM_ALARM_PDC:
                HCNetSDK.NET_DVR_PDC_ALRAM_INFO strPDCResult = new HCNetSDK.NET_DVR_PDC_ALRAM_INFO();
                strPDCResult.write();
                Pointer pPDCInfo = strPDCResult.getPointer();
                pPDCInfo.write(0, pAlarmInfo.getByteArray(0, strPDCResult.size()), 0, strPDCResult.size());
                strPDCResult.read();
                // byMode=0-实时统计结果(联合体中struStatFrame有效)，
                if (strPDCResult.byMode == 0) {
                    strPDCResult.uStatModeParam.setType(HCNetSDK.NET_DVR_STATFRAME.class);
                    String sAlarmPDC0Info = "实时客流量统计，进入人数：" + strPDCResult.dwEnterNum + "，离开人数：" + strPDCResult.dwLeaveNum +
                            ", byMode:" + strPDCResult.byMode + ", dwRelativeTime:" + strPDCResult.uStatModeParam.struStatFrame.dwRelativeTime +
                            ", dwAbsTime:" + strPDCResult.uStatModeParam.struStatFrame.dwAbsTime;
                }
                // byMode=1-周期统计结果(联合体中struStatTime有效)，
                if (strPDCResult.byMode == 1) {
                    strPDCResult.uStatModeParam.setType(HCNetSDK.NET_DVR_STATTIME.class);
                    String strtmStart = "" + String.format("%04d", strPDCResult.uStatModeParam.struStatTime.tmStart.dwYear) +
                            String.format("%02d", strPDCResult.uStatModeParam.struStatTime.tmStart.dwMonth) +
                            String.format("%02d", strPDCResult.uStatModeParam.struStatTime.tmStart.dwDay) +
                            String.format("%02d", strPDCResult.uStatModeParam.struStatTime.tmStart.dwHour) +
                            String.format("%02d", strPDCResult.uStatModeParam.struStatTime.tmStart.dwMinute) +
                            String.format("%02d", strPDCResult.uStatModeParam.struStatTime.tmStart.dwSecond);
                    String strtmEnd = "" + String.format("%04d", strPDCResult.uStatModeParam.struStatTime.tmEnd.dwYear) +
                            String.format("%02d", strPDCResult.uStatModeParam.struStatTime.tmEnd.dwMonth) +
                            String.format("%02d", strPDCResult.uStatModeParam.struStatTime.tmEnd.dwDay) +
                            String.format("%02d", strPDCResult.uStatModeParam.struStatTime.tmEnd.dwHour) +
                            String.format("%02d", strPDCResult.uStatModeParam.struStatTime.tmEnd.dwMinute) +
                            String.format("%02d", strPDCResult.uStatModeParam.struStatTime.tmEnd.dwSecond);
                    String sAlarmPDC1Info = "周期性客流量统计，进入人数：" + strPDCResult.dwEnterNum + "，离开人数：" + strPDCResult.dwLeaveNum +
                            ", byMode:" + strPDCResult.byMode + ", tmStart:" + strtmStart + ",tmEnd :" + strtmEnd;
                }
                break;
            case HCNetSDK.COMM_ALARM_V30:  //移动侦测、视频丢失、遮挡、IO信号量等报警信息(V3.0以上版本支持的设备)
                HCNetSDK.NET_DVR_ALARMINFO_V30 struAlarmInfo = new HCNetSDK.NET_DVR_ALARMINFO_V30();
                struAlarmInfo.write();
                Pointer pAlarmInfo_V30 = struAlarmInfo.getPointer();
                pAlarmInfo_V30.write(0, pAlarmInfo.getByteArray(0, struAlarmInfo.size()), 0, struAlarmInfo.size());
                struAlarmInfo.read();
                System.out.println("报警类型：" + struAlarmInfo.dwAlarmType);  // 3-移动侦测
                break;
            case HCNetSDK.COMM_ALARM_V40: //移动侦测、视频丢失、遮挡、IO信号量等报警信息，报警数据为可变长
                HCNetSDK.NET_DVR_ALARMINFO_V40 struAlarmInfoV40 = new HCNetSDK.NET_DVR_ALARMINFO_V40();
                struAlarmInfoV40.write();
                Pointer pAlarmInfoV40 = struAlarmInfoV40.getPointer();
                pAlarmInfoV40.write(0, pAlarmInfo.getByteArray(0, struAlarmInfoV40.size()), 0, struAlarmInfoV40.size());
                struAlarmInfoV40.read();
                System.out.println("报警类型:" + struAlarmInfoV40.struAlarmFixedHeader.dwAlarmType); //3-移动侦测
                break;
            case HCNetSDK.COMM_THERMOMETRY_ALARM:  //温度报警信息
                HCNetSDK.NET_DVR_THERMOMETRY_ALARM struTemInfo = new HCNetSDK.NET_DVR_THERMOMETRY_ALARM();
                struTemInfo.write();
                Pointer pTemInfo = struTemInfo.getPointer();
                pTemInfo.write(0, pAlarmInfo.getByteArray(0, struTemInfo.size()), 0, struTemInfo.size());
                struTemInfo.read();
                String sThermAlarmInfo = "规则ID:" + struTemInfo.byRuleID + "预置点号：" + struTemInfo.wPresetNo + "报警等级：" + struTemInfo.byAlarmLevel + "报警类型：" +
                        struTemInfo.byAlarmType + "当前温度：" + struTemInfo.fCurrTemperature;
                System.out.println(sThermAlarmInfo);
                //可见光图片保存
                if ((struTemInfo.dwPicLen > 0) && (struTemInfo.byPicTransType == 0)) {
                    SimpleDateFormat sf = new SimpleDateFormat("yyyyMMddHHmmss");
                    String newName = sf.format(new Date());
                    FileOutputStream fout;

                    try {
                        String filename = "../pic/" + newName + "_" + struTemInfo.fCurrTemperature + ".jpg";
                        fout = new FileOutputStream(filename);
                        //将字节写入文件
                        long offset = 0;
                        ByteBuffer buffers = struTemInfo.pPicBuff.getByteBuffer(offset, struTemInfo.dwPicLen);
                        byte[] bytes = new byte[struTemInfo.dwPicLen];
                        buffers.rewind();
                        buffers.get(bytes);
                        fout.write(bytes);
                        fout.close();
                    } catch (FileNotFoundException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }

                if ((struTemInfo.dwThermalPicLen > 0) && (struTemInfo.byPicTransType == 0)) {
                    SimpleDateFormat sf = new SimpleDateFormat("yyyyMMddHHmmss");
                    String newName = sf.format(new Date());
                    FileOutputStream fout;

                    try {
                        String filename = "../pic/" + newName + "_" + "_ThermalPiC" + ".jpg";
                        fout = new FileOutputStream(filename);
                        //将字节写入文件
                        long offset = 0;
                        ByteBuffer buffers = struTemInfo.pThermalPicBuff.getByteBuffer(offset, struTemInfo.dwThermalPicLen);
                        byte[] bytes = new byte[struTemInfo.dwThermalPicLen];
                        buffers.rewind();
                        buffers.get(bytes);
                        fout.write(bytes);
                        fout.close();
                    } catch (FileNotFoundException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }

                }
                break;
            case HCNetSDK.COMM_THERMOMETRY_DIFF_ALARM: //温差检测报警
                HCNetSDK.NET_DVR_THERMOMETRY_DIFF_ALARM strThermDiffAlarm = new HCNetSDK.NET_DVR_THERMOMETRY_DIFF_ALARM();
                strThermDiffAlarm.write();
                Pointer pTemDiffInfo = strThermDiffAlarm.getPointer();
                pTemDiffInfo.write(0, pAlarmInfo.getByteArray(0, strThermDiffAlarm.size()), 0, strThermDiffAlarm.size());
                strThermDiffAlarm.read();
                String sThremDiffInfo = "通道号：" + strThermDiffAlarm.dwChannel + ",报警规则：" + strThermDiffAlarm.byAlarmRule + "，当前温差：" + strThermDiffAlarm.fCurTemperatureDiff;
                System.out.println(sThremDiffInfo);
                //可见光图片保存
                if ((strThermDiffAlarm.dwPicLen > 0) && (strThermDiffAlarm.byPicTransType == 0)) {
                    SimpleDateFormat sf = new SimpleDateFormat("yyyyMMddHHmmss");
                    String newName = sf.format(new Date());
                    FileOutputStream fout;

                    try {
                        String filename = "../pic/" + newName + "_" + strThermDiffAlarm.fCurTemperatureDiff + ".jpg";
                        fout = new FileOutputStream(filename);
                        //将字节写入文件
                        long offset = 0;
                        ByteBuffer buffers = strThermDiffAlarm.pPicBuff.getByteBuffer(offset, strThermDiffAlarm.dwPicLen);
                        byte[] bytes = new byte[strThermDiffAlarm.dwPicLen];
                        buffers.rewind();
                        buffers.get(bytes);
                        fout.write(bytes);
                        fout.close();
                    } catch (FileNotFoundException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                //热成像图片保存
                if ((strThermDiffAlarm.dwThermalPicLen > 0) && (strThermDiffAlarm.byPicTransType == 0)) {
                    SimpleDateFormat sf = new SimpleDateFormat("yyyyMMddHHmmss");
                    String newName = sf.format(new Date());
                    FileOutputStream fout;

                    try {
                        String filename = "../pic/" + newName + "_" + "_ThermalDiffPiC" + ".jpg";
                        fout = new FileOutputStream(filename);
                        //将字节写入文件
                        long offset = 0;
                        ByteBuffer buffers = strThermDiffAlarm.pThermalPicBuff.getByteBuffer(offset, strThermDiffAlarm.dwThermalPicLen);
                        byte[] bytes = new byte[strThermDiffAlarm.dwThermalPicLen];
                        buffers.rewind();
                        buffers.get(bytes);
                        fout.write(bytes);
                        fout.close();
                    } catch (FileNotFoundException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }

                }
                break;
            case HCNetSDK.COMM_ALARM_SHIPSDETECTION: //船只检测报警
                HCNetSDK.NET_DVR_SHIPSDETECTION_ALARM struShipAlarm = new HCNetSDK.NET_DVR_SHIPSDETECTION_ALARM();
                struShipAlarm.write();
                Pointer pShipAlarm = struShipAlarm.getPointer();
                pShipAlarm.write(0, pAlarmInfo.getByteArray(0, struShipAlarm.size()), 0, struShipAlarm.size());
                struShipAlarm.read();
                String sShipAlarm = "绝对时间：" + struShipAlarm.dwAbsTime + ",正跨越检测线的船只数:" + struShipAlarm.byShipsNum + ",船头检测的船只数 :" + struShipAlarm.byShipsNumHead
                        + ", èˆ¹å°¾æ£€æµ‹çš„船只数 :" + struShipAlarm.byShipsNumEnd;
                System.out.println(sShipAlarm);
                //可见光图片保存
                if ((struShipAlarm.dwPicLen > 0) && (struShipAlarm.byPicTransType == 0)) {
                    SimpleDateFormat sf = new SimpleDateFormat("yyyyMMddHHmmss");
                    String newName = sf.format(new Date());
                    FileOutputStream fout;

                    try {
                        String filename = "../pic/" + newName + "_ShipAlarm" + ".jpg";
                        fout = new FileOutputStream(filename);
                        //将字节写入文件
                        long offset = 0;
                        ByteBuffer buffers = struShipAlarm.pPicBuffer.getByteBuffer(offset, struShipAlarm.dwPicLen);
                        byte[] bytes = new byte[struShipAlarm.dwPicLen];
                        buffers.rewind();
                        buffers.get(bytes);
                        fout.write(bytes);
                        fout.close();
                    } catch (FileNotFoundException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                //热成像图片保存
                if ((struShipAlarm.dwThermalPicLen > 0) && (struShipAlarm.byPicTransType == 0)) {
                    SimpleDateFormat sf = new SimpleDateFormat("yyyyMMddHHmmss");
                    String newName = sf.format(new Date());
                    FileOutputStream fout;

                    try {
                        String filename = "../pic/" + newName + "_" + "_ThermalShipAlarm" + ".jpg";
                        fout = new FileOutputStream(filename);
                        //将字节写入文件
                        long offset = 0;
                        ByteBuffer buffers = struShipAlarm.pThermalPicBuffer.getByteBuffer(offset, struShipAlarm.dwThermalPicLen);
                        byte[] bytes = new byte[struShipAlarm.dwThermalPicLen];
                        buffers.rewind();
                        buffers.get(bytes);
                        fout.write(bytes);
                        fout.close();
                    } catch (FileNotFoundException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }

                }
                break;

            case HCNetSDK.COMM_FIREDETECTION_ALARM://烟火检测
                HCNetSDK.NET_DVR_FIREDETECTION_ALARM struFireDecAlarm = new HCNetSDK.NET_DVR_FIREDETECTION_ALARM();
                struFireDecAlarm.write();
                Pointer pFireDecAlarm = struFireDecAlarm.getPointer();
                pFireDecAlarm.write(0, pAlarmInfo.getByteArray(0, struFireDecAlarm.size()), 0, struFireDecAlarm.size());
                struFireDecAlarm.read();
                String sFireDecAlarmInfo = "绝对时间：" + struFireDecAlarm.dwAbsTime + ",报警子类型：" + struFireDecAlarm.byAlarmSubType + ",火点最高温度 :" +
                        struFireDecAlarm.wFireMaxTemperature + ",火点目标距离：" + struFireDecAlarm.wTargetDistance;
                System.out.println(sFireDecAlarmInfo);
                //可见光图片保存
                if ((struFireDecAlarm.dwVisiblePicLen > 0) && (struFireDecAlarm.byPicTransType == 0)) {
                    SimpleDateFormat sf = new SimpleDateFormat("yyyyMMddHHmmss");
                    String newName = sf.format(new Date());
                    FileOutputStream fout;

                    try {
                        String filename = "../pic/" + newName + "_FireDecAlarm" + ".jpg";
                        fout = new FileOutputStream(filename);
                        //将字节写入文件
                        long offset = 0;
                        ByteBuffer buffers = struFireDecAlarm.pVisiblePicBuf.getByteBuffer(offset, struFireDecAlarm.dwVisiblePicLen);
                        byte[] bytes = new byte[struFireDecAlarm.dwVisiblePicLen];
                        buffers.rewind();
                        buffers.get(bytes);
                        fout.write(bytes);
                        fout.close();
                    } catch (FileNotFoundException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                //热成像图片保存
                if ((struFireDecAlarm.dwPicDataLen > 0) && (struFireDecAlarm.byPicTransType == 0)) {
                    SimpleDateFormat sf = new SimpleDateFormat("yyyyMMddHHmmss");
                    String newName = sf.format(new Date());
                    FileOutputStream fout;

                    try {
                        String filename = "../pic/" + newName + "_" + "_ThermalFireAlarm" + ".jpg";
                        fout = new FileOutputStream(filename);
                        //将字节写入文件
                        long offset = 0;
                        ByteBuffer buffers = struFireDecAlarm.pBuffer.getByteBuffer(offset, struFireDecAlarm.dwPicDataLen);
                        byte[] bytes = new byte[struFireDecAlarm.dwPicDataLen];
                        buffers.rewind();
                        buffers.get(bytes);
                        fout.write(bytes);
                        fout.close();
                    } catch (FileNotFoundException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }

                }
                break;
            case HCNetSDK.COMM_UPLOAD_AIOP_VIDEO: //AI开放平台接入视频检测报警信息
                System.out.println("AI开放平台接入视频检测报警上传");
                HCNetSDK.NET_AIOP_VIDEO_HEAD struAIOPVideo = new HCNetSDK.NET_AIOP_VIDEO_HEAD();
                struAIOPVideo.write();
                Pointer pAIOPVideo = struAIOPVideo.getPointer();
                pAIOPVideo.write(0, pAlarmInfo.getByteArray(0, struAIOPVideo.size()), 0, struAIOPVideo.size());
                struAIOPVideo.read();
                System.out.println("视频任务ID" + new String(struAIOPVideo.szTaskID));
                System.out.println("通道号：" + struAIOPVideo.dwChannel);
                System.out.println("检测模型包ID" + new String(struAIOPVideo.szMPID));
                String strTime = String.format("%04d", struAIOPVideo.struTime.wYear) +
                        String.format("%02d", struAIOPVideo.struTime.wMonth) +
                        String.format("%02d", struAIOPVideo.struTime.wDay) +
                        String.format("%02d", struAIOPVideo.struTime.wHour) +
                        String.format("%02d", struAIOPVideo.struTime.wMinute) +
                        String.format("%02d", struAIOPVideo.struTime.wSecond) +
                        String.format("%03d", struAIOPVideo.struTime.wMilliSec);
                //AIOPData数据
                if (struAIOPVideo.dwAIOPDataSize > 0) {
                    FileOutputStream fout;
                    try {
                        String filename = "../pic/" + new String(pAlarmer.sDeviceIP).trim() +
                                "_" + strTime + "_VideoData.json";
                        fout = new FileOutputStream(filename);
                        //将字节写入文件
                        long offset = 0;
                        ByteBuffer buffers = struAIOPVideo.pBufferAIOPData.getByteBuffer(offset, struAIOPVideo.dwAIOPDataSize);
                        byte[] bytes = new byte[struAIOPVideo.dwAIOPDataSize];
                        buffers.rewind();
                        buffers.get(bytes);
                        fout.write(bytes);
                        fout.close();
                    } catch (FileNotFoundException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                //图片数据保存
                if (struAIOPVideo.dwPictureSize > 0) {
                    FileOutputStream fout;
                    try {
                        String filename = "../pic/" + new String(pAlarmer.sDeviceIP).trim() +
                                "_" + strTime + "_VideoPic.jpg";
                        fout = new FileOutputStream(filename);
                        //将字节写入文件
                        long offset = 0;
                        ByteBuffer buffers = struAIOPVideo.pBufferPicture.getByteBuffer(offset, struAIOPVideo.dwPictureSize);
                        byte[] bytes = new byte[struAIOPVideo.dwPictureSize];
                        buffers.rewind();
                        buffers.get(bytes);
                        fout.write(bytes);
                        fout.close();
                    } catch (FileNotFoundException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                break;
            case HCNetSDK.COMM_UPLOAD_AIOP_PICTURE: //AI开放平台接入图片检测报警信息
                System.out.println("AI开放平台接入图片检测报警上传");
                HCNetSDK.NET_AIOP_PICTURE_HEAD struAIOPPic = new HCNetSDK.NET_AIOP_PICTURE_HEAD();
                struAIOPPic.write();
                Pointer pAIOPPic = struAIOPPic.getPointer();
                pAIOPPic.write(0, pAlarmInfo.getByteArray(0, struAIOPPic.size()), 0, struAIOPPic.size());
                struAIOPPic.read();
                System.out.println("图片ID：" + new String(struAIOPPic.szPID));
                System.out.println("检测模型包ID：" + new String(struAIOPPic.szMPID));
                String strPicTime = "" + String.format("%04d", struAIOPPic.struTime.wYear) +
                        String.format("%02d", struAIOPPic.struTime.wMonth) +
                        String.format("%02d", struAIOPPic.struTime.wDay) +
                        String.format("%02d", struAIOPPic.struTime.wHour) +
                        String.format("%02d", struAIOPPic.struTime.wMinute) +
                        String.format("%02d", struAIOPPic.struTime.wSecond) +
                        String.format("%03d", struAIOPPic.struTime.wMilliSec);
                //AIOPData数据
                if (struAIOPPic.dwAIOPDataSize > 0) {
                    FileOutputStream fout;
                    try {
                        String filename = "../pic/" + new String(pAlarmer.sDeviceIP).trim() +
                                "_" + strPicTime + "_AIO_PicData.json";
                        fout = new FileOutputStream(filename);
                        //将字节写入文件
                        long offset = 0;
                        ByteBuffer buffers = struAIOPPic.pBufferAIOPData.getByteBuffer(offset, struAIOPPic.dwAIOPDataSize);
                        byte[] bytes = new byte[struAIOPPic.dwAIOPDataSize];
                        buffers.rewind();
                        buffers.get(bytes);
                        fout.write(bytes);
                        fout.close();
                    } catch (FileNotFoundException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                break;

            //AI开放平台接入轮询抓图检测报警信息
            case HCNetSDK.COMM_UPLOAD_AIOP_POLLING_SNAP:
                System.out.println("AI开放平台接入轮询抓图检测报警事件上传");
                HCNetSDK.NET_AIOP_POLLING_SNAP_HEAD strAiopPollingPic = new HCNetSDK.NET_AIOP_POLLING_SNAP_HEAD();
                strAiopPollingPic.write();
                Pointer pAiopPollingPic = strAiopPollingPic.getPointer();
                pAiopPollingPic.write(0, pAlarmInfo.getByteArray(0, strAiopPollingPic.size()), 0, strAiopPollingPic.size());
                strAiopPollingPic.read();
                System.out.println("通道号：" + strAiopPollingPic.dwChannel);
                System.out.println("轮询抓图任务ID：" + new String(strAiopPollingPic.szTaskID));
                String strPollingPicTime = "" + String.format("%04d", strAiopPollingPic.struTime.wYear) +
                        String.format("%02d", strAiopPollingPic.struTime.wMonth) +
                        String.format("%02d", strAiopPollingPic.struTime.wDay) +
                        String.format("%02d", strAiopPollingPic.struTime.wHour) +
                        String.format("%02d", strAiopPollingPic.struTime.wMinute) +
                        String.format("%02d", strAiopPollingPic.struTime.wSecond) +
                        String.format("%03d", strAiopPollingPic.struTime.wMilliSec);
                //AIOPData数据保存
                if (strAiopPollingPic.dwAIOPDataSize > 0) {
                    FileOutputStream fout;
                    try {
                        String filename = "../pic/" + new String(pAlarmer.sDeviceIP).trim() +
                                "_" + strPollingPicTime + "_PollingPicData.json";
                        fout = new FileOutputStream(filename);
                        //将字节写入文件
                        long offset = 0;
                        ByteBuffer buffers = strAiopPollingPic.pBufferAIOPData.getByteBuffer(offset, strAiopPollingPic.dwAIOPDataSize);
                        byte[] bytes = new byte[strAiopPollingPic.dwAIOPDataSize];
                        buffers.rewind();
                        buffers.get(bytes);
                        fout.write(bytes);
                        fout.close();
                    } catch (FileNotFoundException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                //轮询抓图图片保存
                if (strAiopPollingPic.dwPictureSize > 0) {
                    FileOutputStream fout;
                    try {
                        String filename = "../pic/" + new String(pAlarmer.sDeviceIP).trim() +
                                "_" + strPollingPicTime + "_PollingPic.jpg";
                        fout = new FileOutputStream(filename);
                        //将字节写入文件
                        long offset = 0;
                        ByteBuffer buffers = strAiopPollingPic.pBufferPicture.getByteBuffer(offset, strAiopPollingPic.dwPictureSize);
                        byte[] bytes = new byte[strAiopPollingPic.dwPictureSize];
                        buffers.rewind();
                        buffers.get(bytes);
                        fout.write(bytes);
                        fout.close();
                    } catch (FileNotFoundException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }

                break;
            //AI开放平台接入轮询视频检测报警信息
            case HCNetSDK.COMM_UPLOAD_AIOP_POLLING_VIDEO:
                System.out.println("AI开放平台接入轮询视频检测报警事件上传");
                HCNetSDK.NET_AIOP_POLLING_VIDEO_HEAD strAiopPollingVideo = new HCNetSDK.NET_AIOP_POLLING_VIDEO_HEAD();
                strAiopPollingVideo.write();
                Pointer pAiopPollingVideo = strAiopPollingVideo.getPointer();
                pAiopPollingVideo.write(0, pAlarmInfo.getByteArray(0, strAiopPollingVideo.size()), 0, strAiopPollingVideo.size());
                strAiopPollingVideo.read();
                System.out.println("通道号：" + strAiopPollingVideo.dwChannel);
                System.out.println("轮询视频任务ID：" + new String(strAiopPollingVideo.szTaskID));
                String AiopPollingVideoTime = "" + String.format("%04d", strAiopPollingVideo.struTime.wYear) +
                        String.format("%02d", strAiopPollingVideo.struTime.wMonth) +
                        String.format("%02d", strAiopPollingVideo.struTime.wDay) +
                        String.format("%02d", strAiopPollingVideo.struTime.wHour) +
                        String.format("%02d", strAiopPollingVideo.struTime.wMinute) +
                        String.format("%02d", strAiopPollingVideo.struTime.wSecond) +
                        String.format("%03d", strAiopPollingVideo.struTime.wMilliSec);
                //AIOPData数据保存
                if (strAiopPollingVideo.dwAIOPDataSize > 0) {
                    FileOutputStream fout;
                    try {
                        String filename = "../pic/" + new String(pAlarmer.sDeviceIP).trim() +
                                "_" + AiopPollingVideoTime + "_PollingVideoData.json";
                        fout = new FileOutputStream(filename);
                        //将字节写入文件
                        long offset = 0;
                        ByteBuffer buffers = strAiopPollingVideo.pBufferAIOPData.getByteBuffer(offset, strAiopPollingVideo.dwAIOPDataSize);
                        byte[] bytes = new byte[strAiopPollingVideo.dwAIOPDataSize];
                        buffers.rewind();
                        buffers.get(bytes);
                        fout.write(bytes);
                        fout.close();
                    } catch (FileNotFoundException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                //对应分析图片数据
                if (strAiopPollingVideo.dwPictureSize > 0) {
                    FileOutputStream fout;
                    try {
                        String filename = "../pic/" + new String(pAlarmer.sDeviceIP).trim() +
                                "_" + AiopPollingVideoTime + "_PollingVideo.jpg";
                        fout = new FileOutputStream(filename);
                        //将字节写入文件
                        long offset = 0;
                        ByteBuffer buffers = strAiopPollingVideo.pBufferPicture.getByteBuffer(offset, strAiopPollingVideo.dwPictureSize);
                        byte[] bytes = new byte[strAiopPollingVideo.dwPictureSize];
                        buffers.rewind();
                        buffers.get(bytes);
                        fout.write(bytes);
                        fout.close();
                    } catch (FileNotFoundException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } catch (IOException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                break;
            default:
                System.out.println("报警类型" + Integer.toHexString(lCommand));
                break;
        }
    }
}






 igds-protocol-sdk/src/main/java/com/ld/igds/protocol/hk/common/HCNetSDK.java

¶Ô±ÈÐÂÎļþ
ÎļþÌ«´ó

 igds-protocol-sdk/src/main/java/com/ld/igds/protocol/hk/common/LPRCallBask_V31.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,164 @@

package com.ld.igds.protocol.hk.common;

import com.ld.igds.inout.dto.ApiInoutData;
import com.ld.igds.inout.manager.InoutEventControlManager;
import com.ld.igds.protocol.hk.HKConstant;
import com.ld.igds.util.SpringUtil;
import com.sun.jna.Pointer;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.nio.ByteBuffer;
import java.text.SimpleDateFormat;
import java.util.Date;


/**
 * è½¦ç‰Œè¯†åˆ«å›žè°ƒå‡½æ•°
 */
public class LPRCallBask_V31 implements HCNetSDK.FMSGCallBack_V31 {

    Logger log = LoggerFactory.getLogger(LPRCallBask_V31.class);


    private InoutEventControlManager inoutEventControlManager;


    //报警信息回调函数
    public boolean invoke(int lCommand, HCNetSDK.NET_DVR_ALARMER pAlarmer, Pointer pAlarmInfo, int dwBufLen, Pointer pUser) {
        AlarmDataHandle(lCommand, pAlarmer, pAlarmInfo, dwBufLen, pUser);
        return true;
    }

    public void AlarmDataHandle(int lCommand, HCNetSDK.NET_DVR_ALARMER pAlarmer, Pointer pAlarmInfo, int dwBufLen, Pointer pUser) {
        log.info("报警事件类型： lCommand:" + Integer.toHexString(lCommand));

        String MonitoringSiteID;
        //lCommand是传的报警类型
        switch (lCommand) {

            case HCNetSDK.COMM_ITS_PLATE_RESULT://交通抓拍结果(新报警信息)
                HCNetSDK.NET_ITS_PLATE_RESULT strItsPlateResult = new HCNetSDK.NET_ITS_PLATE_RESULT();
                strItsPlateResult.write();
                Pointer pItsPlateInfo = strItsPlateResult.getPointer();
                pItsPlateInfo.write(0, pAlarmInfo.getByteArray(0, strItsPlateResult.size()), 0, strItsPlateResult.size());
                strItsPlateResult.read();
                try {
                    String sLicense = new String(strItsPlateResult.struPlateInfo.sLicense, "GBK");
                    byte VehicleType = strItsPlateResult.byVehicleType;  //0-其他车辆，1-小型车，2-大型车，3- è¡Œäººè§¦å‘，4- äºŒè½®è½¦è§¦å‘，5- ä¸‰è½®è½¦è§¦å‘，6- æœºåŠ¨è½¦è§¦å‘
                    MonitoringSiteID = new String(strItsPlateResult.byMonitoringSiteID);

                    String deviceIp = new String(pAlarmer.sDeviceIP, "GBK");
                    String deviceSn = new String(pAlarmer.sSerialNumber, "GBK");

                    if (StringUtils.isNotEmpty(sLicense)) sLicense = sLicense.trim();
                    if (StringUtils.isNotEmpty(deviceSn)) deviceSn = deviceSn.trim();
                    if (StringUtils.isNotEmpty(deviceIp)) deviceIp = deviceIp.trim();


                    log.info("车牌号：" + sLicense + ":车辆类型：" + VehicleType + ":监控点编号：" + MonitoringSiteID + "-设备IP=" + deviceIp + "-SN=" + deviceSn);

                    ApiInoutData data = HKConstant.getDataBySn(deviceSn);
                    if (null != data) {
                        data.setPlateNum(sLicense.substring(1));
                        data.setErrorMsg(HKConstant.RESULT_SUCCESS);
                        data.setTime(new Date());
                        HKConstant.updateLprMap(deviceSn, data);

                        if (inoutEventControlManager == null) {
                            inoutEventControlManager = SpringUtil.getBean(InoutEventControlManager.class);
                            inoutEventControlManager.onReceivePlateNum(data);
                        }

                    }

                } catch (IOException e) {
                    e.printStackTrace();
                }


                //报警图片保存，车牌，车辆图片
                for (int i = 0; i < strItsPlateResult.dwPicNum; i++) {
                    if (strItsPlateResult.struPicInfo[i].dwDataLen > 0) {
                        SimpleDateFormat sf = new SimpleDateFormat("yyyyMMddHHmmss");
                        String newName = sf.format(new Date());
                        FileOutputStream fout;
                        try {
                            // String filename = "../pic/" + newName + "_type[" + strItsPlateResult.struPicInfo[i].byType + "]_ItsPlate.jpg";

                            String basePath = HKConstant.getImgBasePath(false);

                            String filename = basePath + newName + ".jpg";
                            fout = new FileOutputStream(filename);
                            //将字节写入文件
                            long offset = 0;
                            ByteBuffer buffers = strItsPlateResult.struPicInfo[i].pBuffer.getByteBuffer(offset, strItsPlateResult.struPicInfo[i].dwDataLen);
                            byte[] bytes = new byte[strItsPlateResult.struPicInfo[i].dwDataLen];
                            buffers.rewind();
                            buffers.get(bytes);
                            fout.write(bytes);
                            fout.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
                break;
            case HCNetSDK.COMM_ITS_PARK_VEHICLE: //停车场数据上传
                HCNetSDK.NET_ITS_PARK_VEHICLE strParkVehicle = new HCNetSDK.NET_ITS_PARK_VEHICLE();
                strParkVehicle.write();
                Pointer pstrParkVehicle = strParkVehicle.getPointer();
                pstrParkVehicle.write(0, pAlarmInfo.getByteArray(0, strParkVehicle.size()), 0, strParkVehicle.size());
                strParkVehicle.read();
                try {
                    //  byte ParkError = strParkVehicle.byParkError; //停车异常：0- æ­£å¸¸ï¼Œ1- å¼‚常
                    //   String ParkingNo = new String(strParkVehicle.byParkingNo, "UTF-8"); //车位编号
                    byte LocationStatus = strParkVehicle.byLocationStatus; //车位车辆状态 0- æ— è½¦ï¼Œ1- æœ‰è½¦
                    MonitoringSiteID = strParkVehicle.byMonitoringSiteID.toString();
                    String plateNo = new String(strParkVehicle.struPlateInfo.sLicense, "GBK"); //车牌号

                    log.info("车牌号：" + plateNo + ":车位状态：" + LocationStatus + ":监控点编号：" + MonitoringSiteID);
                } catch (UnsupportedEncodingException e) {
                    e.printStackTrace();
                }
                //报警图片信息
                for (int i = 0; i < strParkVehicle.dwPicNum; i++) {
                    if (strParkVehicle.struPicInfo[i].dwDataLen > 0) {
                        SimpleDateFormat sf = new SimpleDateFormat("yyyyMMddHHmmss");
                        String newName = sf.format(new Date());
                        FileOutputStream fout;
                        try {
                            String basePath = HKConstant.getImgBasePath(false);
                            String filename = basePath + newName + "_ParkVehicle.jpg";
                            fout = new FileOutputStream(filename);
                            //将字节写入文件
                            long offset = 0;
                            ByteBuffer buffers = strParkVehicle.struPicInfo[i].pBuffer.getByteBuffer(offset, strParkVehicle.struPicInfo[i].dwDataLen);
                            byte[] bytes = new byte[strParkVehicle.struPicInfo[i].dwDataLen];
                            buffers.rewind();
                            buffers.get(bytes);
                            fout.write(bytes);
                            fout.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
                break;
            default:
                System.out.println("报警类型" + Integer.toHexString(lCommand));
                break;
        }
    }
}






 igds-protocol-sdk/src/main/java/com/ld/igds/protocol/hk/common/OsSelect.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,16 @@
package com.ld.igds.protocol.hk.common;

/**
 * @author
 * @create 2022-01-19-16:40
 */
public class OsSelect {

    public static boolean isLinux() {
        return System.getProperty("os.name").toLowerCase().contains("linux");
    }

    public static boolean isWindows() {
        return System.getProperty("os.name").toLowerCase().contains("windows");
    }
}

 igds-protocol-sdk/src/main/java/com/ld/igds/protocol/hk/lpr/AlarmLpr.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,196 @@
package com.ld.igds.protocol.hk.lpr;

import com.ld.igds.protocol.hk.HKConstant;
import com.ld.igds.protocol.hk.common.HCNetSDK;
import com.ld.igds.protocol.hk.common.LPRCallBask_V31;
import com.ld.igds.protocol.hk.common.OsSelect;
import com.sun.jna.Native;
import com.sun.jna.Pointer;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;



/**
 * æµ·åº·è½¦ç‰Œè¯†åˆ«ç›‘听控制，使用在宁夏石嘴山项目
 */
public class AlarmLpr {

    Logger log = LoggerFactory.getLogger(AlarmLpr.class);

    static HCNetSDK hCNetSDK = null;
    static int[] lUserID = new int[]{0, 0, 0, 0, 0};//用户句柄 å®žçŽ°å¯¹è®¾å¤‡ç™»å½•
    static int[] lAlarmHandle = new int[]{-1, -1, -1, -1, -1};//报警布防句柄
    static int lListenHandle = -1;//报警监听句柄
    static LPRCallBask_V31 fMSFCallBack_V31 = null;


    /**
     * SDK初始化
     *
     * @return
     */
    public String initSdk() {
        if (hCNetSDK == null) {
            synchronized (HCNetSDK.class) {
                String strDllPath = "";
                try {
                    if (OsSelect.isWindows())
                        strDllPath = HKConstant.SDK_DIR_WIN + "\\HCNetSDK.dll";
                    else if (OsSelect.isLinux())
                        strDllPath = HKConstant.SDK_DIR_LINUX + "/libhcnetsdk.so";
                    hCNetSDK = (HCNetSDK) Native.loadLibrary(strDllPath, HCNetSDK.class);
                } catch (Exception ex) {
                    // System.out.println("loadLibrary: " + strDllPath + " Error: " + ex.getMessage());
                    log.error("loadLibrary: " + strDllPath + " Error: " + ex.getMessage());

                    return "ERROR:loadLibrary: " + strDllPath + " Error: " + ex.getMessage();
                }
            }
        }

        String logBasePath = HKConstant.getLogBasePath(OsSelect.isLinux());

        //初始化
        hCNetSDK.NET_DVR_Init();

        //加载日志
        hCNetSDK.NET_DVR_SetLogToFile(3, logBasePath, false);

        //设置报警回调函数
        if (fMSFCallBack_V31 == null) {
            fMSFCallBack_V31 = new LPRCallBask_V31();
            Pointer pUser = null;
            if (!hCNetSDK.NET_DVR_SetDVRMessageCallBack_V31(fMSFCallBack_V31, pUser)) {
                log.error("设置回调函数失败!");
                return "ERROR：设置回调函数失败!";
            } else {
                log.debug("设置回调函数失败!");
            }
        }


        //配置警告监听
        HCNetSDK.NET_DVR_LOCAL_GENERAL_CFG struNET_DVR_LOCAL_GENERAL_CFG = new HCNetSDK.NET_DVR_LOCAL_GENERAL_CFG();
        struNET_DVR_LOCAL_GENERAL_CFG.byAlarmJsonPictureSeparate = 1;   //设置JSON透传报警数据和图片分离
        struNET_DVR_LOCAL_GENERAL_CFG.write();
        Pointer pStrNET_DVR_LOCAL_GENERAL_CFG = struNET_DVR_LOCAL_GENERAL_CFG.getPointer();
        hCNetSDK.NET_DVR_SetSDKLocalCfg(17, pStrNET_DVR_LOCAL_GENERAL_CFG);

        return HKConstant.RESULT_SUCCESS;
    }


    /**
     * @param index    ç™»é™†é¡ºåº é»˜è®¤0 -4 åŒæ—¶åªèƒ½ç™»é™†5个设备，每个设备登陆的顺序，人为控制
     * @param ip
     * @param port
     * @param userName
     * @param pwd
     * @return
     */
    public String login(int index, String ip, int port, String userName, String pwd) {

        //登陆
        String msg = Login_V(index, ip, (short) port, userName, pwd);

        if (!HKConstant.RESULT_SUCCESS.equals(msg)) {
            return msg;
        }
        //启动事件监听
        msg = SetAlarm_V(index, ip, port);
        return msg;
    }

    /**
     * é€€å‡º
     *
     * @param ip
     * @param port
     * @return
     */
    public String logout(int index, String ip, int port) {

        int i = index;

        if (lAlarmHandle[i] > -1) {
            if (!hCNetSDK.NET_DVR_CloseAlarmChan(lAlarmHandle[i])) {
                log.debug(ip + ":" + port + "撤防成功");
            }
        }
        if (lListenHandle > -1) {
            if (!hCNetSDK.NET_DVR_StopListen_V30(lListenHandle)) {

                log.debug(ip + ":" + port + "停止监听成功");
            }
        }
        if (hCNetSDK.NET_DVR_Logout(lUserID[i])) {
            log.debug(ip + ":" + port + "注销成功");
        }

        hCNetSDK.NET_DVR_Cleanup();

        return HKConstant.RESULT_SUCCESS;
    }


    public String Login_V(int i, String ip, short port, String user, String psw) {
        //注册
        HCNetSDK.NET_DVR_USER_LOGIN_INFO m_strLoginInfo = new HCNetSDK.NET_DVR_USER_LOGIN_INFO();//设备登录信息
        HCNetSDK.NET_DVR_DEVICEINFO_V40 m_strDeviceInfo = new HCNetSDK.NET_DVR_DEVICEINFO_V40();//设备信息

        String m_sDeviceIP = ip;//设备ip地址
        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());

        String m_sUsername = user;//设备用户名
        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());

        String m_sPassword = psw;//设备密码
        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 = port;
        m_strLoginInfo.bUseAsynLogin = false; //是否异步登录：0- å¦ï¼Œ1- æ˜¯
//        m_strLoginInfo.byLoginMode=1;  //ISAPI登录
        m_strLoginInfo.write();

        lUserID[i] = hCNetSDK.NET_DVR_Login_V40(m_strLoginInfo, m_strDeviceInfo);
        if (lUserID[i] == -1) {
            log.error("ERROR:登录失败，错误码为" + hCNetSDK.NET_DVR_GetLastError());
            return "ERROR:登录失败，错误码为" + hCNetSDK.NET_DVR_GetLastError();

        }

        log.debug(ip + ":设备登录成功！");
        return HKConstant.RESULT_SUCCESS;
    }


    public String SetAlarm_V(int index, String ip, int port) {
        if (lAlarmHandle[index] < 0) { //尚未布防,需要布防
            //报警布防参数设置
            HCNetSDK.NET_DVR_SETUPALARM_PARAM m_strAlarmInfo = new HCNetSDK.NET_DVR_SETUPALARM_PARAM();
            m_strAlarmInfo.dwSize = m_strAlarmInfo.size();
            m_strAlarmInfo.byLevel = 1;  //布防等级 0 ä¸€çº§ï¼Œ1二级
            m_strAlarmInfo.byAlarmInfoType = 1;   // æ™ºèƒ½äº¤é€šæŠ¥è­¦ä¿¡æ¯ä¸Šä¼ ç±»åž‹ï¼š0- è€æŠ¥è­¦ä¿¡æ¯ï¼ˆNET_DVR_PLATE_RESULT），1- æ–°æŠ¥è­¦ä¿¡æ¯(NET_ITS_PLATE_RESULT)
            m_strAlarmInfo.byDeployType = 0;   //布防类型：0-客户端布防，1-实时布防
            m_strAlarmInfo.write();
            lAlarmHandle[index] = hCNetSDK.NET_DVR_SetupAlarmChan_V41(lUserID[index], m_strAlarmInfo);
            log.debug("lAlarmHandle: " + lAlarmHandle[index]);
            if (lAlarmHandle[index] == -1) {
                log.error("ERROR:布防失败，错误码为" + hCNetSDK.NET_DVR_GetLastError());
                return "ERROR:布防失败，错误码为" + hCNetSDK.NET_DVR_GetLastError();
            } else {
                log.debug(ip + ":" + port + " å¸ƒé˜²æˆåŠŸ");
            }
        } else {
            log.warn(ip + ":" + port + " è®¾å¤‡å·²ç»å¸ƒé˜²ï¼Œè¯·å…ˆæ’¤é˜²ï¼");
        }

        return HKConstant.RESULT_SUCCESS;
    }

}

 igds-protocol-sdk/src/main/java/com/ld/igds/protocol/hk/lpr/HIKSDKStructure.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,29 @@
package com.ld.igds.protocol.hk.lpr;

import com.sun.jna.Structure;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.List;

public class HIKSDKStructure extends Structure {

    protected List<String> getFieldOrder(){
        List<String> fieldOrderList = new ArrayList<String>();
        for (Class<?> cls = getClass();
             !cls.equals(HIKSDKStructure.class);
             cls = cls.getSuperclass()) {
            Field[] fields = cls.getDeclaredFields();
            int modifiers;
            for (Field field : fields) {
                modifiers = field.getModifiers();
                if (Modifier.isStatic(modifiers) || !Modifier.isPublic(modifiers)) {
                    continue;
                }
                fieldOrderList.add(field.getName());
            }
        }
        return fieldOrderList;
    }
}

 igds-protocol-sdk/src/main/resources/lib/examples.jar

Binary files differ

 igds-protocol-sdk/src/main/resources/lib/jna.jar

Binary files differ

 igds-protocol-sdk/src/main/resources/lib/json.jar

Binary files differ

 pom.xml

@@ -41,10 +41,16 @@
        <module>igds-protocol-bhzn</module>
        <!--物联网拓展设备包-->
        <module>igds-protocol-iot</module>

        <!--SKD协议包-->
        <module>igds-protocol-sdk</module>

        <!--    æ‰‹æœºåŒ…    -->
        <module>igds-api-phone</module>
        <!--    æŽ¥å£åŒ…，包括三维接口    -->
        <module>igds-api-inte</module>


        <!-- å¯è§†åŒ–-->
        <module>igds-databoard</module>