大华摄像头sdk,红外测温接入

pom.xml

@@ -104,6 +104,14 @@
             <version>3.4.3</version>
         </dependency>
 
+        <dependency>
+            <groupId>net.dahua.netsdk</groupId>
+            <artifactId>dahua-netsdk-jni</artifactId>
+            <version>1.0.0</version>
+            <scope>compile</scope>
+            <!--            <systemPath>${project.basedir}/lib/INetSDK.jar</systemPath>-->
+        </dependency>
+
         <dependency>
             <groupId>net.java.jna</groupId>
             <artifactId>jna</artifactId>

src/main/java/com/inspect/nvr/config/DahuaConfig.java

@@ -0,0 +1,136 @@
+package com.inspect.nvr.config;
+
+
+
+import com.inspect.nvr.daHuaCarme.jna.NetSDKLib;
+import com.inspect.nvr.daHuaCarme.jna.osSelect;
+import com.inspect.nvr.daHuaCarme.utils.DateUtils;
+import com.inspect.nvr.hikVision.utils.jna.HCNetSDK;
+import com.sun.jna.Native;
+import com.sun.jna.Pointer;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+import java.io.File;
+
+/**
+ * @program: standard
+ * @description: 大华sdk配置类
+ * @author: 刺客
+ * @create: 2023-03-17 17:48
+ */
+@Configuration
+public class DahuaConfig {
+
+//    @Autowired
+    public NetSDKLib dhNetSDK;
+
+//    @Autowired
+//    private fSnapReceiveCB fSnapReceiveCB;
+
+    private static DisConnect disConnect=new DisConnect();
+
+    private static HaveReConnect haveReConnect=new HaveReConnect();
+
+
+
+    private static boolean bLogopen = false;
+
+    @Bean
+    public NetSDKLib initDhSDK(){
+//        if (!instance()) {
+//            System.out.println("Load DaHua SDK fail");
+//            return null;
+//        }
+        dhNetSDK= NetSDKLib.NETSDK_INSTANCE;
+        boolean bInit = dhNetSDK.CLIENT_Init(disConnect,null);
+        if(!bInit) {
+            System.out.println("Initialize SDK failed");
+            return null;
+        }
+
+        //打开日志，可选
+        NetSDKLib.LOG_SET_PRINT_INFO setLog = new NetSDKLib.LOG_SET_PRINT_INFO();
+        File path = new File("sdklog/");
+        if (!path.exists()) {
+            path.mkdir();
+        }
+        String logPath = path.getAbsoluteFile().getParent() + "\\sdklog\\" + DateUtils.getDate() + ".log";
+        setLog.nPrintStrategy = 0;
+        setLog.bSetFilePath = 1;
+        System.arraycopy(logPath.getBytes(), 0, setLog.szLogFilePath, 0, logPath.getBytes().length);
+        System.out.println(logPath);
+        setLog.bSetPrintStrategy = 1;
+        bLogopen = dhNetSDK.CLIENT_LogOpen(setLog);
+        if(!bLogopen ) {
+            System.err.println("Failed to open NetSDK log");
+        }
+
+        // 设置断线重连回调接口，设置过断线重连成功回调函数后，当设备出现断线情况，SDK内部会自动进行重连操作
+        // 此操作为可选操作，但建议用户进行设置
+        dhNetSDK.CLIENT_SetAutoReconnect(haveReConnect, null);
+
+        //设置登录超时时间和尝试次数，可选
+        int waitTime = 5000; //登录请求响应超时时间设置为5S
+        int tryTimes = 1;    //登录时尝试建立链接1次
+        dhNetSDK.CLIENT_SetConnectTime(waitTime, tryTimes);
+
+
+        // 设置更多网络参数，NET_PARAM的nWaittime，nConnectTryNum成员与CLIENT_SetConnectTime
+        // 接口设置的登录设备超时时间和尝试次数意义相同,可选
+        NetSDKLib.NET_PARAM netParam = new NetSDKLib.NET_PARAM();
+        netParam.nConnectTime = 10000;      // 登录时尝试建立链接的超时时间
+        netParam.nGetConnInfoTime = 3000;   // 设置子连接的超时时间
+        netParam.nGetDevInfoTime = 3000;//获取设备信息超时时间，为0默认1000ms
+        dhNetSDK.CLIENT_SetNetworkParam(netParam);
+//        dhNetSDK.CLIENT_SetSnapRevCallBack(fSnapReceiveCB,null);
+        System.out.println("Dahua Sdk Init Successfully" );
+        return dhNetSDK;
+
+    }
+
+    // 设备断线回调: 通过 CLIENT_Init 设置该回调函数，当设备出现断线时，SDK会调用该函数
+    private static class DisConnect implements NetSDKLib.fDisConnect {
+        public void invoke(NetSDKLib.LLong m_hLoginHandle, String pchDVRIP, int nDVRPort, Pointer dwUser) {
+            System.out.printf("Device[%s] Port[%d] DisConnect!\n", pchDVRIP, nDVRPort);
+
+        }
+    }
+
+    // 网络连接恢复，设备重连成功回调
+    // 通过 CLIENT_SetAutoReconnect 设置该回调函数，当已断线的设备重连成功时，SDK会调用该函数
+    private static class HaveReConnect implements NetSDKLib.fHaveReConnect {
+        public void invoke(NetSDKLib.LLong m_hLoginHandle, String pchDVRIP, int nDVRPort, Pointer dwUser) {
+            System.out.printf("ReConnect Device[%s] Port[%d]\n", pchDVRIP, nDVRPort);
+
+        }
+    }
+
+    public boolean instance(){
+        if (dhNetSDK==null){
+//            try {
+//                dhNetSDK = (NetSDKLib) Native.loadLibrary(LibraryLoad.getLoadLibrary("dhnetsdk"), HCNetSDK.class);
+//            }catch (Exception e){
+//                System.out.println("loadLibrary: Error: " + e.getMessage());
+//                return false;
+//            }
+            synchronized (NetSDKLib.class) {
+                String strDllPath = "";
+                try {
+                    if (osSelect.isWindows())
+                        //win系统加载库路径
+                        strDllPath = System.getProperty("user.dir") + "\\lib\\win64\\dhnetsdk.dll";
+
+                    else if (osSelect.isLinux())
+                        //Linux系统加载库路径
+                        strDllPath = System.getProperty("user.dir") + "/lib/linux64/dhnetsdk.so";
+                    dhNetSDK = (NetSDKLib) Native.loadLibrary(strDllPath, HCNetSDK.class);
+                } catch (Exception ex) {
+                    System.out.println("loadLibrary: " + strDllPath + " Error: " + ex.getMessage());
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}

src/main/java/com/inspect/nvr/controller/DahuaController.java

@@ -0,0 +1,37 @@
+package com.inspect.nvr.controller;
+
+
+import com.inspect.nvr.domain.Infrared.Camera;
+import com.inspect.nvr.domain.Infrared.NvrInfo;
+import com.inspect.nvr.service.DahuaService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.*;
+
+@Controller
+@RequestMapping("/dahua")
+public class DahuaController {
+
+    @Autowired
+    private DahuaService dahuaService;
+
+
+    @PostMapping("/login")
+    @CrossOrigin
+    @ResponseBody
+    public void login(@RequestBody NvrInfo nvrInfo) {
+        dahuaService.login(nvrInfo);
+    }
+
+
+    @PostMapping("/StartRemote")
+    @CrossOrigin
+    @ResponseBody
+    public String StartRemote(@RequestBody Camera camera) {
+        return dahuaService.StartRemote(camera);
+    }
+
+
+
+
+}

src/main/java/com/inspect/nvr/daHuaCarme/callback/fRedirectServerCallBackEx.java

@@ -0,0 +1,41 @@
+package com.inspect.nvr.daHuaCarme.callback;
+
+
+import com.inspect.nvr.daHuaCarme.jna.NetSDKLib;
+import com.inspect.nvr.daHuaCarme.jna.dahua.ToolKits;
+import com.inspect.nvr.daHuaCarme.jna.dahua.structure.NET_CB_REDIRECT_SERVER_CALLBACK_INFO;
+import com.inspect.nvr.daHuaCarme.jna.dahua.structure.NET_IN_START_REDIRECT_SERVICE;
+import com.sun.jna.Callback;
+import com.sun.jna.Pointer;
+
+/**
+ * @author 47081
+ * @version 1.0
+ * @description 重定向服务器回调函数原形扩展
+ * @date 2021/3/13
+ */
+public interface fRedirectServerCallBackEx extends Callback {
+  /**
+   * @param lDevHandle 设备句柄
+   * @param pInParam 设备信息,对应结构体{@link NET_CB_REDIRECT_SERVER_CALLBACK_INFO}
+   * @param dwUserData 自定义数据,该自定义数据为{@link
+   *     NET_IN_START_REDIRECT_SERVICE#dwUserData}传入的数据,注意保证dwUser不会被jvm回收,
+   *     否则回调中接收到的dwUser可能乱码，甚至导致程序崩溃
+   * @return
+   */
+  default int callback(NetSDKLib.LLong lDevHandle, Pointer pInParam, Pointer dwUserData) {
+    NET_CB_REDIRECT_SERVER_CALLBACK_INFO info = new NET_CB_REDIRECT_SERVER_CALLBACK_INFO();
+    ToolKits.GetPointerDataToStruct(pInParam, 0, info);
+    dealWithData(lDevHandle.longValue(), info, dwUserData);
+    return 0;
+  }
+
+  /**
+   * 数据处理
+   *
+   * @param devHandler 设备句柄
+   * @param info 主动注册重定向设备信息
+   * @param userData 用户数据
+   */
+  void dealWithData(long devHandler, NET_CB_REDIRECT_SERVER_CALLBACK_INFO info, Pointer userData);
+}

src/main/java/com/inspect/nvr/daHuaCarme/callback/fVideoStatHeatMapCallBack.java

@@ -0,0 +1,29 @@
+package com.inspect.nvr.daHuaCarme.callback;
+
+
+
+import com.inspect.nvr.daHuaCarme.jna.NetSDKLib;
+import com.sun.jna.Callback;
+import com.sun.jna.Pointer;
+
+/**
+ * @author 47081
+ * @version 1.0
+ * @description 热度图数据回调
+ * @date 2020/9/21
+ */
+public interface fVideoStatHeatMapCallBack extends Callback {
+  /**
+   * @param lAttachHandle 订阅句柄
+   * @param pBuf 回调上来的数据，对应结构体{@link com.netsdk.lib.structure.NET_CB_VIDEOSTAT_HEATMAP}
+   * @param pBinData 回调上来的二进制数据
+   * @param dwBinDataLen 二进制数据长度
+   * @param dwUser 用户数据
+   */
+  void invoke(
+      NetSDKLib.LLong lAttachHandle,
+      Pointer pBuf,
+      Pointer pBinData,
+      int dwBinDataLen,
+      Pointer dwUser);
+}

src/main/java/com/inspect/nvr/daHuaCarme/callback/securityCheck/fNotifyPopulationStatisticsInfo.java

@@ -0,0 +1,22 @@
+package com.inspect.nvr.daHuaCarme.callback.securityCheck;
+
+
+import com.inspect.nvr.daHuaCarme.jna.NetSDKLib;
+import com.sun.jna.Callback;
+import com.sun.jna.Pointer;
+
+
+/**
+ * @author ： 291189
+ * @since ： Created in 2021/7/5
+// 接口 CLIENT_AttachPopulationStatistics 回调函数
+// pstuPopulationStatisticsInfos 人数变化信息
+ */
+public interface fNotifyPopulationStatisticsInfo extends Callback {
+
+    void invoke(
+            NetSDKLib.LLong lPopulationStatisticsHandle,
+            Pointer pstuPopulationStatisticsInfos,
+            Pointer dwUser);
+    //typedef int (CALLBACK *fNotifyPopulationStatisticsInfo)(LLONG lPopulationStatisticsHandle, NET_POPULATION_STATISTICS_INFO* pstuPopulationStatisticsInfos, LDWORD dwUser);
+}

src/main/java/com/inspect/nvr/daHuaCarme/callback/securityCheck/fSecurityGateAttachAlarmStatistics.java

@@ -0,0 +1,27 @@
+package com.inspect.nvr.daHuaCarme.callback.securityCheck;
+
+
+import com.inspect.nvr.daHuaCarme.jna.NetSDKLib;
+import com.sun.jna.Callback;
+import com.sun.jna.Pointer;
+
+/**
+ * @author 291189
+ * @version 1.0
+ * @description 安全门报警订阅回调函数
+ * @date 2021/6/29
+ */
+public interface fSecurityGateAttachAlarmStatistics extends Callback{
+
+    /**
+     * @param lAttachHandle 订阅句柄
+     * @param pInfo 安全门报警统计信息，对应结构体{@link com.netsdk.lib.structure.NET_SECURITYGATE_ALARM_STATISTICS_INFO}
+     * @param dwUser 用户数据
+     */
+    void invoke(
+            NetSDKLib.LLong lAttachHandle,
+            Pointer pInfo,
+            Pointer dwUser);
+
+   // (LLONG lAttachHandle, NET_SECURITYGATE_ALARM_STATISTICS_INFO* pInfo, LDWORD dwUser);
+}

src/main/java/com/inspect/nvr/daHuaCarme/callback/securityCheck/fXRayAttachPackageStatistics.java

@@ -0,0 +1,24 @@
+package com.inspect.nvr.daHuaCarme.callback.securityCheck;
+
+
+import com.inspect.nvr.daHuaCarme.jna.NetSDKLib;
+import com.sun.jna.Callback;
+import com.sun.jna.Pointer;
+/**
+ * @author 291189
+ * @version 1.0
+ * @description  包裹信息回调函数
+ * @date 2021/7/1
+ */
+public interface fXRayAttachPackageStatistics extends Callback {
+    /**
+     * @param lAttachHandle 订阅句柄
+     * @param pInfo 包裹信息回调函数，对应结构体{@link com.netsdk.lib.structure.NET_IN_XRAY_PACKAGE_STATISTICS_INFO}
+     * @param dwUser 用户数据
+     */
+    void invoke(
+            NetSDKLib.LLong lAttachHandle,
+            Pointer pInfo,
+            Pointer dwUser);
+
+}

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/LastError.java

@@ -0,0 +1,497 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua;
+
+/**
+ * 错误类型代号，对应CLIENT_GetLastError接口的返回值, 十进制
+ *
+ * @author 29779
+ */
+public class LastError {
+    public static final int NET_NOERROR = 0;               // 没有错误
+    public static final int NET_ERROR = -1;               // 未知错误
+    public static final int NET_SYSTEM_ERROR = (0x80000000 | 1);   // Windows系统出错
+    public static final int NET_NETWORK_ERROR = (0x80000000 | 2);   // 网络错误，可能是因为网络超时
+    public static final int NET_DEV_VER_NOMATCH = (0x80000000 | 3);   // 设备协议不匹配
+    public static final int NET_INVALID_HANDLE = (0x80000000 | 4);   // 句柄无效
+    public static final int NET_OPEN_CHANNEL_ERROR = (0x80000000 | 5);   // 打开通道失败
+    public static final int NET_CLOSE_CHANNEL_ERROR = (0x80000000 | 6);   // 关闭通道失败
+    public static final int NET_ILLEGAL_PARAM = (0x80000000 | 7);   // 用户参数不合法
+    public static final int NET_SDK_INIT_ERROR = (0x80000000 | 8);   // SDK初始化出错
+    public static final int NET_SDK_UNINIT_ERROR = (0x80000000 | 9);   // SDK清理出错
+    public static final int NET_RENDER_OPEN_ERROR = (0x80000000 | 10);  // 申请render资源出错
+    public static final int NET_DEC_OPEN_ERROR = (0x80000000 | 11);  // 打开解码库出错
+    public static final int NET_DEC_CLOSE_ERROR = (0x80000000 | 12);  // 关闭解码库出错
+    public static final int NET_MULTIPLAY_NOCHANNEL = (0x80000000 | 13);  // 多画面预览中检测到通道数为0
+    public static final int NET_TALK_INIT_ERROR = (0x80000000 | 14);  // 录音库初始化失败
+    public static final int NET_TALK_NOT_INIT = (0x80000000 | 15);  // 录音库未经初始化
+    public static final int NET_TALK_SENDDATA_ERROR = (0x80000000 | 16);  // 发送音频数据出错
+    public static final int NET_REAL_ALREADY_SAVING = (0x80000000 | 17);  // 实时数据已经处于保存状态
+    public static final int NET_NOT_SAVING = (0x80000000 | 18);  // 未保存实时数据
+    public static final int NET_OPEN_FILE_ERROR = (0x80000000 | 19);  // 打开文件出错
+    public static final int NET_PTZ_SET_TIMER_ERROR = (0x80000000 | 20);  // 启动云台控制定时器失败
+    public static final int NET_RETURN_DATA_ERROR = (0x80000000 | 21);  // 对返回数据的校验出错
+    public static final int NET_INSUFFICIENT_BUFFER = (0x80000000 | 22);  // 没有足够的缓存
+    public static final int NET_NOT_SUPPORTED = (0x80000000 | 23);  // 当前SDK未支持该功能
+    public static final int NET_NO_RECORD_FOUND = (0x80000000 | 24);  // 查询不到录像
+    public static final int NET_NOT_AUTHORIZED = (0x80000000 | 25);  // 无操作权限
+    public static final int NET_NOT_NOW = (0x80000000 | 26);  // 暂时无法执行
+    public static final int NET_NO_TALK_CHANNEL = (0x80000000 | 27);  // 未发现对讲通道
+    public static final int NET_NO_AUDIO = (0x80000000 | 28);  // 未发现音频
+    public static final int NET_NO_INIT = (0x80000000 | 29);  // 网络SDK未经初始化
+    public static final int NET_DOWNLOAD_END = (0x80000000 | 30);  // 下载已结束
+    public static final int NET_EMPTY_LIST = (0x80000000 | 31);  // 查询结果为空
+    public static final int NET_ERROR_GETCFG_SYSATTR = (0x80000000 | 32);  // 获取系统属性配置失败
+    public static final int NET_ERROR_GETCFG_SERIAL = (0x80000000 | 33);  // 获取序列号失败
+    public static final int NET_ERROR_GETCFG_GENERAL = (0x80000000 | 34);  // 获取常规属性失败
+    public static final int NET_ERROR_GETCFG_DSPCAP = (0x80000000 | 35);  // 获取DSP能力描述失败
+    public static final int NET_ERROR_GETCFG_NETCFG = (0x80000000 | 36);  // 获取网络配置失败
+    public static final int NET_ERROR_GETCFG_CHANNAME = (0x80000000 | 37);  // 获取通道名称失败
+    public static final int NET_ERROR_GETCFG_VIDEO = (0x80000000 | 38);  // 获取视频属性失败
+    public static final int NET_ERROR_GETCFG_RECORD = (0x80000000 | 39);  // 获取录象配置失败
+    public static final int NET_ERROR_GETCFG_PRONAME = (0x80000000 | 40);  // 获取解码器协议名称失败
+    public static final int NET_ERROR_GETCFG_FUNCNAME = (0x80000000 | 41);  // 获取232串口功能名称失败
+    public static final int NET_ERROR_GETCFG_485DECODER = (0x80000000 | 42);  // 获取解码器属性失败
+    public static final int NET_ERROR_GETCFG_232COM = (0x80000000 | 43);  // 获取232串口配置失败
+    public static final int NET_ERROR_GETCFG_ALARMIN = (0x80000000 | 44);  // 获取外部报警输入配置失败
+    public static final int NET_ERROR_GETCFG_ALARMDET = (0x80000000 | 45);  // 获取动态检测报警失败
+    public static final int NET_ERROR_GETCFG_SYSTIME = (0x80000000 | 46);  // 获取设备时间失败
+    public static final int NET_ERROR_GETCFG_PREVIEW = (0x80000000 | 47);  // 获取预览参数失败
+    public static final int NET_ERROR_GETCFG_AUTOMT = (0x80000000 | 48);  // 获取自动维护配置失败
+    public static final int NET_ERROR_GETCFG_VIDEOMTRX = (0x80000000 | 49);  // 获取视频矩阵配置失败
+    public static final int NET_ERROR_GETCFG_COVER = (0x80000000 | 50);  // 获取区域遮挡配置失败
+    public static final int NET_ERROR_GETCFG_WATERMAKE = (0x80000000 | 51);  // 获取图象水印配置失败
+    public static final int NET_ERROR_GETCFG_MULTICAST = (0x80000000 | 52);  // 获取配置失败位置：组播端口按通道配置
+    public static final int NET_ERROR_SETCFG_GENERAL = (0x80000000 | 55);  // 修改常规属性失败
+    public static final int NET_ERROR_SETCFG_NETCFG = (0x80000000 | 56);  // 修改网络配置失败
+    public static final int NET_ERROR_SETCFG_CHANNAME = (0x80000000 | 57);  // 修改通道名称失败
+    public static final int NET_ERROR_SETCFG_VIDEO = (0x80000000 | 58);  // 修改视频属性失败
+    public static final int NET_ERROR_SETCFG_RECORD = (0x80000000 | 59);  // 修改录象配置失败
+    public static final int NET_ERROR_SETCFG_485DECODER = (0x80000000 | 60);  // 修改解码器属性失败
+    public static final int NET_ERROR_SETCFG_232COM = (0x80000000 | 61);  // 修改232串口配置失败
+    public static final int NET_ERROR_SETCFG_ALARMIN = (0x80000000 | 62);  // 修改外部输入报警配置失败
+    public static final int NET_ERROR_SETCFG_ALARMDET = (0x80000000 | 63);  // 修改动态检测报警配置失败
+    public static final int NET_ERROR_SETCFG_SYSTIME = (0x80000000 | 64);  // 修改设备时间失败
+    public static final int NET_ERROR_SETCFG_PREVIEW = (0x80000000 | 65);  // 修改预览参数失败
+    public static final int NET_ERROR_SETCFG_AUTOMT = (0x80000000 | 66);  // 修改自动维护配置失败
+    public static final int NET_ERROR_SETCFG_VIDEOMTRX = (0x80000000 | 67);  // 修改视频矩阵配置失败
+    public static final int NET_ERROR_SETCFG_COVER = (0x80000000 | 68);  // 修改区域遮挡配置失败
+    public static final int NET_ERROR_SETCFG_WATERMAKE = (0x80000000 | 69);  // 修改图象水印配置失败
+    public static final int NET_ERROR_SETCFG_WLAN = (0x80000000 | 70);  // 修改无线网络信息失败
+    public static final int NET_ERROR_SETCFG_WLANDEV = (0x80000000 | 71);  // 选择无线网络设备失败
+    public static final int NET_ERROR_SETCFG_REGISTER = (0x80000000 | 72);  // 修改主动注册参数配置失败
+    public static final int NET_ERROR_SETCFG_CAMERA = (0x80000000 | 73);  // 修改摄像头属性配置失败
+    public static final int NET_ERROR_SETCFG_INFRARED = (0x80000000 | 74);  // 修改红外报警配置失败
+    public static final int NET_ERROR_SETCFG_SOUNDALARM = (0x80000000 | 75);  // 修改音频报警配置失败
+    public static final int NET_ERROR_SETCFG_STORAGE = (0x80000000 | 76);  // 修改存储位置配置失败
+    public static final int NET_AUDIOENCODE_NOTINIT = (0x80000000 | 77);  // 音频编码接口没有成功初始化
+    public static final int NET_DATA_TOOLONGH = (0x80000000 | 78);  // 数据过长
+    public static final int NET_UNSUPPORTED = (0x80000000 | 79);  // 设备不支持该操作
+    public static final int NET_DEVICE_BUSY = (0x80000000 | 80);  // 设备资源不足
+    public static final int NET_SERVER_STARTED = (0x80000000 | 81);  // 服务器已经启动
+    public static final int NET_SERVER_STOPPED = (0x80000000 | 82);  // 服务器尚未成功启动
+    public static final int NET_LISTER_INCORRECT_SERIAL = (0x80000000 | 83);  // 输入序列号有误
+    public static final int NET_QUERY_DISKINFO_FAILED = (0x80000000 | 84);  // 获取硬盘信息失败
+    public static final int NET_ERROR_GETCFG_SESSION = (0x80000000 | 85);  // 获取连接Session信息
+    public static final int NET_USER_FLASEPWD_TRYTIME = (0x80000000 | 86);  // 输入密码错误超过限制次数
+    public static final int NET_LOGIN_ERROR_PASSWORD = (0x80000000 | 100); // 密码不正确
+    public static final int NET_LOGIN_ERROR_USER = (0x80000000 | 101); // 帐户不存在
+    public static final int NET_LOGIN_ERROR_TIMEOUT = (0x80000000 | 102); // 等待登录返回超时
+    public static final int NET_LOGIN_ERROR_RELOGGIN = (0x80000000 | 103); // 帐号已登录
+    public static final int NET_LOGIN_ERROR_LOCKED = (0x80000000 | 104); // 帐号已被锁定
+    public static final int NET_LOGIN_ERROR_BLACKLIST = (0x80000000 | 105); // 帐号已被列为禁止名单
+    public static final int NET_LOGIN_ERROR_BUSY = (0x80000000 | 106); // 资源不足，系统忙
+    public static final int NET_LOGIN_ERROR_CONNECT = (0x80000000 | 107); // 登录设备超时，请检查网络并重试
+    public static final int NET_LOGIN_ERROR_NETWORK = (0x80000000 | 108); // 网络连接失败
+    public static final int NET_LOGIN_ERROR_SUBCONNECT = (0x80000000 | 109); // 登录设备成功，但无法创建视频通道，请检查网络状况
+    public static final int NET_LOGIN_ERROR_MAXCONNECT = (0x80000000 | 110); // 超过最大连接数
+    public static final int NET_LOGIN_ERROR_PROTOCOL3_ONLY = (0x80000000 | 111); // 只支持3代协议
+    public static final int NET_LOGIN_ERROR_UKEY_LOST = (0x80000000 | 112); // 未插入U盾或U盾信息错误
+    public static final int NET_LOGIN_ERROR_NO_AUTHORIZED = (0x80000000 | 113); // 客户端IP地址没有登录权限
+    public static final int NET_LOGIN_ERROR_USER_OR_PASSOWRD = (0x80000000 | 117); // 账号或密码错误
+    public static final int NET_LOGIN_ERROR_DEVICE_NOT_INIT = (0x80000000 | 118);    // 设备尚未初始化，不能登录，请先初始化设备
+    public static final int NET_RENDER_SOUND_ON_ERROR = (0x80000000 | 120); // Render库打开音频出错
+    public static final int NET_RENDER_SOUND_OFF_ERROR = (0x80000000 | 121); // Render库关闭音频出错
+    public static final int NET_RENDER_SET_VOLUME_ERROR = (0x80000000 | 122); // Render库控制音量出错
+    public static final int NET_RENDER_ADJUST_ERROR = (0x80000000 | 123); // Render库设置画面参数出错
+    public static final int NET_RENDER_PAUSE_ERROR = (0x80000000 | 124); // Render库暂停播放出错
+    public static final int NET_RENDER_SNAP_ERROR = (0x80000000 | 125); // Render库抓图出错
+    public static final int NET_RENDER_STEP_ERROR = (0x80000000 | 126); // Render库步进出错
+    public static final int NET_RENDER_FRAMERATE_ERROR = (0x80000000 | 127); // Render库设置帧率出错
+    public static final int NET_RENDER_DISPLAYREGION_ERROR = (0x80000000 | 128); // Render库设置显示区域出错
+    public static final int NET_RENDER_GETOSDTIME_ERROR = (0x80000000 | 129); // Render库获取当前播放时间出错
+    public static final int NET_GROUP_EXIST = (0x80000000 | 140); // 组名已存在
+    public static final int NET_GROUP_NOEXIST = (0x80000000 | 141); // 组名不存在
+    public static final int NET_GROUP_RIGHTOVER = (0x80000000 | 142); // 组的权限超出权限列表范围
+    public static final int NET_GROUP_HAVEUSER = (0x80000000 | 143); // 组下有用户，不能删除
+    public static final int NET_GROUP_RIGHTUSE = (0x80000000 | 144); // 组的某个权限被用户使用，不能删除
+    public static final int NET_GROUP_SAMENAME = (0x80000000 | 145); // 新组名同已有组名重复
+    public static final int NET_USER_EXIST = (0x80000000 | 146); // 用户已存在
+    public static final int NET_USER_NOEXIST = (0x80000000 | 147); // 用户不存在
+    public static final int NET_USER_RIGHTOVER = (0x80000000 | 148); // 用户权限超出组权限
+    public static final int NET_USER_PWD = (0x80000000 | 149); // 保留帐号，不容许修改密码
+    public static final int NET_USER_FLASEPWD = (0x80000000 | 150); // 密码不正确
+    public static final int NET_USER_NOMATCHING = (0x80000000 | 151); // 密码不匹配
+    public static final int NET_USER_INUSE = (0x80000000 | 152); // 账号正在使用中
+    public static final int NET_ERROR_GETCFG_ETHERNET = (0x80000000 | 300); // 获取网卡配置失败
+    public static final int NET_ERROR_GETCFG_WLAN = (0x80000000 | 301); // 获取无线网络信息失败
+    public static final int NET_ERROR_GETCFG_WLANDEV = (0x80000000 | 302); // 获取无线网络设备失败
+    public static final int NET_ERROR_GETCFG_REGISTER = (0x80000000 | 303); // 获取主动注册参数失败
+    public static final int NET_ERROR_GETCFG_CAMERA = (0x80000000 | 304); // 获取摄像头属性失败
+    public static final int NET_ERROR_GETCFG_INFRARED = (0x80000000 | 305); // 获取红外报警配置失败
+    public static final int NET_ERROR_GETCFG_SOUNDALARM = (0x80000000 | 306); // 获取音频报警配置失败
+    public static final int NET_ERROR_GETCFG_STORAGE = (0x80000000 | 307); // 获取存储位置配置失败
+    public static final int NET_ERROR_GETCFG_MAIL = (0x80000000 | 308); // 获取邮件配置失败
+    public static final int NET_CONFIG_DEVBUSY = (0x80000000 | 309); // 暂时无法设置
+    public static final int NET_CONFIG_DATAILLEGAL = (0x80000000 | 310); // 配置数据不合法
+    public static final int NET_ERROR_GETCFG_DST = (0x80000000 | 311); // 获取夏令时配置失败
+    public static final int NET_ERROR_SETCFG_DST = (0x80000000 | 312); // 设置夏令时配置失败
+    public static final int NET_ERROR_GETCFG_VIDEO_OSD = (0x80000000 | 313); // 获取视频OSD叠加配置失败
+    public static final int NET_ERROR_SETCFG_VIDEO_OSD = (0x80000000 | 314); // 设置视频OSD叠加配置失败
+    public static final int NET_ERROR_GETCFG_GPRSCDMA = (0x80000000 | 315); // 获取CDMA\GPRS网络配置失败
+    public static final int NET_ERROR_SETCFG_GPRSCDMA = (0x80000000 | 316); // 设置CDMA\GPRS网络配置失败
+    public static final int NET_ERROR_GETCFG_IPFILTER = (0x80000000 | 317); // 获取IP过滤配置失败
+    public static final int NET_ERROR_SETCFG_IPFILTER = (0x80000000 | 318); // 设置IP过滤配置失败
+    public static final int NET_ERROR_GETCFG_TALKENCODE = (0x80000000 | 319); // 获取语音对讲编码配置失败
+    public static final int NET_ERROR_SETCFG_TALKENCODE = (0x80000000 | 320); // 设置语音对讲编码配置失败
+    public static final int NET_ERROR_GETCFG_RECORDLEN = (0x80000000 | 321); // 获取录像打包长度配置失败
+    public static final int NET_ERROR_SETCFG_RECORDLEN = (0x80000000 | 322); // 设置录像打包长度配置失败
+    public static final int NET_DONT_SUPPORT_SUBAREA = (0x80000000 | 323); // 不支持网络硬盘分区
+    public static final int NET_ERROR_GET_AUTOREGSERVER = (0x80000000 | 324); // 获取设备上主动注册服务器信息失败
+    public static final int NET_ERROR_CONTROL_AUTOREGISTER = (0x80000000 | 325); // 主动注册重定向注册错误
+    public static final int NET_ERROR_DISCONNECT_AUTOREGISTER = (0x80000000 | 326); // 断开主动注册服务器错误
+    public static final int NET_ERROR_GETCFG_MMS = (0x80000000 | 327); // 获取mms配置失败
+    public static final int NET_ERROR_SETCFG_MMS = (0x80000000 | 328); // 设置mms配置失败
+    public static final int NET_ERROR_GETCFG_SMSACTIVATION = (0x80000000 | 329); // 获取短信激活无线连接配置失败
+    public static final int NET_ERROR_SETCFG_SMSACTIVATION = (0x80000000 | 330); // 设置短信激活无线连接配置失败
+    public static final int NET_ERROR_GETCFG_DIALINACTIVATION = (0x80000000 | 331); // 获取拨号激活无线连接配置失败
+    public static final int NET_ERROR_SETCFG_DIALINACTIVATION = (0x80000000 | 332); // 设置拨号激活无线连接配置失败
+    public static final int NET_ERROR_GETCFG_VIDEOOUT = (0x80000000 | 333); // 查询视频输出参数配置失败
+    public static final int NET_ERROR_SETCFG_VIDEOOUT = (0x80000000 | 334); // 设置视频输出参数配置失败
+    public static final int NET_ERROR_GETCFG_OSDENABLE = (0x80000000 | 335); // 获取osd叠加使能配置失败
+    public static final int NET_ERROR_SETCFG_OSDENABLE = (0x80000000 | 336); // 设置osd叠加使能配置失败
+    public static final int NET_ERROR_SETCFG_ENCODERINFO = (0x80000000 | 337); // 设置数字通道前端编码接入配置失败
+    public static final int NET_ERROR_GETCFG_TVADJUST = (0x80000000 | 338); // 获取TV调节配置失败
+    public static final int NET_ERROR_SETCFG_TVADJUST = (0x80000000 | 339); // 设置TV调节配置失败
+    public static final int NET_ERROR_CONNECT_FAILED = (0x80000000 | 340); // 请求建立连接失败
+    public static final int NET_ERROR_SETCFG_BURNFILE = (0x80000000 | 341); // 请求刻录文件上传失败
+    public static final int NET_ERROR_SNIFFER_GETCFG = (0x80000000 | 342); // 获取抓包配置信息失败
+    public static final int NET_ERROR_SNIFFER_SETCFG = (0x80000000 | 343); // 设置抓包配置信息失败
+    public static final int NET_ERROR_DOWNLOADRATE_GETCFG = (0x80000000 | 344); // 查询下载限制信息失败
+    public static final int NET_ERROR_DOWNLOADRATE_SETCFG = (0x80000000 | 345); // 设置下载限制信息失败
+    public static final int NET_ERROR_SEARCH_TRANSCOM = (0x80000000 | 346); // 查询串口参数失败
+    public static final int NET_ERROR_GETCFG_POINT = (0x80000000 | 347); // 获取预制点信息错误
+    public static final int NET_ERROR_SETCFG_POINT = (0x80000000 | 348); // 设置预制点信息错误
+    public static final int NET_SDK_LOGOUT_ERROR = (0x80000000 | 349); // SDK没有正常登出设备
+    public static final int NET_ERROR_GET_VEHICLE_CFG = (0x80000000 | 350); // 获取车载配置失败
+    public static final int NET_ERROR_SET_VEHICLE_CFG = (0x80000000 | 351); // 设置车载配置失败
+    public static final int NET_ERROR_GET_ATM_OVERLAY_CFG = (0x80000000 | 352); // 获取atm叠加配置失败
+    public static final int NET_ERROR_SET_ATM_OVERLAY_CFG = (0x80000000 | 353); // 设置atm叠加配置失败
+    public static final int NET_ERROR_GET_ATM_OVERLAY_ABILITY = (0x80000000 | 354); // 获取atm叠加能力失败
+    public static final int NET_ERROR_GET_DECODER_TOUR_CFG = (0x80000000 | 355); // 获取解码器解码轮巡配置失败
+    public static final int NET_ERROR_SET_DECODER_TOUR_CFG = (0x80000000 | 356); // 设置解码器解码轮巡配置失败
+    public static final int NET_ERROR_CTRL_DECODER_TOUR = (0x80000000 | 357); // 控制解码器解码轮巡失败
+    public static final int NET_GROUP_OVERSUPPORTNUM = (0x80000000 | 358); // 超出设备支持最大用户组数目
+    public static final int NET_USER_OVERSUPPORTNUM = (0x80000000 | 359); // 超出设备支持最大用户数目
+    public static final int NET_ERROR_GET_SIP_CFG = (0x80000000 | 368); // 获取SIP配置失败
+    public static final int NET_ERROR_SET_SIP_CFG = (0x80000000 | 369); // 设置SIP配置失败
+    public static final int NET_ERROR_GET_SIP_ABILITY = (0x80000000 | 370); // 获取SIP能力失败
+    public static final int NET_ERROR_GET_WIFI_AP_CFG = (0x80000000 | 371); // 获取WIFI ap配置失败
+    public static final int NET_ERROR_SET_WIFI_AP_CFG = (0x80000000 | 372); // 设置WIFI ap配置失败
+    public static final int NET_ERROR_GET_DECODE_POLICY = (0x80000000 | 373); // 获取解码策略配置失败
+    public static final int NET_ERROR_SET_DECODE_POLICY = (0x80000000 | 374); // 设置解码策略配置失败
+    public static final int NET_ERROR_TALK_REJECT = (0x80000000 | 375); // 拒绝对讲
+    public static final int NET_ERROR_TALK_OPENED = (0x80000000 | 376); // 对讲被其他客户端打开
+    public static final int NET_ERROR_TALK_RESOURCE_CONFLICIT = (0x80000000 | 377); // 资源冲突
+    public static final int NET_ERROR_TALK_UNSUPPORTED_ENCODE = (0x80000000 | 378); // 不支持的语音编码格式
+    public static final int NET_ERROR_TALK_RIGHTLESS = (0x80000000 | 379); // 无权限
+    public static final int NET_ERROR_TALK_FAILED = (0x80000000 | 380); // 请求对讲失败
+    public static final int NET_ERROR_GET_MACHINE_CFG = (0x80000000 | 381); // 获取机器相关配置失败
+    public static final int NET_ERROR_SET_MACHINE_CFG = (0x80000000 | 382); // 设置机器相关配置失败
+    public static final int NET_ERROR_GET_DATA_FAILED = (0x80000000 | 383); // 设备无法获取当前请求数据
+    public static final int NET_ERROR_MAC_VALIDATE_FAILED = (0x80000000 | 384); // MAC地址验证失败
+    public static final int NET_ERROR_GET_INSTANCE = (0x80000000 | 385); // 获取服务器实例失败
+    public static final int NET_ERROR_JSON_REQUEST = (0x80000000 | 386); // 生成的json字符串错误
+    public static final int NET_ERROR_JSON_RESPONSE = (0x80000000 | 387); // 响应的json字符串错误
+    public static final int NET_ERROR_VERSION_HIGHER = (0x80000000 | 388); // 协议版本低于当前使用的版本
+    public static final int NET_SPARE_NO_CAPACITY = (0x80000000 | 389); // 设备操作失败, 容量不足
+    public static final int NET_ERROR_SOURCE_IN_USE = (0x80000000 | 390); // 显示源被其他输出占用
+    public static final int NET_ERROR_REAVE = (0x80000000 | 391); // 高级用户抢占低级用户资源
+    public static final int NET_ERROR_NETFORBID = (0x80000000 | 392); // 禁止入网
+    public static final int NET_ERROR_GETCFG_MACFILTER = (0x80000000 | 393); // 获取MAC过滤配置失败
+    public static final int NET_ERROR_SETCFG_MACFILTER = (0x80000000 | 394); // 设置MAC过滤配置失败
+    public static final int NET_ERROR_GETCFG_IPMACFILTER = (0x80000000 | 395); // 获取IP/MAC过滤配置失败
+    public static final int NET_ERROR_SETCFG_IPMACFILTER = (0x80000000 | 396); // 设置IP/MAC过滤配置失败
+    public static final int NET_ERROR_OPERATION_OVERTIME = (0x80000000 | 397); // 当前操作超时
+    public static final int NET_ERROR_SENIOR_VALIDATE_FAILED = (0x80000000 | 398); // 高级校验失败
+    public static final int NET_ERROR_DEVICE_ID_NOT_EXIST = (0x80000000 | 399); // 设备ID不存在
+    public static final int NET_ERROR_UNSUPPORTED = (0x80000000 | 400); // 不支持当前操作
+    public static final int NET_ERROR_PROXY_DLLLOAD = (0x80000000 | 401); // 代理库加载失败
+    public static final int NET_ERROR_PROXY_ILLEGAL_PARAM = (0x80000000 | 402); // 代理用户参数不合法
+    public static final int NET_ERROR_PROXY_INVALID_HANDLE = (0x80000000 | 403); // 代理句柄无效
+    public static final int NET_ERROR_PROXY_LOGIN_DEVICE_ERROR = (0x80000000 | 404); // 代理登入前端设备失败
+    public static final int NET_ERROR_PROXY_START_SERVER_ERROR = (0x80000000 | 405); // 启动代理服务失败
+    public static final int NET_ERROR_SPEAK_FAILED = (0x80000000 | 406); // 请求喊话失败
+    public static final int NET_ERROR_NOT_SUPPORT_F6 = (0x80000000 | 407); // 设备不支持此F6接口调用
+    public static final int NET_ERROR_CD_UNREADY = (0x80000000 | 408); // 光盘未就绪
+    public static final int NET_ERROR_DIR_NOT_EXIST = (0x80000000 | 409); // 目录不存在
+    public static final int NET_ERROR_UNSUPPORTED_SPLIT_MODE = (0x80000000 | 410); // 设备不支持的分割模式
+    public static final int NET_ERROR_OPEN_WND_PARAM = (0x80000000 | 411); // 开窗参数不合法
+    public static final int NET_ERROR_LIMITED_WND_COUNT = (0x80000000 | 412); // 开窗数量超过限制
+    public static final int NET_ERROR_UNMATCHED_REQUEST = (0x80000000 | 413); // 请求命令与当前模式不匹配
+    public static final int NET_RENDER_ENABLELARGEPICADJUSTMENT_ERROR = (0x80000000 | 414); // Render库启用高清图像内部调整策略出错
+    public static final int NET_ERROR_UPGRADE_FAILED = (0x80000000 | 415); // 设备升级失败
+    public static final int NET_ERROR_NO_TARGET_DEVICE = (0x80000000 | 416); // 找不到目标设备
+    public static final int NET_ERROR_NO_VERIFY_DEVICE = (0x80000000 | 417); // 找不到验证设备
+    public static final int NET_ERROR_CASCADE_RIGHTLESS = (0x80000000 | 418); // 无级联权限
+    public static final int NET_ERROR_LOW_PRIORITY = (0x80000000 | 419); // 低优先级
+    public static final int NET_ERROR_REMOTE_REQUEST_TIMEOUT = (0x80000000 | 420); // 远程设备请求超时
+    public static final int NET_ERROR_LIMITED_INPUT_SOURCE = (0x80000000 | 421); // 输入源超出最大路数限制
+    public static final int NET_ERROR_SET_LOG_PRINT_INFO = (0x80000000 | 422); // 设置日志打印失败
+    public static final int NET_ERROR_PARAM_DWSIZE_ERROR = (0x80000000 | 423); // 入参的dwsize字段出错
+    public static final int NET_ERROR_LIMITED_MONITORWALL_COUNT = (0x80000000 | 424); // 电视墙数量超过上限
+    public static final int NET_ERROR_PART_PROCESS_FAILED = (0x80000000 | 425); // 部分过程执行失败
+    public static final int NET_ERROR_TARGET_NOT_SUPPORT = (0x80000000 | 426); // 该功能不支持转发
+    public static final int NET_ERROR_VISITE_FILE = (0x80000000 | 510); // 访问文件失败
+    public static final int NET_ERROR_DEVICE_STATUS_BUSY = (0x80000000 | 511); // 设备忙
+    public static final int NET_USER_PWD_NOT_AUTHORIZED = (0x80000000 | 512); // 修改密码无权限
+    public static final int NET_USER_PWD_NOT_STRONG = (0x80000000 | 513); // 密码强度不够
+    public static final int NET_ERROR_NO_SUCH_CONFIG = (0x80000000 | 514); // 没有对应的配置
+    public static final int NET_ERROR_AUDIO_RECORD_FAILED = (0x80000000 | 515); // 录音失败
+    public static final int NET_ERROR_SEND_DATA_FAILED = (0x80000000 | 516); // 数据发送失败
+    public static final int NET_ERROR_OBSOLESCENT_INTERFACE = (0x80000000 | 517); // 废弃接口
+    public static final int NET_ERROR_INSUFFICIENT_INTERAL_BUF = (0x80000000 | 518); // 内部缓冲不足
+    public static final int NET_ERROR_NEED_ENCRYPTION_PASSWORD = (0x80000000 | 519); // 修改设备ip时,需要校验密码
+    public static final int NET_ERROR_NOSUPPORT_RECORD = (0x80000000 | 520); // 设备不支持此记录集
+    public static final int NET_ERROR_SERIALIZE_ERROR = (0x80000000 | 1010);// 数据序列化错误
+    public static final int NET_ERROR_DESERIALIZE_ERROR = (0x80000000 | 1011);// 数据反序列化错误
+    public static final int NET_ERROR_LOWRATEWPAN_ID_EXISTED = (0x80000000 | 1012);// 该无线ID已存在
+    public static final int NET_ERROR_LOWRATEWPAN_ID_LIMIT = (0x80000000 | 1013);// 无线ID数量已超限
+    public static final int NET_ERROR_LOWRATEWPAN_ID_ABNORMAL = (0x80000000 | 1014);// 无线异常添加
+    public static final int NET_ERROR_ENCRYPT = (0x80000000 | 1015);// 加密数据失败
+    public static final int NET_ERROR_PWD_ILLEGAL = (0x80000000 | 1016);// 新密码不合规范
+    public static final int NET_ERROR_DEVICE_ALREADY_INIT = (0x80000000 | 1017);// 设备已经初始化
+    public static final int NET_ERROR_SECURITY_CODE = (0x80000000 | 1018);// 安全码错误
+    public static final int NET_ERROR_SECURITY_CODE_TIMEOUT = (0x80000000 | 1019);// 安全码超出有效期
+    public static final int NET_ERROR_GET_PWD_SPECI = (0x80000000 | 1020);// 获取密码规范失败
+    public static final int NET_ERROR_NO_AUTHORITY_OF_OPERATION = (0x80000000 | 1021);// 无权限进行该操作
+    public static final int NET_ERROR_DECRYPT = (0x80000000 | 1022);// 解密数据失败
+    public static final int NET_ERROR_2D_CODE = (0x80000000 | 1023);// 2D code校验失败
+    public static final int NET_ERROR_INVALID_REQUEST = (0x80000000 | 1024);// 非法的RPC请求
+    public static final int NET_ERROR_PWD_RESET_DISABLE = (0x80000000 | 1025);// 密码重置功能已关闭
+    public static final int NET_ERROR_PLAY_PRIVATE_DATA = (0x80000000 | 1026);// 显示私有数据，比如规则框等失败
+    public static final int NET_ERROR_ROBOT_OPERATE_FAILED = (0x80000000 | 1027);// 机器人操作失败
+    public static final int NET_ERROR_PHOTOSIZE_EXCEEDSLIMIT = (0x80000000 | 1028);// 图片大小超限
+    public static final int NET_ERROR_USERID_INVALID = (0x80000000 | 1029);// 用户ID不存在
+    public static final int NET_ERROR_EXTRACTFEATURE_FAILED = (0x80000000 | 1030);// 照片特征值提取失败
+    public static final int NET_ERROR_PHOTO_EXIST = (0x80000000 | 1031);// 照片已存在
+    public static final int NET_ERROR_PHOTO_OVERFLOW = (0x80000000 | 1032);// 照片数量超过上限
+    public static final int NET_ERROR_CHANNEL_ALREADY_OPENED = (0x80000000 | 1033);// 通道已经打开
+    public static final int NET_ERROR_CREATE_SOCKET = (0x80000000 | 1034);// 创建套接字失败
+    public static final int NET_ERROR_CHANNEL_NUM = (0x80000000 | 1035);// 通道号错误
+    public static final int NET_ERROR_PHOTO_FORMAT = (0x80000000 | 1036);// 图片格式错误
+    public static final int NET_ERROR_DIGITAL_CERTIFICATE_INTERNAL_ERROR = (0x80000000 | 1037);      // 内部错误(比如：相关硬件问题，获取公钥失败，内部接口调用失败，写文件失败等等)
+    public static final int NET_ERROR_DIGITAL_CERTIFICATE_GET_ID_FAILED = (0x80000000 | 1038);      // 获取设备ID失败
+    public static final int NET_ERROR_DIGITAL_CERTIFICATE_IMPORT_ILLEGAL = (0x80000000 | 1039);      // 证书文件非法(格式不支持或者不是证书文件)
+    public static final int NET_ERROR_DIGITAL_CERTIFICATE_SN_ERROR = (0x80000000 | 1040);      // 证书sn重复或错误或不规范
+    public static final int NET_ERROR_DIGITAL_CERTIFICATE_COMMON_NAME_ILLEGAL = (0x80000000 | 1041);// 证书commonName非法(本地设备证书与系统中的不匹配devid_cryptoID,或者对端的不符合规则(devid_crytoID))
+    public static final int NET_ERROR_DIGITAL_CERTIFICATE_NO_ROOT_CERT = (0x80000000 | 1042);      // 根证书未导入或不存在
+    public static final int NET_ERROR_DIGITAL_CERTIFICATE_CERT_REVOKED = (0x80000000 | 1043);      // 证书被吊销
+    public static final int NET_ERROR_DIGITAL_CERTIFICATE_CERT_INVALID = (0x80000000 | 1044);      // 证书不可用或未生效或已过期
+    public static final int NET_ERROR_DIGITAL_CERTIFICATE_CERT_ERROR_SIGN = (0x80000000 | 1045);      // 证书签名不匹配
+    public static final int NET_ERROR_DIGITAL_CERTIFICATE_COUNTS_UPPER_LIMIT = (0x80000000 | 1046); // 超出证书导入上限
+    public static final int NET_ERROR_DIGITAL_CERTIFICATE_CERT_NO_EXIST = (0x80000000 | 1047);      // 证书文件不存在(导出证书或者获取对应证书的公钥)#define NET_ERROR_DEFULAT_SEARCH_PORT								_EC(1048)		  // 默认搜索端口无法使用（5050,37810）
+    public static final int NET_ERROR_FACE_RECOGNITION_SERVER_MULTI_APPEND_STOUP = (0x80000000 | 1049);            // 批量添加人脸停止
+    public static final int NET_ERROR_FACE_RECOGNITION_SERVER_MULTI_APPEND_ERROR = (0x80000000 | 1050);            // 批量添加人脸失败
+    public static final int NET_ERROR_FACE_RECOGNITION_SERVER_GROUP_ID_EXCEED = (0x80000000 | 1051);            // 组ID超过最大值
+    public static final int NET_ERROR_FACE_RECOGNITION_SERVER_GROUP_ID_NOT_IN_REGISTER_GROUP = (0x80000000 | 1052);            // 组ID不存在或为空
+    public static final int NET_ERROR_FACE_RECOGNITION_SERVER_PICTURE_NOT_FOUND = (0x80000000 | 1053);            // 无图片数据
+    public static final int NET_ERROR_FACE_RECOGNITION_SERVER_GENERATE_GROUP_ID_FAILED = (0x80000000 | 1054);            // 生成组ID超出范围
+    public static final int NET_ERROR_FACE_RECOGNITION_SERVER_SET_CONFIG_FAILED = (0x80000000 | 1055);            // 设置配置失败
+    public static final int NET_ERROR_FACE_RECOGNITION_SERVER_FILE_OPEN_FAILED = (0x80000000 | 1056);            // 图片文件打开失败
+    public static final int NET_ERROR_FACE_RECOGNITION_SERVER_FILE_READ_FAILED = (0x80000000 | 1057);            // 图片文件读取失败
+    public static final int NET_ERROR_FACE_RECOGNITION_SERVER_FILE_WRITE_FAILED = (0x80000000 | 1058);            // 图片文件写入失败
+    public static final int NET_ERROR_FACE_RECOGNITION_SERVER_PICTURE_DPI_ERROR = (0x80000000 | 1059);            // 图片分辨率异常
+    public static final int NET_ERROR_FACE_RECOGNITION_SERVER_PICTURE_PX_ERROR = (0x80000000 | 1060);            // 图片像素异常
+    public static final int NET_ERROR_FACE_RECOGNITION_SERVER_PICTURE_SIZE_ERROR = (0x80000000 | 1061);            // 图片大小不对
+    public static final int NET_ERROR_FACE_RECOGNITION_SERVER_DATA_BASE_ERROR = (0x80000000 | 1062);            // 数据库操作失败
+    public static final int NET_ERROR_FACE_RECOGNITION_SERVER_FACE_MAX_NUM = (0x80000000 | 1063);            // 人员数量超过限制
+    public static final int NET_ERROR_FACE_RECOGNITION_SERVER_BIRTH_DAY_FORMAT_ERROR = (0x80000000 | 1064);            // 生日日期格式错误
+    public static final int NET_ERROR_FACE_RECOGNITION_SERVER_UID_ERROR = (0x80000000 | 1065);            // 人员UID不存在或为空
+    public static final int NET_ERROR_FACE_RECOGNITION_SERVER_TOKEN_ERROR = (0x80000000 | 1066);            // 令牌不存在或为空
+    public static final int NET_ERROR_FACE_RECOGNITION_SERVER_BEGIN_NUM_OVER_RUN = (0x80000000 | 1067);            // 查询起始数大于总数
+    public static final int NET_ERROR_FACE_RECOGNITION_SERVER_ABSTRACT_NUM_ZERO = (0x80000000 | 1068);            // 需手动建模人数为0
+    public static final int NET_ERROR_FACE_RECOGNITION_SERVER_ABSTRACT_INIT_ERROR = (0x80000000 | 1069);            // 建模分析器启动失败
+    public static final int NET_ERROR_FACE_RECOGNITION_SERVER_AUTO_ABSTRACT_STATE = (0x80000000 | 1070);            // 设备正在自动建模
+    public static final int NET_ERROR_FACE_RECOGNITION_SERVER_ABSTRACT_STATE = (0x80000000 | 1071);            // 设备正在手动建模
+    public static final int NET_ERROR_FACE_RECOGNITION_SERVER_IM_EX_STATE = (0x80000000 | 1072);            // 设备正在导入导出
+    public static final int NET_ERROR_FACE_RECOGNITION_SERVER_PIC_WRITE_FAILED = (0x80000000 | 1073);            // 图片写入失败
+    public static final int NET_ERROR_FACE_RECOGNITION_SERVER_GROUP_SPACE_EXCEED = (0x80000000 | 1074);            // 超出人脸库空间大小限制
+    public static final int NET_ERROR_FACE_RECOGNITION_SERVER_GROUP_PIC_COUNT_EXCEED = (0x80000000 | 1075);            // 超出人脸库图片数量限制
+    public static final int NET_ERROR_FACE_RECOGNITION_SERVER_GROUP_NOT_FOUND = (0x80000000 | 1076);            // 人脸库不存在
+    public static final int NET_ERROR_FACE_RECOGNITION_SERVER_FIND_RECORDS_ERROR = (0x80000000 | 1077);            // 查询原人脸库数据结果无效
+    public static final int NET_ERROR_FACE_RECOGNITION_SERVER_DELETE_PERSON_ERROR = (0x80000000 | 1078);            // 删除原人脸库数据失败
+    public static final int NET_ERROR_FACE_RECOGNITION_SERVER_DELETE_GROUP_ERROR = (0x80000000 | 1079);           // 删除人脸库失败
+    public static final int NET_ERROR_FACE_RECOGNITION_SERVER_NAME_FORMAT_ERROR = (0x80000000 | 1080);           // 命名格式错误
+    public static final int NET_ERROR_FACE_RECOGNITION_SERVER_FILEPATH_NOT_SET = (0x80000000 | 1081);           // 图片保存路径未设置
+    public static final int NET_ERROR_DEVICE_PARSE_PROTOCOL = (0x80000000 | 1079);          // 设备解析协议错误
+    public static final int NET_ERROR_DEVICE_INVALID_REQUEST = (0x80000000 | 1080);          // 设备返回无效请求
+    public static final int NET_ERROR_DEVICE_INTERNAL_ERROR = (0x80000000 | 1081);          // 设备内部错误
+    public static final int NET_ERROR_DEVICE_REQUEST_TIMEOUT = (0x80000000 | 1082);          // 设备内部请求超时
+    public static final int NET_ERROR_DEVICE_KEEPALIVE_FAIL = (0x80000000 | 1083);          // 设备保活失败
+    public static final int NET_ERROR_DEVICE_NETWORK_ERROR = (0x80000000 | 1084);          // 设备网络错误
+    public static final int NET_ERROR_DEVICE_UNKNOWN_ERROR = (0x80000000 | 1085);          // 设备内部未知错误
+    public static final int NET_ERROR_DEVICE_COM_INTERFACE_NOTFOUND = (0x80000000 | 1086);          // 设备组件接口没有找到
+    public static final int NET_ERROR_DEVICE_COM_IMPLEMENT_NOTFOUND = (0x80000000 | 1087);          // 设备组件实现没有找到
+    public static final int NET_ERROR_DEVICE_COM_NOTFOUND = (0x80000000 | 1088);          // 设备接入组件没有找到
+    public static final int NET_ERROR_DEVICE_COM_INSTANCE_NOTEXIST = (0x80000000 | 1089);          // 设备接入组件实例不存在
+    public static final int NET_ERROR_DEVICE_CREATE_COM_FAIL = (0x80000000 | 1090);          // 设备组件工厂创建组件失败
+    public static final int NET_ERROR_DEVICE_GET_COM_FAIL = (0x80000000 | 1091);          // 设备组件工厂获取组件实例失败
+    public static final int NET_ERROR_DEVICE_BAD_REQUEST = (0x80000000 | 1092);          // 设备业务请求不被接受
+    public static final int NET_ERROR_DEVICE_REQUEST_IN_PROGRESS = (0x80000000 | 1093);          // 设备已经在处理请求，不接受重复请求
+    public static final int NET_ERROR_DEVICE_LIMITED_RESOURCE = (0x80000000 | 1094);          // 设备资源不足
+    public static final int NET_ERROR_DEVICE_BUSINESS_TIMEOUT = (0x80000000 | 1095);          // 设备业务超时
+    public static final int NET_ERROR_DEVICE_TOO_MANY_REQUESTS = (0x80000000 | 1096);          // 设备接收过多请求
+    public static final int NET_ERROR_DEVICE_NOT_ALREADY = (0x80000000 | 1097);          // 设备未准备就绪，不接受业务请求
+    public static final int NET_ERROR_DEVICE_SEARCHRECORD_TIMEOUT = (0x80000000 | 1098);          // 设备录像查询超时
+    public static final int NET_ERROR_DEVICE_SEARCHTIME_INVALID = (0x80000000 | 1099);          // 设备录像查询时间无效
+    public static final int NET_ERROR_DEVICE_SSID_INVALID = (0x80000000 | 1100);          // 设备校验SSID无效
+    public static final int NET_ERROR_DEVICE_CHANNEL_STREAMTYPE_ERROR = (0x80000000 | 1101);    // 设备校验通道号或码流类型无效
+    public static final int NET_ERROR_DEVICE_STREAM_PACKINGFORMAT_UNSUPPORT = (0x80000000 | 1102);    // 设备不支持该码流打包格式
+    public static final int NET_ERROR_DEVICE_AUDIO_ENCODINGFORMAT_UNSUPPORT = (0x80000000 | 1103);    // 设备不支持该语音编码格式
+    public static final int NET_ERROR_SECURITY_ERROR_SUPPORT_GUI = (0x80000000 | 1104);    // 校验请求安全码失败,可使用本地GUI方式重置密码
+    public static final int NET_ERROR_SECURITY_ERROR_SUPPORT_MULT = (0x80000000 | 1105);    // 校验请求安全码失败,可使用大华渠道APP、configtool工具重置密码
+    public static final int NET_ERROR_SECURITY_ERROR_SUPPORT_UNIQUE = (0x80000000 | 1106);    // 校验请求安全码失败,可登陆Web页面重置密码
+    public static final int NET_ERROR_STREAMCONVERTOR_DEFECT = (0x80000000 | 1107);    // 转码库缺失
+
+
+    public static final int NET_ERROR_SECURITY_GENERATE_SAFE_CODE = (0x8000000 | 1108);    // 调用大华加密库产生安全码失败
+    public static final int NET_ERROR_SECURITY_GET_CONTACT = (0x8000000 | 1109);    // 获取联系方式失败
+    public static final int NET_ERROR_SECURITY_GET_QRCODE = (0x8000000 | 1110);    // 获取重置密码的二维码信息失败
+    public static final int NET_ERROR_SECURITY_CANNOT_RESET = (0x8000000 | 1111);    // 设备未初始化,无法重置
+    public static final int NET_ERROR_SECURITY_NOT_SUPPORT_CONTACT_MODE = (0x8000000 | 1112);    // 不支持设置该种联系方式,如只支持设置手机号，却请求设置邮箱
+    public static final int NET_ERROR_SECURITY_RESPONSE_TIMEOUT = (0x8000000 | 1113);    // 对端响应超时
+    public static final int NET_ERROR_SECURITY_AUTHCODE_FORBIDDEN = (0x8000000 | 1114);    // 尝试校验AuthCode次数过多，禁止校验
+    public static final int NET_ERROR_TRANCODE_LOGIN_REMOTE_DEV = (0x8000000 | 1115);        // (虚拟转码)登陆远程设备失败
+    public static final int NET_ERROR_TRANCODE_NOFREE_CHANNEL = (0x8000000 | 1116);        // (虚拟转码)没有可用的通道资源
+    public static final int NET_ERROR_VK_INFO_DECRYPT_FAILED = (0x8000000 | 1117);        // VK信息解密失败
+    public static final int NET_ERROR_VK_INFO_DESERIALIZE_FAILED = (0x8000000 | 1118);        // VK信息解析失败
+    public static final int NET_ERROR_GDPR_ABILITY_NOT_ENABLE = (0x8000000 | 1119);        // SDK GDPR功能未使能
+
+    /*门禁快速导入及复核错误码 start*/
+    public static final int NET_ERROR_FAST_CHECK_NO_AUTH = (0x80000000 | 1120);    // 门禁快速复核:无权限
+    public static final int NET_ERROR_FAST_CHECK_NO_FILE = (0x80000000 | 1121);    // 门禁快速复核:文件不存在
+    public static final int NET_ERROR_FAST_CHECK_FILE_FAIL = (0x80000000 | 1122);    // 门禁快速复核:文件准备失败
+    public static final int NET_ERROR_FAST_CHECK_BUSY = (0x80000000 | 1123);    // 门禁快速复核:系统忙
+    public static final int NET_ERROR_FAST_CHECK_NO_PASSWORD = (0x80000000 | 1124);    // 门禁快速复核:未定义密码, 不允许导出
+    public static final int NET_ERROR_IMPORT_ACCESS_SEND_FAILD = (0x80000000 | 1125);    // 门禁快速导入:发送门禁数据失败
+    public static final int NET_ERROR_IMPORT_ACCESS_BUSY = (0x80000000 | 1126);    // 门禁快速导入:系统忙, 已经有导入任务
+    public static final int NET_ERROR_IMPORT_ACCESS_DATAERROR = (0x80000000 | 1127);    // 门禁快速导入:数据包检验失败
+    public static final int NET_ERROR_IMPORT_ACCESS_DATAINVALID = (0x80000000 | 1128);    // 门禁快速导入:数据包非法
+    public static final int NET_ERROR_IMPORT_ACCESS_SYNC_FALID = (0x80000000 | 1129);    // 门禁快速导入:同步失败,数据库无法生成
+    public static final int NET_ERROR_IMPORT_ACCESS_DBFULL = (0x80000000 | 1130);    // 门禁快速导入:数据库已满, 无法导入
+    public static final int NET_ERROR_IMPORT_ACCESS_SDFULL = (0x80000000 | 1131);    // 门禁快速导入:存储空间已满, 无法导入
+    public static final int NET_ERROR_IMPORT_ACCESS_CIPHER_ERROR = (0x80000000 | 1132);    // 门禁快速导入:导入压缩包密码不对
+    /*门禁快速导入及复核错误码 end*/
+
+    public static final int NET_ERROR_INVALID_PARAM = (0x80000000 | 1133);    // 参数无效
+    public static final int NET_ERROR_INVALID_PASSWORD = (0x80000000 | 1134);    // 密码无效
+    public static final int NET_ERROR_INVALID_FINGERPRINT = (0x80000000 | 1135);    // 指纹无效
+    public static final int NET_ERROR_INVALID_FACE = (0x80000000 | 1136);    // 人脸无效
+    public static final int NET_ERROR_INVALID_CARD = (0x80000000 | 1137);    // 卡无效
+    public static final int NET_ERROR_INVALID_USER = (0x80000000 | 1138);    // 用户无效
+    public static final int NET_ERROR_GET_SUBSERVICE = (0x80000000 | 1139);    // 能力集子服务获取失败
+    public static final int NET_ERROR_GET_METHOD = (0x80000000 | 1140);   // 获取组件的方法集失败
+    public static final int NET_ERROR_GET_SUBCAPS = (0x80000000 | 1141);    // 获取资源实体能力集失败
+    public static final int NET_ERROR_UPTO_INSERT_LIMIT = (0x80000000 | 1142);   // 已达插入上限
+    public static final int NET_ERROR_UPTO_MAX_INSERT_RATE = (0x80000000 | 1143);   // 已达最大插入速度
+    public static final int NET_ERROR_ERASE_FINGERPRINT = (0x80000000 | 1144);   // 清除指纹数据失败
+    public static final int NET_ERROR_ERASE_FACE = (0x80000000 | 1145);   // 清除人脸数据失败
+    public static final int NET_ERROR_ERASE_CARD = (0x80000000 | 1146);   // 清除卡数据失败
+    public static final int NET_ERROR_NO_RECORD = (0x80000000 | 1147);   // 没有记录
+    public static final int NET_ERROR_NOMORE_RECORDS = (0x80000000 | 1148);   // 查找到最后，没有更多记录
+    public static final int NET_ERROR_RECORD_ALREADY_EXISTS = (0x80000000 | 1149);   // 下发卡或指纹时，数据重复
+    public static final int NET_ERROR_EXCEED_MAX_FINGERPRINT_PERUSER = (0x80000000 | 1150);   // 超过个人最大指纹记录数
+    public static final int NET_ERROR_EXCEED_MAX_CARD_PERUSER = (0x80000000 | 1151);   // 超过个人最大卡片记录数
+    public static final int NET_ERROR_EXCEED_ADMINISTRATOR_LIMIT = (0x80000000 | 1152);   // 超过门禁管理员个数限制
+
+    public static final int NET_LOGIN_ERROR_DEVICE_NOT_SUPPORT_HIGHLEVEL_SECURITY_LOGIN = (0x80000000 | 1153);   // 设备不支持高安全等级登录
+    public static final int NET_LOGIN_ERROR_DEVICE_ONLY_SUPPORT_HIGHLEVEL_SECURITY_LOGIN = (0x80000000 | 1154);   // 设备只支持高安全等级登录
+
+    public static final int NET_ERROR_VIDEO_CHANNEL_OFFLINE = (0x80000000 | 1155);   // 表示此视频通道处于离线，拉流失败
+    public static final int NET_ERROR_USERID_FORMAT_INCORRECT = (0x80000000 | 1156);    // 用户编号不规范
+    public static final int NET_ERROR_CANNOT_FIND_CHANNEL_RELATE_TO_SN = (0x80000000 | 1157);    // 找不到该SN对应的通道
+    public static final int NET_ERROR_TASK_QUEUE_OF_CHANNEL_IS_FULL = (0x80000000 | 1158);    // 该通道的任务队列满
+    public static final int NET_ERROR_APPLY_USER_INFO_BLOCK_FAIL = (0x80000000 | 1159);    // 申请不到新的用户信息(权限)块
+    public static final int NET_ERROR_EXCEED_MAX_PASSWD_PERUSER = (0x80000000 | 1160);    // 用户密码数量超过限制
+    public static final int NET_ERROR_PARSE_PROTOCOL = (0x80000000 | 1161);    // 设备内部异常引起协议解析错误
+    public static final int NET_ERROR_CARD_NUM_EXIST = (0x80000000 | 1162);    // 卡号已存在
+    public static final int NET_ERROR_FINGERPRINT_EXIST = (0x80000000 | 1163);    // 指纹已存在
+
+    public static final int NET_ERROR_OPEN_PLAYGROUP_FAIL = (0x80000000 | 1164);    // 打开播放组失败
+    public static final int NET_ERROR_ALREADY_IN_PLAYGROUP = (0x80000000 | 1165);    // 已位于播放组中
+    public static final int NET_ERROR_QUERY_PLAYGROUP_TIME_FAIL = (0x80000000 | 1166);    // 查询播放组时间失败
+    public static final int NET_ERROR_SET_PLAYGROUP_BASECHANNEL_FAIL = (0x80000000 | 1167);    // 设置播放组基准通道失败
+    public static final int NET_ERROR_SET_PLAYGROUP_DIRECTION_FAIL = (0x80000000 | 1168);    // 设置播放组方向失败
+    public static final int NET_ERROR_SET_PLAYGROUP_SPEED_FAIL = (0x80000000 | 1169);    // 设置播放组速度失败
+    public static final int NET_ERROR_ADD_PLAYGROUP_FAIL = (0x80000000 | 1170);    // 加入播放组失败
+
+    public static final int NET_ERROR_EXPORT_AOL_LOGFILE_NO_AUTH = (0x80000000 | 1171);    // 导出AOL日志:无权限
+    public static final int NET_ERROR_EXPORT_AOL_LOGFILE_NO_FILE = (0x80000000 | 1172);    // 导出AOL日志:文件不存在
+    public static final int NET_ERROR_EXPORT_AOL_LOGFILE_FILE_FAIL = (0x80000000 | 1173);    // 导出AOL日志:文件准备失败
+    public static final int NET_ERROR_EXPORT_AOL_LOGFILE_BUSY = (0x80000000 | 1174);    // 导出AOL日志:系统忙
+
+    // 设备上APP安装相关错误码
+    public static final int NET_ERROR_EMPTY_LICENSE = (0x80000000 | 1175);   // License为空
+    public static final int NET_ERROR_UNSUPPORTED_MODE = (0x80000000 | 1176);   // 不支持该模式
+    public static final int NET_ERROR_URL_APP_NOT_MATCH = (0x80000000 | 1177);   // URL与APP不匹配
+    public static final int NET_ERROR_READ_INFO_FAILED = (0x80000000 | 1178);   // 读取信息失败
+    public static final int NET_ERROR_WRITE_FAILED = (0x80000000 | 1179);   // 写入失败
+    public static final int NET_ERROR_NO_SUCH_APP = (0x80000000 | 1180);   // 未找到APP
+    public static final int NET_ERROR_VERIFIF_FAILED = (0x80000000 | 1181);   // 校验失败
+    public static final int NET_ERROR_LICENSE_OUT_DATE = (0x80000000 | 1182);   // License已过期
+
+    public static final int NET_ERROR_UPGRADE_PROGRAM_TOO_OLD = (0x80000000 | 1183);    // 升级程序版本过低
+    public static final int NET_ERROR_SECURE_TRANSMIT_BEEN_CUT = (0x80000000 | 1184);    // 加密传输被裁剪
+    public static final int NET_ERROR_DEVICE_NOT_SUPPORT_SECURE_TRANSMIT = (0x80000000 | 1185);    // 设备不支持安全传输
+
+    public static final int NET_ERROR_EXTRA_STREAM_LOGIN_FAIL_CAUSE_BY_MAIN_STREAM = (0x80000000 | 1186);    // 主码流成功的情况下，辅码流登录失败
+    public static final int NET_ERROR_EXTRA_STREAM_CLOSED_BY_REMOTE_DEVICE = (0x80000000 | 1187);    // 辅码流被前端关闭
+
+    /*人脸库导入导出错误码 start*/
+    public static final int NET_ERROR_IMPORT_FACEDB_SEND_FAILD = (0x80000000 | 1188);    // 人脸库导入:发送人脸库数据失败
+    public static final int NET_ERROR_IMPORT_FACEDB_BUSY = (0x80000000 | 1189);    // 人脸库导入:系统忙, 已经有导入任务
+    public static final int NET_ERROR_IMPORT_FACEDB_DATAERROR = (0x80000000 | 1190);    // 人脸库导入:数据包检验失败
+    public static final int NET_ERROR_IMPORT_FACEDB_DATAINVALID = (0x80000000 | 1191);    // 人脸库导入:数据包非法
+    public static final int NET_ERROR_IMPORT_FACEDB_UPGRADE_FAILD = (0x80000000 | 1192);   // 人脸库导入:上传失败
+    public static final int NET_ERROR_IMPORT_FACEDB_NO_AUTHORITY = (0x80000000 | 1193);   // 人脸库导入:用户无权限
+    public static final int NET_ERROR_IMPORT_FACEDB_ABNORMAL_FILE = (0x80000000 | 1194);   // 人脸库导入:文件格式异常
+    public static final int NET_ERROR_IMPORT_FACEDB_SYNC_FALID = (0x80000000 | 1195);    // 人脸库导入:同步失败,数据库无法生成
+    public static final int NET_ERROR_IMPORT_FACEDB_DBFULL = (0x80000000 | 1196);    // 人脸库导入:数据库已满, 无法导入
+    public static final int NET_ERROR_IMPORT_FACEDB_SDFULL = (0x80000000 | 1197);    // 人脸库导入:存储空间已满, 无法导入
+    public static final int NET_ERROR_IMPORT_FACEDB_CIPHER_ERROR = (0x80000000 | 1198);    // 人脸库导入:导入压缩包密码不对
+
+    public static final int NET_ERROR_EXPORT_FACEDB_NO_AUTH = (0x80000000 | 1199);    // 人脸库导出:无权限
+    public static final int NET_ERROR_EXPORT_FACEDB_NO_FILE = (0x80000000 | 1200);    // 人脸库导出:文件不存在
+    public static final int NET_ERROR_EXPORT_FACEDB_FILE_FAIL = (0x80000000 | 1201);    // 人脸库导出:文件准备失败
+    public static final int NET_ERROR_EXPORT_FACEDB_BUSY = (0x80000000 | 1202);    // 人脸库导出:系统忙
+    public static final int NET_ERROR_EXPORT_FACEDB_NO_PASSWORD = (0x80000000 | 1203);    // 人脸库导出:未定义密码, 不允许导出
+    /*人脸库导入导出错误码 end*/
+
+    /* 人脸图片操作错误码 范围 _EC(1300) ~ _EC(1400) */
+    public static final int NET_ERROR_FACEMANAGER_NO_FACE_DETECTED = (0x80000000 | 1300);  // 图片中检测到0个人脸目标
+    public static final int NET_ERROR_FACEMANAGER_MULTI_FACE_DETECTED = (0x80000000 | 1301);  // 图片中检测到多个人脸，无法返回特征
+    public static final int NET_ERROR_FACEMANAGER_PICTURE_DECODING_ERROR = (0x80000000 | 1302);  // 图片解码错误
+    public static final int NET_ERROR_FACEMANAGER_LOW_PICTURE_QUALITY = (0x80000000 | 1303);  // 图片质量太低
+    public static final int NET_ERROR_FACEMANAGER_NOT_RECOMMENDED = (0x80000000 | 1304);  // 结果不推荐使用，比如：对外国人，特征提取成功，但算法支持不好，容易造成误识别
+    public static final int NET_ERROR_FACEMANAGER_FACE_FEATURE_ALREADY_EXIST = (0x80000000 | 1305); // 人脸特征已存在
+    public static final int NET_ERROR_FACEMANAGER_FACE_ANGLE_OVER_THRESHOLDS = (0x80000000 | 1307); // 人脸角度超过配置阈值
+    public static final int NET_ERROR_FACEMANAGER_FACE_RADIO_EXCEEDS_RANGE = (0x80000000 | 1308); // 人脸占比超出范围，算法建议占比:不要超过2/3;不要小于1/3
+    public static final int NET_ERROR_FACEMANAGER_FACE_OVER_EXPOSED = (0x80000000 | 1309);  // 人脸过爆
+    public static final int NET_ERROR_FACEMANAGER_FACE_UNDER_EXPOSED = (0x80000000 | 1310);  // 人脸欠爆
+    public static final int NET_ERROR_FACEMANAGER_BRIGHTNESS_IMBALANCE = (0x80000000 | 1311);  // 人脸亮度不均衡 ,用于判断阴阳脸
+    public static final int NET_ERROR_FACEMANAGER_FACE_LOWER_CONFIDENCE = (0x80000000 | 1312);  // 人脸的置信度低
+    public static final int NET_ERROR_FACEMANAGER_FACE_LOW_ALIGN = (0x80000000 | 1313);  // 人脸对齐分数低
+    public static final int NET_ERROR_FACEMANAGER_FRAGMENTARY_FACE_DETECTED = (0x80000000 | 1314);  // 人脸存在遮挡、残缺不全
+    public static final int NET_ERROR_FACEMANAGER_PUPIL_DISTANCE_NOT_ENOUGH = (0x80000000 | 1315);  // 人脸瞳距小于阈值
+    public static final int NET_ERROR_FACEMANAGER_FACE_DATA_DOWNLOAD_FAILED = (0x80000000 | 1316);  // 人脸数据下载失败
+
+}

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/ToolKits.java

@@ -0,0 +1,573 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua;
+
+
+import com.inspect.nvr.daHuaCarme.jna.NetSDKLib;
+import com.inspect.nvr.daHuaCarme.jna.NetSDKLib.*;
+import com.inspect.nvr.daHuaCarme.utils.jna.ErrorCode;
+import com.inspect.nvr.daHuaCarme.utils.jna.PaintPanel;
+import com.sun.jna.Memory;
+import com.sun.jna.Pointer;
+import com.sun.jna.Structure;
+import com.sun.jna.ptr.IntByReference;
+
+import javax.imageio.ImageIO;
+import javax.swing.*;
+import javax.swing.filechooser.FileFilter;
+import java.awt.event.ActionEvent;
+import java.awt.event.KeyEvent;
+import java.awt.event.KeyListener;
+import java.awt.image.BufferedImage;
+import java.io.*;
+import java.text.SimpleDateFormat;
+
+public class ToolKits {
+	static NetSDKLib netsdkapi = NetSDKLib.NETSDK_INSTANCE;
+	static NetSDKLib configapi = NetSDKLib.CONFIG_INSTANCE;
+	
+  	/***************************************************************************************************
+  	 *                          				工具方法       	 										   *
+  	 ***************************************************************************************************/
+	public static void GetPointerData(Pointer pNativeData, Structure pJavaStu)
+	{
+		GetPointerDataToStruct(pNativeData, 0, pJavaStu);
+	}
+
+	public static void GetPointerDataToStruct(Pointer pNativeData, long OffsetOfpNativeData, Structure pJavaStu) {
+		pJavaStu.write();
+		Pointer pJavaMem = pJavaStu.getPointer();
+		pJavaMem.write(0, pNativeData.getByteArray(OffsetOfpNativeData, pJavaStu.size()), 0,
+				pJavaStu.size());
+		pJavaStu.read();
+	}
+	
+	public static void GetPointerDataToStructArr(Pointer pNativeData, Structure []pJavaStuArr) {
+		long offset = 0;
+		for (int i=0; i<pJavaStuArr.length; ++i)
+		{
+			GetPointerDataToStruct(pNativeData, offset, pJavaStuArr[i]);
+			offset += pJavaStuArr[i].size();
+		}
+	}
+	
+	/**
+	 * 将结构体数组拷贝到内存
+	 * @param pNativeData 
+	 * @param pJavaStuArr
+	 */
+	public static void SetStructArrToPointerData(Structure []pJavaStuArr, Pointer pNativeData) {
+		long offset = 0;
+		for (int i = 0; i < pJavaStuArr.length; ++i) {
+			SetStructDataToPointer(pJavaStuArr[i], pNativeData, offset);
+			offset += pJavaStuArr[i].size();
+		}
+	}
+	
+	public static void SetStructDataToPointer(Structure pJavaStu, Pointer pNativeData, long OffsetOfpNativeData){
+		pJavaStu.write();
+		Pointer pJavaMem = pJavaStu.getPointer();
+		pNativeData.write(OffsetOfpNativeData, pJavaMem.getByteArray(0, pJavaStu.size()), 0, pJavaStu.size());
+	}
+	
+	public static void savePicture(byte[] pBuf, String sDstFile) throws IOException
+	{
+		FileOutputStream fos=null;
+        try
+        {
+          	fos = new FileOutputStream(sDstFile);
+        	fos.write(pBuf);	
+        } catch (Exception e){
+        	e.printStackTrace();
+        }finally{
+        	fos.close();	
+        }
+	}
+	
+	public static void savePicture(byte[] pBuf, int dwBufOffset, int dwBufSize, String sDstFile) throws IOException
+	{
+		FileOutputStream fos=null;
+        try
+        {       	
+        	fos = new FileOutputStream(sDstFile);
+        	fos.write(pBuf, dwBufOffset, dwBufSize);
+        } catch (Exception e){
+        	e.printStackTrace();
+        }finally{
+        	fos.close();	
+        }
+	}
+	
+	public static void savePicture(Pointer pBuf, int dwBufSize, String sDstFile) throws IOException
+	{
+		FileOutputStream fos=null;
+        try
+        {
+          	fos = new FileOutputStream(sDstFile);
+        	fos.write(pBuf.getByteArray(0, dwBufSize), 0, dwBufSize);
+        } catch (Exception e){
+        	e.printStackTrace();
+        }finally{
+        	fos.close();	
+        }
+	}
+	
+	public static void savePicture(Pointer pBuf, int dwBufOffset, int dwBufSize, String sDstFile) throws IOException
+	{
+		FileOutputStream fos=null;
+        try
+        {
+        	fos = new FileOutputStream(sDstFile);
+        	fos.write(pBuf.getByteArray(dwBufOffset, dwBufSize), 0, dwBufSize);
+        } catch (Exception e){
+        	e.printStackTrace();
+        }finally{
+        	fos.close();	
+        }
+	}
+	
+	// 将Pointer值转为byte[]
+	public static String GetPointerDataToByteArr(Pointer pointer) {	
+		String str = "";
+		if(pointer == null) {
+			return str;
+		}
+
+		int length = 0;
+		byte[] bufferPlace = new byte[1];
+
+		for(int i = 0; i < 2048; i++) {		
+			pointer.read(i, bufferPlace, 0, 1);		
+			if(bufferPlace[0] == '\0') {
+				length = i;
+				break;
+			}
+		}
+				
+		if(length > 0) {
+			byte[] buffer = new byte[length];
+			pointer.read(0, buffer, 0, length);
+			try {
+				str = new String(buffer, "GBK").trim();
+			} catch (UnsupportedEncodingException e) {
+				return str;
+			}
+		} 
+
+		return str;
+	}
+	
+	// 获取当前时间
+	public static String getDate() {
+		SimpleDateFormat simpleDate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+	    String date = simpleDate.format(new java.util.Date()).replace(" ", "_").replace(":", "-");
+	    
+	    return date;
+	}
+	
+	// 获取当前时间
+	public static String getDay() {
+			SimpleDateFormat simpleDate = new SimpleDateFormat("yyyy-MM-dd");
+		    String date = simpleDate.format(new java.util.Date());		
+		    return date;
+	}
+
+	
+	// 限制JTextField 长度，以及内容
+	public static void limitTextFieldLength(final JTextField jTextField, final int size) {
+		jTextField.addKeyListener(new KeyListener() {
+			
+			@Override
+			public void keyTyped(KeyEvent e) {			
+				String number = "0123456789" + (char)8;	
+				if(number.indexOf(e.getKeyChar()) < 0 || jTextField.getText().trim().length() >= size) {
+					e.consume();
+					return;
+				}		
+			}
+			
+			@Override
+			public void keyReleased(KeyEvent e) {		
+			}
+			
+			@Override
+			public void keyPressed(KeyEvent e) {	
+			}
+		});
+	}
+	
+    // 获取当前窗口
+	public static JFrame getFrame(ActionEvent e) {
+		JButton btn = (JButton)e.getSource();
+		JFrame frame = (JFrame)btn.getRootPane().getParent();
+		
+		return frame;
+	}
+	
+	// 获取操作平台信息
+	public static String getLoadLibrary(String library) {
+		String path = "";
+		String os = System.getProperty("os.name");
+		if(os.toLowerCase().startsWith("win")) {
+			path = "./libs/";
+		} else if(os.toLowerCase().startsWith("linux")) {
+			path = "";
+		}
+
+		return (path + library);
+	}
+		
+	public static String getOsName() {
+		String osName = "";
+		String os = System.getProperty("os.name");
+		if(os.toLowerCase().startsWith("win")) {
+			osName = "win";
+		} else if(os.toLowerCase().startsWith("linux")) {
+			osName = "linux";
+		}
+		
+		return osName;
+	}
+	
+	/**
+	 * 读取图片大小
+	 * @param filePath  图片路径
+	 * @return
+	 */
+	public static long GetFileSize(String filePath) {
+		File f = new File(filePath);
+		if (f.exists() && f.isFile()) {
+			return f.length();
+		}
+		else
+		{
+			return 0;
+		}
+	}
+	
+	/**
+	 * 读取图片数据
+	 * @param file 图片路径
+	 * @param memory 图片数据缓存  
+	 * @return
+	 * @throws IOException 
+	 */
+	public static boolean ReadAllFileToMemory(String file, Memory memory) throws IOException {
+		if (memory != Memory.NULL)
+		{
+			long fileLen = GetFileSize(file);
+			if (fileLen <= 0)
+			{
+				return false;
+			}
+			FileInputStream in =null;
+			try {
+				File infile = new File(file);
+				if (infile.canRead())
+				{
+					in = new FileInputStream(infile);
+					int buffLen = 1024; 
+					byte[] buffer = new byte[buffLen];
+					long currFileLen = 0;
+					int readLen = 0;
+					while (currFileLen < fileLen)
+					{
+						readLen = in.read(buffer);
+						memory.write(currFileLen, buffer, 0, readLen);
+						currFileLen += readLen;
+					}										
+					return true;
+				}
+		        else
+		        {
+		        	System.err.println("Failed to open file %s for read!!!\n");
+		            return false;
+		        }
+			}catch (Exception e)
+			{
+				System.err.println("Failed to open file %s for read!!!\n");
+				e.printStackTrace();
+			}finally{
+				if(in!=null){
+					in.close();
+				}				
+			}
+		}
+		
+		return false;
+	}
+	
+	static class JPGFilter extends FileFilter {
+		public boolean accept(File f) {
+			if(f.getName().toLowerCase().endsWith(".JPG")
+					|| f.getName().toLowerCase().endsWith(".jpg") 
+					|| f.isDirectory()) {
+				return true;
+			}
+			return false;
+		}
+
+		@Override
+		public String getDescription() {
+			return "*.jpg; *.JPG";
+		}
+	}
+	
+	/*
+	 * 用选择器选择图片, 获取图片路径，并在界面显示
+	 */
+	public static String openPictureFile(PaintPanel paintPanel) {
+    	try {
+            UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel");
+        } catch (Exception e) {
+        	e.printStackTrace();
+        } 
+    	
+		String picPath = "";
+		
+		// 读取图片
+		JFileChooser jfc = new JFileChooser("d:/");
+		jfc.setMultiSelectionEnabled(false);    // 不可以拖选多个文件
+		jfc.setAcceptAllFileFilterUsed(false);  // 关闭显示所有
+
+		//添加过滤器
+		JPGFilter filter = new JPGFilter();
+		jfc.addChoosableFileFilter(filter);
+		jfc.setFileFilter(filter);
+		
+        if( jfc.showOpenDialog(null) == JFileChooser.APPROVE_OPTION) {
+        	picPath = jfc.getSelectedFile().getAbsolutePath();
+        	
+        	/*
+        	 * 读取本地图片, 并在面板上显示
+        	 */
+        	BufferedImage bufferedImage = null;
+			if(picPath == null || picPath.equals("")) {
+				return "";
+			}
+			
+			File file = new File(picPath);
+			if(!file.exists()) {
+				return "";
+			}
+			
+			try {
+				bufferedImage = ImageIO.read(file);
+			} catch (IOException e) {
+				e.printStackTrace();
+			}
+			
+			if(bufferedImage == null) {
+				paintPanel.setOpaque(true);
+				paintPanel.repaint();
+				
+				System.err.println("打开图片失败，请重新选择！");
+				return "";
+			} else {
+				paintPanel.setOpaque(false);
+				paintPanel.setImage(bufferedImage);
+				paintPanel.repaint();
+			}
+		}
+        
+    	try {
+            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
+        } catch (Exception e) {
+        	e.printStackTrace();
+        } 
+        return picPath;
+	}
+	
+	/*
+	 * 传入图片路径, 打开图片, 并在面板显示
+	 */
+	public static File openPictureFile(String picPath, PaintPanel paintPanel) {		
+    	/*
+    	 * 读取本地图片, 并在面板上显示
+    	 */
+    	BufferedImage bufferedImage = null;
+		if(picPath == null || picPath.equals("")) {
+			return null;
+		}
+		
+		File file = new File(picPath);
+		if(!file.exists()) {
+			return null;
+		}
+		
+		try {
+			bufferedImage = ImageIO.read(file);
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		
+		if(bufferedImage == null) {
+			paintPanel.setOpaque(true);
+			paintPanel.repaint();
+			
+			System.err.println("打开图片失败，请重新选择！");
+			return null;
+		} else {
+			paintPanel.setOpaque(false);
+			paintPanel.setImage(bufferedImage);
+			paintPanel.repaint();
+		}
+		
+        return file;
+	}
+	
+	/**
+	 * 读取图片
+	 * @return 图片缓存
+	 * @throws IOException 
+	 */
+	public static Memory readPictureFile(String picPath) throws IOException {
+		int nPicBufLen = 0;
+		Memory memory = null;
+			
+	    /*
+	     * 读取本地图片大小
+	     */
+		nPicBufLen = (int)ToolKits.GetFileSize(picPath);   
+		
+		// 读取文件大小失败
+		if (nPicBufLen <= 0) {
+			System.err.println("读取图片大小失败，请重新选择！");
+            return null;
+		}
+
+		/*
+		 * 读取图片缓存
+		 */
+		memory = new Memory(nPicBufLen);   // 申请缓存
+		memory.clear();
+		
+		if (!ToolKits.ReadAllFileToMemory(picPath,  memory)) {
+			System.err.println("读取图片数据，请重新选择！");
+            return null;
+		}
+	
+        return memory;
+	}
+	
+	/**
+	 * 登录设备设备错误状态, 用于界面显示
+	 */
+//	public static String getErrorCodeShow() {
+//		return ErrorCode.getErrorCode(LoginModule.netsdk.CLIENT_GetLastError());
+//	}
+	
+	/**
+	 * 获取接口错误码和错误信息，用于打印
+	 * @return
+	 */
+	public static String getErrorCodePrint(int errorCode) {
+		return "\n{error code: (0x80000000|" + (errorCode & 0x7fffffff) +").参考  NetSDKLib.java }"
+				+ " - {error info:" + ErrorCode.getErrorCode(errorCode) + "}\n";
+	}
+	
+	/**
+	 * 获取单个配置
+	 * @param hLoginHandle 登陆句柄
+	 * @param nChn 通道号，-1 表示全通道
+	 * @param strCmd 配置名称
+	 * @param cmdObject 配置对应的结构体对象
+	 * @return 成功返回 true 
+	 */
+	public static boolean GetDevConfig(LLong hLoginHandle, int nChn, String strCmd, Structure cmdObject) {
+		boolean result = false;
+		IntByReference error = new IntByReference(0);
+		int nBufferLen = 2*1024*1024;
+	    byte[] strBuffer = new byte[nBufferLen];
+	   
+	    if(netsdkapi.CLIENT_GetNewDevConfig( hLoginHandle, strCmd , nChn, strBuffer, nBufferLen,error,3000,null)) {  
+	    	cmdObject.write();
+			if (configapi.CLIENT_ParseData(strCmd, strBuffer, cmdObject.getPointer(),
+					cmdObject.size(), null)) {
+				cmdObject.read();
+	     		result = true;
+	     	} else {
+//	     		System.err.println("Parse " + strCmd + " Config Failed!" + ToolKits.getErrorCodePrint());
+	     		result = false;
+		 	}
+	    } else {
+//			 System.err.printf("Get %s Config Failed!Last Error = %s\n" , strCmd , getErrorCodePrint());
+			 result = false;
+		}
+			
+	    return result;
+	}
+	
+	/**
+	 * 设置单个配置
+	 * @param hLoginHandle 登陆句柄
+	 * @param nChn 通道号，-1 表示全通道
+	 * @param strCmd 配置名称
+	 * @param cmdObject 配置对应的结构体对象
+	 * @return 成功返回 true
+	 */
+	public static boolean SetDevConfig(LLong hLoginHandle, int nChn, String strCmd, Structure cmdObject) {
+        boolean result = false;
+    	int nBufferLen = 2*1024*1024;
+        byte szBuffer[] = new byte[nBufferLen];
+        for(int i=0; i<nBufferLen; i++)szBuffer[i]=0;
+    	IntByReference error = new IntByReference(0);
+    	IntByReference restart = new IntByReference(0); 
+
+		cmdObject.write();
+		if (configapi.CLIENT_PacketData(strCmd, cmdObject.getPointer(), cmdObject.size(),
+				szBuffer, nBufferLen)) {	
+			cmdObject.read();
+        	if( netsdkapi.CLIENT_SetNewDevConfig(hLoginHandle, strCmd , nChn , szBuffer, nBufferLen, error, restart, 3000)) {
+        		result = true;
+        	} else {
+//        		 System.err.printf("Set %s Config Failed! Last Error = %s\n" , strCmd , getErrorCodePrint());
+	        	 result = false;
+        	}
+        } else {
+//        	System.err.println("Packet " + strCmd + " Config Failed!" + getErrorCodePrint());
+         	result = false;
+        }
+        
+        return result;
+    }
+	
+    // Win下，将GBK String类型的转为Pointer
+    public static Pointer GetGBKStringToPointer(String src) {	
+    	Pointer pointer = null;
+    	try {
+			byte[] b = src.getBytes("GBK");
+			pointer = new Memory(b.length+1);
+			pointer.clear(b.length+1);
+			
+			pointer.write(0, b, 0, b.length);
+		} catch (UnsupportedEncodingException e) {
+			e.printStackTrace();
+		}
+    	return pointer;
+    }
+    
+    /**
+     * 字符串拷贝，用于先获取，再设置(src → dst)
+     * @param src 
+     * @param dst
+     */
+	public static void StringToByteArray(String src, byte[] dst) {
+		for(int i = 0; i < dst.length; i++) {
+			dst[i] = 0;
+		}
+		
+		System.arraycopy(src.getBytes(), 0, dst, 0, src.getBytes().length);
+	}
+	
+	/**
+	 * 数组拷贝， 用于先获取，再设置(src → dst)
+	 * @param
+	 * @param dst
+	 */
+	public static void ByteArrayToByteArray(byte[] src, byte[] dst) {
+		for(int i = 0; i < dst.length; i++) {
+			dst[i] = 0;
+		}
+		
+		System.arraycopy(src, 0, dst, 0, src.length);
+	}
+}

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/constant/SDKStructureFieldLenth.java

@@ -0,0 +1,87 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.constant;
+
+/**
+ * 一些结构体成员变量的数组长度
+ *
+ * @author 47081 47040
+ * @version 1.0
+ * @since 2020/8/24
+ */
+public class SDKStructureFieldLenth {
+  /** 通用名字字符串长度 */
+  public static final int NET_MAX_NAME_LEN = 16;
+  /** 视频分析设备支持的检测物体类型列表个数上限 */
+  public static final int MAX_OBJECT_LIST_SIZE = 16;
+  /** 一周的天数 */
+  public static final int WEEK_DAY_NUM = 7;
+  /** 录像时间段扩展个数 */
+  public static final int MAX_REC_TSECT_EX = 10;
+  /** 通用字符串长度512 */
+  public static final int SDK_COMMON_STRING_512 = 512;
+  /** 电视墙最大预案数 */
+  public static final int NET_MAX_COLLECTION_NUM = 64;
+  /** 景物点信息最大个数 */
+  public static final int MAX_SCENICSPOT_POINTS_NUM = 256;
+  /** 协议名称长度 */
+  public static final int MAX_PROTOCOL_NAME_LEN = 32;
+  /** 通用字符串长度32 */
+  public static final int CFG_COMMON_STRING_32 = 32;
+  /** 隐私遮挡类型数量 */
+  public static final int MAX_MASKTYPE_COUNT = 8;
+  /** 马赛克遮挡类型数量 */
+  public static final int MAX_MOSAICTYPE_COUNT = 8;
+  /** 最大下位矩阵输出通道数 */
+  public static final int CFG_MAX_LOWER_MATRIX_OUTPUT = 32;
+  /** 最大通道数256 */
+  public static final int CFG_MAX_VIDEO_CHANNEL_NUM = 256;
+  /** 最大多画面预览窗口数 8 */
+  public static final int CFG_MAX_PREVIEW_MODE_SPLIT_TYPE_NUM = 8;
+  /** 规则检测区域最大顶点数 */
+  public static final int SDK_MAX_DETECT_REGION_NUM = 20;
+  /** 检测到目标的最大个数 */
+  public static final int HDBJ_MAX_OBJECTS_NUM = 200;
+  /** 规则检测区域最大顶点数 */
+  public static final int DH_MAX_DETECT_REGION_NUM = 20;
+  /** 最大事件名称长度 */
+  public static final int MAX_EVENT_NAME_LEN = 128;
+  /** 最大标定点个数 */
+  public static final int MAX_CALIBRATE_POINT_NUM = 64;
+  /** 最大的地址长度 */
+  public static final int MAX_ADDRESS_LEN = 256;
+  /** 最大密码长度 */
+  public static final int MAX_PASSWORD_LEN = 64;
+  /** 最大的SIP服务器ID长度 */
+  public static final int MAX_SIP_SVR_ID_LEN = 24;
+  /** 最大的SIP域长度 */
+  public static final int MAX_SIP_DOMAIN_LEN = 128;
+  /** 最大的SIP服务器IP长度 */
+  public static final int MAX_SIP_SVR_IP_LEN = 128;
+  /** 最大的设备编号长度 */
+  public static final int MAX_SIP_SERVER_DEVICE_ID_LEN = 24;
+  /** 最大的注册密码长度 */
+  public static final int MAX_REG_PASSWORD_LEN = 24;
+  /** 最大的行政区划代码长度 */
+  public static final int MAX_CIVIL_CODE_LEN = 24;
+  /** 最大的接入模块识别码长度 */
+  public static final int MAX_INTERVIDEO_ID_LEN = 24;
+  /** 最大的通道编号长度 */
+  public static final int MAX_CHANNEL_ID_LEN = 24;
+  /** 最大的SIP服务器信息个数 */
+  public static final int MAX_SIP_SERVER_NUM = 5;
+  /** 动态检测区域的行数 */
+  public static final int MAX_MOTION_ROW = 32;
+  /** 动态检测区域的列数 */
+  public static final int MAX_MOTION_COL = 32;
+  /** 动检支持的视频窗口值 */
+  public static final int MAX_MOTION_WINDOW = 10;
+  /** 每个云台的最大配置数 */
+  public static final int MAX_CONFIG_NUM=32;
+  /** 最大语音编码类型个数 */
+  public static final int CFG_MAX_AUDIO_ENCODE_TYPE = 64;
+  /** 视频分辨率个数 */
+  public static final int CFG_MAX_CAPTURE_SIZE_NUM = 64;
+  /** 视频编码格式最多种类个数 */
+  public static final int CFG_MAX_COMPRESSION_TYPES_NUM  = 16;
+  /** 路径最大长度 */
+  public static final int MAX_PATH = 260;
+}

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/constant/SDK_ALARM_Ex_TYPE.java

@@ -0,0 +1,45 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.constant;
+
+
+import com.inspect.nvr.daHuaCarme.jna.NetSDKLib;
+import com.inspect.nvr.daHuaCarme.jna.dahua.structure.ALARM_SOLARCELL_SYSTEM_INFO;
+import com.sun.jna.NativeLong;
+import com.sun.jna.Pointer;
+
+/**
+ * @author 47081
+ * @version 1.0
+ * @description \if ENGLISH_LANG
+ * <p>
+ * \else
+ * 扩展报警类型,对应{@link NetSDKLib#CLIENT_StartListenEx(NetSDKLib.LLong)}
+ * \endif
+ * @date 2020/8/11
+ */
+public class SDK_ALARM_Ex_TYPE {
+    /**
+     * 太阳能系统信息上报(对应结构体 {@link ALARM_SOLARCELL_SYSTEM_INFO}),枚举值对应的回调接口{@link com.netsdk.lib.NetSDKLib.fMessCallBack#invoke(int, NetSDKLib.LLong, Pointer, int, String, NativeLong, Pointer)}
+     * 对应的接口{@link NetSDKLib#CLIENT_StartListenEx(NetSDKLib.LLong)}
+     */
+    public static final int SDK_ALARM_SOLARCELL_SYSTEM_INFO = 0x345F;
+
+    /**
+     * 硬盘满报警，数据为1个字节，1为有硬盘满报警，0为无报警。
+     * 对应的回调接口{@link NetSDKLib.fMessCallBack#invoke(int, NetSDKLib.LLong, Pointer, int, String, NativeLong, Pointer)}
+     * 对应的接口{@link NetSDKLib#CLIENT_StartListenEx(NetSDKLib.LLong)}
+     */
+    public static final int SDK_DISKFULL_ALARM_EX = 0x2106;
+    /**
+     * 坏硬盘报警，数据为32个字节，每个字节表示一个硬盘的故障报警状态，1为有报警，0为无报警。
+     * 对应的回调接口{@link NetSDKLib.fMessCallBack#invoke(int, NetSDKLib.LLong, Pointer, int, String, NativeLong, Pointer)}
+     * 对应的接口{@link NetSDKLib#CLIENT_StartListenEx(NetSDKLib.LLong)}
+     */
+    public static final int SDK_DISKERROR_ALARM_EX = 0x2107;
+    /**
+     * 无硬盘报警,对应结构体{@link com.netsdk.lib.structure.ALARM_NO_DISK_INFO}
+     * 对应的回调接口{@link NetSDKLib.fMessCallBack#invoke(int, NetSDKLib.LLong, Pointer, int, String, NativeLong, Pointer)}
+     * 对应的接口{@link NetSDKLib#CLIENT_StartListenEx(NetSDKLib.LLong)}
+     */
+    public static final int SDK_ALARM_NO_DISK = 0x2183;
+
+}

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/CAPTURE_SIZE.java

@@ -0,0 +1,257 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+
+/** 
+* @author 291189
+* @description  分辨率枚举,供DH_DSP_ENCODECAP使用 
+* @date 2022/08/31 14:44:17
+*/
+public enum CAPTURE_SIZE {
+/**
+704*576(PAL)  704*480(NTSC),兼容WWxHH,下同
+*/
+    CAPTURE_SIZE_D1(0, "704*576(PAL)  704*480(NTSC),兼容WWxHH,下同"),
+/**
+352*576(PAL)  352*480(NTSC)
+*/
+    CAPTURE_SIZE_HD1(1, "352*576(PAL)  352*480(NTSC)"),
+/**
+704*288(PAL)  704*240(NTSC)
+*/
+    CAPTURE_SIZE_BCIF(2, "704*288(PAL)  704*240(NTSC)"),
+/**
+352*288(PAL)  352*240(NTSC)
+*/
+    CAPTURE_SIZE_CIF(3, "352*288(PAL)  352*240(NTSC)"),
+/**
+176*144(PAL)  176*120(NTSC)
+*/
+    CAPTURE_SIZE_QCIF(4, "176*144(PAL)  176*120(NTSC)"),
+/**
+640*480
+*/
+    CAPTURE_SIZE_VGA(5, "640*480"),
+/**
+320*240
+*/
+    CAPTURE_SIZE_QVGA(6, "320*240"),
+/**
+480*480
+*/
+    CAPTURE_SIZE_SVCD(7, "480*480"),
+/**
+160*128
+*/
+    CAPTURE_SIZE_QQVGA(8, "160*128"),
+/**
+800*592
+*/
+    CAPTURE_SIZE_SVGA(9, "800*592"),
+/**
+1024*768
+*/
+    CAPTURE_SIZE_XVGA(10, "1024*768"),
+/**
+1280*800
+*/
+    CAPTURE_SIZE_WXGA(11, "1280*800"),
+/**
+1280*1024
+*/
+    CAPTURE_SIZE_SXGA(12, "1280*1024"),
+/**
+1600*1024
+*/
+    CAPTURE_SIZE_WSXGA(13, "1600*1024"),
+/**
+1600*1200
+*/
+    CAPTURE_SIZE_UXGA(14, "1600*1200"),
+/**
+1920*1200
+*/
+    CAPTURE_SIZE_WUXGA(15, "1920*1200"),
+/**
+240*192,ND1
+*/
+    CAPTURE_SIZE_LTF(16, "240*192,ND1"),
+/**
+1280*720
+*/
+    CAPTURE_SIZE_720(17, "1280*720"),
+/**
+1920*1080
+*/
+    CAPTURE_SIZE_1080(18, "1920*1080"),
+/**
+1280*960
+*/
+    CAPTURE_SIZE_1_3M(19, "1280*960"),
+/**
+1872*1408,2_5M
+*/
+    CAPTURE_SIZE_2M(20, "1872*1408,2_5M"),
+/**
+3744*1408
+*/
+    CAPTURE_SIZE_5M(21, "3744*1408"),
+/**
+2048*1536
+*/
+    CAPTURE_SIZE_3M(22, "2048*1536"),
+/**
+2432*2050
+*/
+    CAPTURE_SIZE_5_0M(23, "2432*2050"),
+/**
+1216*1024
+*/
+    CPTRUTE_SIZE_1_2M(24, "1216*1024"),
+/**
+1408*1024
+*/
+    CPTRUTE_SIZE_1408_1024(25, "1408*1024"),
+/**
+3296*2472
+*/
+    CPTRUTE_SIZE_8M(26, "3296*2472"),
+/**
+2560*1920(5_1M)
+*/
+    CPTRUTE_SIZE_2560_1920(27, "2560*1920(5_1M)"),
+/**
+960*576(PAL) 960*480(NTSC)
+*/
+    CAPTURE_SIZE_960H(28, "960*576(PAL) 960*480(NTSC)"),
+/**
+960*720
+*/
+    CAPTURE_SIZE_960_720(29, "960*720"),
+/**
+640*360
+*/
+    CAPTURE_SIZE_NHD(30, "640*360"),
+/**
+320*180
+*/
+    CAPTURE_SIZE_QNHD(31, "320*180"),
+/**
+160*90
+*/
+    CAPTURE_SIZE_QQNHD(32, "160*90"),
+/**
+960*540
+*/
+    CAPTURE_SIZE_960_540(33, "960*540"),
+/**
+640*352
+*/
+    CAPTURE_SIZE_640_352(34, "640*352"),
+/**
+640*400
+*/
+    CAPTURE_SIZE_640_400(35, "640*400"),
+/**
+320*192
+*/
+    CAPTURE_SIZE_320_192(36, "320*192"),
+/**
+320*176
+*/
+    CAPTURE_SIZE_320_176(37, "320*176"),
+/**
+800*600
+*/
+    CAPTURE_SIZE_SVGA1(38, "800*600"),
+/**
+2560*1440
+*/
+    CAPTURE_SIZE_2560_1440(39, "2560*1440"),
+/**
+2304*1296
+*/
+    CAPTURE_SIZE_2304_1296(40, "2304*1296"),
+/**
+2592*1520
+*/
+    CAPTURE_SIZE_2592_1520(41, "2592*1520"),
+/**
+4000*3000
+*/
+    CAPTURE_SIZE_4000_3000(42, "4000*3000"),
+/**
+2880*2880
+*/
+    CAPTURE_SIZE_2880_2880(43, "2880*2880"),
+/**
+2880*2160
+*/
+    CAPTURE_SIZE_2880_2160(44, "2880*2160"),
+/**
+2688*1520
+*/
+    CAPTURE_SIZE_2688_1520(45, "2688*1520"),
+/**
+2592*1944
+*/
+    CAPTURE_SIZE_2592_1944(46, "2592*1944"),
+/**
+3072*1728
+*/
+    CAPTURE_SIZE_3072_1728(47, "3072*1728"),
+/**
+3072*2048
+*/
+    CAPTURE_SIZE_3072_2048(48, "3072*2048"),
+/**
+3840*2160
+*/
+    CAPTURE_SIZE_3840_2160(49, "3840*2160"),
+/**
+
+*/
+    CAPTURE_SIZE_NR(25, "");
+
+private int value;
+private String note;
+
+public String getNote() {
+        return note;
+    }
+
+public int getValue() {
+        return value;
+    }
+
+CAPTURE_SIZE(int givenValue, String note) {
+        this.value = givenValue;
+        this.note = note;
+    }
+
+public static String getNoteByValue(int givenValue) {
+        for (CAPTURE_SIZE enumType : CAPTURE_SIZE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+public static int getValueByNote(String givenNote) {
+        for (CAPTURE_SIZE enumType : CAPTURE_SIZE.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+
+public static CAPTURE_SIZE getEnum(int value) {
+        for (CAPTURE_SIZE e : CAPTURE_SIZE.values()) {
+            if (e.getValue() == value)
+                return e;
+        }
+        return CAPTURE_SIZE.CAPTURE_SIZE_D1;
+    }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/CFG_ACCESS_PROPERTY_TYPE.java

@@ -0,0 +1,25 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * @author 47081
+ * @version 1.0
+ * @description 门禁单双向配置类型
+ * @date 2021/2/7
+ */
+public enum CFG_ACCESS_PROPERTY_TYPE {
+  /** 未知 */
+    CFG_ACCESS_PROPERTY_UNKNOWN(0, "未知"),
+  /** 双向门禁 */
+    CFG_ACCESS_PROPERTY_BIDIRECT(1, "双向门禁"),
+  /** 单向门禁 */
+    CFG_ACCESS_PROPERTY_UNIDIRECT(2, "单向门禁");
+
+  private int type;
+  private String desc;
+
+  CFG_ACCESS_PROPERTY_TYPE(int type, String desc) {
+    this.type = type;
+    this.desc = desc;
+  }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/CFG_DEFOG_MODE.java

@@ -0,0 +1,71 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+
+/** 
+* @author 291189
+* @description  透雾模式枚举 
+* @origin autoTool
+* @date 2023/11/30 15:50:58
+*/
+public enum CFG_DEFOG_MODE {
+	/**
+     * 未知方式
+     */
+    EM_DEFOG_MODE_UNKNOW(0, "未知方式"),
+	/**
+     * 关闭
+     */
+    EM_DEFOG_MODE_OFF(1, "关闭"),
+	/**
+     * 自动
+     */
+    EM_DEFOG_MODE_AUTO(2, "自动"),
+	/**
+     * 手动
+     */
+    EM_DEFOG_MODE_MANA(3, "手动");
+
+private int value;
+private String note;
+
+public String getNote() {
+        return note;
+    }
+
+public int getValue() {
+        return value;
+    }
+
+CFG_DEFOG_MODE(int givenValue, String note) {
+        this.value = givenValue;
+        this.note = note;
+    }
+
+public static String getNoteByValue(int givenValue) {
+        for (CFG_DEFOG_MODE enumType : CFG_DEFOG_MODE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+public static int getValueByNote(String givenNote) {
+        for (CFG_DEFOG_MODE enumType : CFG_DEFOG_MODE.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+
+public static CFG_DEFOG_MODE getEnum(int value) {
+        for (CFG_DEFOG_MODE e : CFG_DEFOG_MODE.values()) {
+            if (e.getValue() == value){
+                return e;
+            }
+        }
+        return CFG_DEFOG_MODE.EM_DEFOG_MODE_UNKNOW;
+    }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/CFG_EM_ASG_VOICE_DIRECTION.java

@@ -0,0 +1,47 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * @author 47081
+ * @version 1.0
+ * @description 闸机进出语音方向
+ * @date 2021/2/7
+ */
+public enum CFG_EM_ASG_VOICE_DIRECTION {
+    CFG_EM_ASG_VOICE_DIRECTION_UNKNOWN(0, "未知"),
+    CFG_EM_ASG_VOICE_DIRECTION_ENTER(1, "进入"),
+    CFG_EM_ASG_VOICE_DIRECTION_LEAVE(2, "离开");
+
+  private int direction;
+  private String desc;
+
+  CFG_EM_ASG_VOICE_DIRECTION(int direction, String desc) {
+    this.direction = direction;
+    this.desc = desc;
+  }
+
+  public static CFG_EM_ASG_VOICE_DIRECTION getVoiceDirection(int direction) {
+    for (CFG_EM_ASG_VOICE_DIRECTION voiceDirection : CFG_EM_ASG_VOICE_DIRECTION.values()) {
+      if (voiceDirection.direction == direction) {
+        return voiceDirection;
+      }
+    }
+    return CFG_EM_ASG_VOICE_DIRECTION_UNKNOWN;
+  }
+
+  public int getDirection() {
+    return direction;
+  }
+
+  public void setDirection(int direction) {
+    this.direction = direction;
+  }
+
+  public String getDesc() {
+    return desc;
+  }
+
+  public void setDesc(String desc) {
+    this.desc = desc;
+  }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/CFG_EM_BODY_TRAIT.java

@@ -0,0 +1,92 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * @author 251823
+ * @description 人体检测及人体识别支持的身体特征
+ * @date 2021/01/11
+ */
+public enum CFG_EM_BODY_TRAIT {
+	// 未知
+    CFG_EM_BODY_TRAIT_UNKNOWN(0, "未知"),
+	// 性别
+    CFG_EM_BODY_TRAIT_SEX(1, "性别"),
+	// 年龄组
+    CFG_EM_BODY_TRAIT_AGEGROUP(2, "年龄组"),
+	// 上衣
+    CFG_EM_BODY_TRAIT_COATTYPE(3, "上衣"),
+	// 裤子
+    CFG_EM_BODY_TRAIT_TROUSERSTYPE(4, "裤子"),
+	// 人体角度
+    CFG_EM_BODY_TRAIT_ANGLE(5, "人体角度"),
+	// 上衣模式
+    CFG_EM_BODY_TRAIT_UPPERPATTERN(6, "上衣模式"),
+	// 裤子颜色
+    CFG_EM_BODY_TRAIT_TROUSERSCOLOR(7, "裤子颜色"),
+	// 打伞
+    CFG_EM_BODY_TRAIT_UMBRELLA(8, "打伞"),
+	// 雨伞颜色
+    CFG_EM_BODY_TRAIT_UMBRELLACOLOR(9, "雨伞颜色"),
+	// 胸前报东西
+    CFG_EM_BODY_TRAIT_HOLD(10, "胸前报东西"),
+	// 裤子模式
+    CFG_EM_BODY_TRAIT_TROUSERSPATTERN(11, "裤子模式"),
+	// 帽子款式
+    CFG_EM_BODY_TRAIT_HATTYPE(12, "帽子款式"),
+	// 帽子颜色
+    CFG_EM_BODY_TRAIT_HATCOLOR(13, "帽子颜色"),
+	// 上衣款式
+    CFG_EM_BODY_TRAIT_UPPERTYPE(14, "上衣款式"),
+	// 上衣颜色
+    CFG_EM_BODY_TRAIT_COATCOLOR(15, "上衣颜色"),
+	// 发型
+    CFG_EM_BODY_TRAIT_HAIRSTYLE(16, "发型"),
+	// 头发颜色
+    CFG_EM_BODY_TRAIT_HAIRCOLOR(17, "头发颜色"),
+	// 鞋子款式
+    CFG_EM_BODY_TRAIT_SHOESTYPE(18, "鞋子款式"),
+	// 鞋子颜色
+    CFG_EM_BODY_TRAIT_SHOESCOLOR(19, "鞋子颜色"),
+	// 箱包款式
+    CFG_EM_BODY_TRAIT_BAG(20, "箱包款式"),
+	// 箱包颜色
+    CFG_EM_BODY_TRAIT_BAGCOLOR(21, "箱包颜色"),
+	// 口罩
+    CFG_EM_BODY_TRAIT_MASK(22, "口罩"),
+	// 口罩颜色
+    CFG_EM_BODY_TRAIT_MASKCOLOR(23, "口罩颜色");
+
+	private int value;
+	private String note;
+
+	private CFG_EM_BODY_TRAIT(int givenValue, String note) {
+		this.value = givenValue;
+		this.note = note;
+	}
+
+	public String getNote() {
+		return note;
+	}
+
+	public int getValue() {
+		return value;
+	}
+
+	public static String getNoteByValue(int givenValue) {
+		for (CFG_EM_BODY_TRAIT enumType : CFG_EM_BODY_TRAIT.values()) {
+			if (givenValue == enumType.getValue()) {
+				return enumType.getNote();
+			}
+		}
+		return null;
+	}
+
+	public static int getValueByNote(String givenNote) {
+		for (CFG_EM_BODY_TRAIT enumType : CFG_EM_BODY_TRAIT.values()) {
+			if (givenNote.equals(enumType.getNote())) {
+				return enumType.getValue();
+			}
+		}
+		return -1;
+	}
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/CFG_EM_FACEDETECT_TYPE.java

@@ -0,0 +1,52 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * @author 251823
+ * @description 智能类型
+ * @date 2021/01/11
+ */
+public enum CFG_EM_FACEDETECT_TYPE {
+	// 未知
+    CFG_EM_FACEDETECT_TYPE_UNKNOWN(0, "未知"),
+	// 可见光
+    CFG_EM_FACEDETECT_TYPE_VISUAL(1, "可见光"),
+	// 红外
+    CFG_EM_FACEDETECT_TYPE_THERMAL(2, "红外"),
+	// 按时间段切换
+    CFG_EM_FACEDETECT_TYPE_SWITCHBYTIME(3, "按时间段切换");
+
+	private int value;
+	private String note;
+
+	private CFG_EM_FACEDETECT_TYPE(int givenValue, String note) {
+		this.value = givenValue;
+		this.note = note;
+	}
+
+	public String getNote() {
+		return note;
+	}
+
+	public int getValue() {
+		return value;
+	}
+
+	public static String getNoteByValue(int givenValue) {
+		for (CFG_EM_FACEDETECT_TYPE enumType : CFG_EM_FACEDETECT_TYPE.values()) {
+			if (givenValue == enumType.getValue()) {
+				return enumType.getNote();
+			}
+		}
+		return null;
+	}
+
+	public static int getValueByNote(String givenNote) {
+		for (CFG_EM_FACEDETECT_TYPE enumType : CFG_EM_FACEDETECT_TYPE.values()) {
+			if (givenNote.equals(enumType.getNote())) {
+				return enumType.getValue();
+			}
+		}
+		return -1;
+	}
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/CFG_EM_FACE_SNAP_POLICY.java

@@ -0,0 +1,64 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * @author 251823
+ * @description 人体检测及人体识别支持的脸部抓拍策略
+ * @date 2021/01/11
+ */
+public enum CFG_EM_FACE_SNAP_POLICY {
+	// 未知
+    CFG_EM_FACE_SNAP_POLICY_UNKNOWN(0, "未知"),
+	// 实时抓拍模式(当前的通用模式，实时性优先)
+    CFG_EM_FACE_SNAP_POLICY_REALTIME(1, "实时抓拍模式"),
+	// 优选抓拍模式，在设定的延时区间(OptimalTime)内挑选评分最高的抓图，准确性优先但延时较大
+    CFG_EM_FACE_SNAP_POLICY_OPTIMAL(2, "优选抓拍模式"),
+	// 质量抓拍模式，在Optimal的基础上，如果图片质量好于阈值提前结束优选，提高实时性
+    CFG_EM_FACE_SNAP_POLICY_QUALITY(3, "质量抓拍模式"),
+	// 识别优先抓拍模式，在优选时间内，以一定间隔帧数多次进行比对；一旦比对成功则立即结束优选，以提高对比成功率，取代质量优先模式
+    CFG_EM_FACE_SNAP_POLICY_RECOGNITION(4, "识别优先抓拍模式"),
+	// 快速优选，从检测到人脸/人体开始，抓拍一定帧数内的质量最好的人脸或人体,
+    CFG_EM_FACE_SNAP_POLICY_QUICK(5, "快速优选"),
+	// 全程优选，抓拍全程质量最好的人脸人体，
+    CFG_EM_FACE_SNAP_POLICY_FULLTRACK(6, "全程优选"),
+	// 间隔抓拍，
+    CFG_EM_FACE_SNAP_POLICY_INTERVAL(7, "间隔抓拍"),
+	// 单人模式，常用于门禁，
+    CFG_EM_FACE_SNAP_POLICY_SINGLE(8, "单人模式"),
+	// 高精度模式，增强目标识别，，增强目标识别，
+    CFG_EM_FACE_SNAP_POLICY_PRECISION(9, "高精度模式");
+
+	private int value;
+	private String note;
+
+	private CFG_EM_FACE_SNAP_POLICY(int givenValue, String note) {
+		this.value = givenValue;
+		this.note = note;
+	}
+
+	public String getNote() {
+		return note;
+	}
+
+	public int getValue() {
+		return value;
+	}
+
+	public static String getNoteByValue(int givenValue) {
+		for (CFG_EM_FACE_SNAP_POLICY enumType : CFG_EM_FACE_SNAP_POLICY.values()) {
+			if (givenValue == enumType.getValue()) {
+				return enumType.getNote();
+			}
+		}
+		return null;
+	}
+
+	public static int getValueByNote(String givenNote) {
+		for (CFG_EM_FACE_SNAP_POLICY enumType : CFG_EM_FACE_SNAP_POLICY.values()) {
+			if (givenNote.equals(enumType.getNote())) {
+				return enumType.getValue();
+			}
+		}
+		return -1;
+	}
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/CFG_EM_FACE_TRAIT.java

@@ -0,0 +1,58 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * @author 251823
+ * @description 人体检测及人体识别支持的脸部特征
+ * @date 2021/01/11
+ */
+public enum CFG_EM_FACE_TRAIT {
+	// 未知
+    CFG_EM_FACE_TRAIT_UNKNOWN(0, "未知"),
+	// 性别
+    CFG_EM_FACE_TRAIT_SEX(1, "性别"),
+	// 年龄
+    CFG_EM_FACE_TRAIT_AGE(2, "年龄"),
+	// 眼镜
+    CFG_EM_FACE_TRAIT_GLASSES(3, "眼镜"),
+    // 胡子
+    CFG_EM_FACE_TRAIT_BEARD(4, "胡子"),
+    // 口罩
+    CFG_EM_FACE_TRAIT_MASK(5, "口罩"),
+    // 表情
+    CFG_EM_FACE_TRAIT_EMOTION(6, "表情");
+
+	private int value;
+	private String note;
+
+	private CFG_EM_FACE_TRAIT(int givenValue, String note) {
+		this.value = givenValue;
+		this.note = note;
+	}
+
+	public String getNote() {
+		return note;
+	}
+
+	public int getValue() {
+		return value;
+	}
+
+	public static String getNoteByValue(int givenValue) {
+		for (CFG_EM_FACE_TRAIT enumType : CFG_EM_FACE_TRAIT.values()) {
+			if (givenValue == enumType.getValue()) {
+				return enumType.getNote();
+			}
+		}
+		return null;
+	}
+
+	public static int getValueByNote(String givenNote) {
+		for (CFG_EM_FACE_TRAIT enumType : CFG_EM_FACE_TRAIT.values()) {
+			if (givenNote.equals(enumType.getNote())) {
+				return enumType.getValue();
+			}
+		}
+		return -1;
+	}
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/CFG_EM_INSTANCE_SUBCLASS_TYPE.java

@@ -0,0 +1,48 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * @author 251823
+ * @description 智能分析实例类型
+ * @date 2021/01/11
+ */
+public enum CFG_EM_INSTANCE_SUBCLASS_TYPE {
+	// 本地实例
+    CFG_EM_INSTANCE_SUBCLASS_TYPE_LOCAL(0, "本地实例"),
+	// 远程实例
+    CFG_EM_INSTANCE_SUBCLASS_TYPE_REMOTE(1, "远程实例");
+
+	private int value;
+	private String note;
+
+	private CFG_EM_INSTANCE_SUBCLASS_TYPE(int givenValue, String note) {
+		this.value = givenValue;
+		this.note = note;
+	}
+
+	public String getNote() {
+		return note;
+	}
+
+	public int getValue() {
+		return value;
+	}
+
+	public static String getNoteByValue(int givenValue) {
+		for (CFG_EM_INSTANCE_SUBCLASS_TYPE enumType : CFG_EM_INSTANCE_SUBCLASS_TYPE.values()) {
+			if (givenValue == enumType.getValue()) {
+				return enumType.getNote();
+			}
+		}
+		return null;
+	}
+
+	public static int getValueByNote(String givenNote) {
+		for (CFG_EM_INSTANCE_SUBCLASS_TYPE enumType : CFG_EM_INSTANCE_SUBCLASS_TYPE.values()) {
+			if (givenNote.equals(enumType.getNote())) {
+				return enumType.getValue();
+			}
+		}
+		return -1;
+	}
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/CFG_EM_PREVIEW_MODE.java

@@ -0,0 +1,67 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * @author 47040
+ * @since Created at 2021/5/25 22:29
+ */
+public enum CFG_EM_PREVIEW_MODE {
+    /**
+     * 未知
+     */
+    CFG_EM_PREVIEW_MODE_UNKNOWN(0, "未知"),
+    /**
+     * 快照方式
+     */
+    CFG_EM_PREVIEW_MODE_SNAPSHOT(1, "快照方式"),
+    /**
+     * 分割编码方式
+     */
+    CFG_EM_PREVIEW_MODE_SPLITENCODE(2, "分割编码方式"),
+    /**
+     * 分割快照方式
+     */
+    CFG_EM_PREVIEW_MODE_SPLITSNAP(3, "分割快照方式");
+
+    private final int value;
+    private final String note;
+
+    CFG_EM_PREVIEW_MODE(int givenValue, String note) {
+        this.value = givenValue;
+        this.note = note;
+    }
+
+    public String getNote() {
+        return note;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    public static String getNoteByValue(int givenValue) {
+        for (CFG_EM_PREVIEW_MODE enumType : CFG_EM_PREVIEW_MODE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+    public static int getValueByNote(String givenNote) {
+        for (CFG_EM_PREVIEW_MODE enumType : CFG_EM_PREVIEW_MODE.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+
+    public static CFG_EM_PREVIEW_MODE getEnum(int value) {
+        for (CFG_EM_PREVIEW_MODE e : CFG_EM_PREVIEW_MODE.values()) {
+            if (e.getValue() == value)
+                return e;
+        }
+        return CFG_EM_PREVIEW_MODE.CFG_EM_PREVIEW_MODE_UNKNOWN;
+    }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/CFG_EM_STREAM_TYPES.java

@@ -0,0 +1,72 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * @author 251823
+ * @description 码流类型
+ * @date 2022/07/20 14:11:30
+ */
+public enum CFG_EM_STREAM_TYPES {
+	/**
+	 * 其它
+	 */
+    CFG_EM_STREAMTYPE_ERR(0, "其它"),
+	/**
+	 * Main -主码流
+	 */
+    CFG_EM_STREAMTYPE_MAIN(1, "Main -主码流"),
+	/**
+	 * Extra1 -辅码流1
+	 */
+    CFG_EM_STREAMTYPE_EXTRA_1(2, "Extra1 -辅码流1"),
+	/**
+	 * Extra2 -辅码流2
+	 */
+    CFG_EM_STREAMTYPE_EXTRA_2(3, "Extra2 -辅码流2"),
+	/**
+	 * Extra3 -辅码流3
+	 */
+    CFG_EM_STREAMTYPE_EXTRA_3(4, "Extra3 -辅码流3"),
+	/**
+	 * Snapshot -抓图码流
+	 */
+    CFG_EM_STREAMTYPE_SNAPSHOT(5, "Snapshot -抓图码流"),
+	/**
+	 * Talkback -对讲码流
+	 */
+    CFG_EM_STREAMTYPE_TALKBACK(6, "Talkback -对讲码流");
+
+	private int value;
+	private String note;
+
+	public String getNote() {
+		return note;
+	}
+
+	public int getValue() {
+		return value;
+	}
+
+	CFG_EM_STREAM_TYPES(int givenValue, String note) {
+		this.value = givenValue;
+		this.note = note;
+	}
+
+	public static String getNoteByValue(int givenValue) {
+		for (CFG_EM_STREAM_TYPES enumType : CFG_EM_STREAM_TYPES.values()) {
+			if (givenValue == enumType.getValue()) {
+				return enumType.getNote();
+			}
+		}
+		return null;
+	}
+
+	public static int getValueByNote(String givenNote) {
+		for (CFG_EM_STREAM_TYPES enumType : CFG_EM_STREAM_TYPES.values()) {
+			if (givenNote.equals(enumType.getNote())) {
+				return enumType.getValue();
+			}
+		}
+		return -1;
+	}
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/CFG_EM_VOICE_ID.java

@@ -0,0 +1,72 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * @author 47081
+ * @version 1.0
+ * @description 语音ID
+ * @date 2021/2/7
+ */
+public enum CFG_EM_VOICE_ID {
+  /** 未知 */
+    CFG_EM_VOICE_ID_UNKNOWN(-1, "未知"),
+  /** 验证成功(默认) */
+    CFG_EM_VOICE_ID_VERIFY_SUCCESS(0, "验证成功(默认)"),
+  /** 开门成功 */
+    CFG_EM_VOICE_ID_OPENDOOR_SUCCESS(1, "开门成功"),
+  /** 开锁成功 */
+    CFG_EM_VOICE_ID_UNLOCK_SUCCESS(2, "开锁成功"),
+  /** 刷卡成功 */
+    CFG_EM_VOICE_ID_SWIPECARD_SUCCESS(3, "刷卡成功"),
+  /** 欢迎光临 */
+    CFG_EM_VOICE_ID_WELCOME(4, "欢迎光临"),
+  /** 欢迎再次光临 */
+    CFG_EM_VOICE_ID_WELCOME_BACK(5, "欢迎再次光临"),
+  /** 谢谢 */
+    CFG_EM_VOICE_ID_THANKS(6, "谢谢"),
+  /** 自定义 */
+    CFG_EM_VOICE_ID_CUSTOMIZED_VOICE(7, "自定义"),
+  /** 无声音 */
+    CFG_EM_VOICE_ID_NO_VOICE(8, "无声音"),
+  /** 欢迎回家 */
+    CFG_EM_VOICE_ID_WELCOME_HOME(9, "欢迎回家"),
+  /** 一路顺风 */
+    CFG_EM_VOICE_ID_GOOD_JOURNEY(10, "一路顺风"),
+  /** 欢迎下次光临 */
+    CFG_EM_VOICE_ID_WELCOME_BACK_NEXT(11, "欢迎下次光临"),
+  /** 谢谢惠顾 */
+    CFG_EM_VOICE_ID_THANKS_FOR_PATRONAGE(12, "谢谢惠顾");
+
+  private int id;
+  private String desc;
+
+  CFG_EM_VOICE_ID(int id, String desc) {
+    this.id = id;
+    this.desc = desc;
+  }
+
+  public static CFG_EM_VOICE_ID getVoiceID(int id) {
+    for (CFG_EM_VOICE_ID voiceID : CFG_EM_VOICE_ID.values()) {
+      if (voiceID.id == id) {
+        return voiceID;
+      }
+    }
+    return CFG_EM_VOICE_ID_UNKNOWN;
+  }
+
+  public int getId() {
+    return id;
+  }
+
+  public void setId(int id) {
+    this.id = id;
+  }
+
+  public String getDesc() {
+    return desc;
+  }
+
+  public void setDesc(String desc) {
+    this.desc = desc;
+  }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/CFG_LIGHT_INTENSITY_MODE.java

@@ -0,0 +1,67 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+
+/** 
+* @author 291189
+* @description  大气光模式枚举 
+* @origin autoTool
+* @date 2023/11/30 15:50:59
+*/
+public enum CFG_LIGHT_INTENSITY_MODE {
+	/**
+     * 未知方式
+     */
+    EM_LIGHT_INTENSITY_MODE_UNKNOW(0, "未知方式"),
+	/**
+     * 自动
+     */
+    EM_LIGHT_INTENSITY_MODE_AUTO(1, "自动"),
+	/**
+     * 手动
+     */
+    EM_LIGHT_INTENSITY_MODE_MANUL(2, "手动");
+
+private int value;
+private String note;
+
+public String getNote() {
+        return note;
+    }
+
+public int getValue() {
+        return value;
+    }
+
+CFG_LIGHT_INTENSITY_MODE(int givenValue, String note) {
+        this.value = givenValue;
+        this.note = note;
+    }
+
+public static String getNoteByValue(int givenValue) {
+        for (CFG_LIGHT_INTENSITY_MODE enumType : CFG_LIGHT_INTENSITY_MODE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+public static int getValueByNote(String givenNote) {
+        for (CFG_LIGHT_INTENSITY_MODE enumType : CFG_LIGHT_INTENSITY_MODE.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+
+public static CFG_LIGHT_INTENSITY_MODE getEnum(int value) {
+        for (CFG_LIGHT_INTENSITY_MODE e : CFG_LIGHT_INTENSITY_MODE.values()) {
+            if (e.getValue() == value){
+                return e;
+            }
+        }
+        return CFG_LIGHT_INTENSITY_MODE.EM_LIGHT_INTENSITY_MODE_UNKNOW;
+    }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/CFG_PTZ_FUNC_TYPE.java

@@ -0,0 +1,58 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * @创建人 291189
+ * @创建时间 2021/5/28
+ * @描述
+ */
+public enum CFG_PTZ_FUNC_TYPE {
+    /**
+     * 巡航
+     */
+    FUNC_TYPE_TOUR(0, "巡航"),
+    /**
+     * 自动巡迹
+     */
+    FUNC_TYPE_PATTERN(1, "自动巡迹"),
+    /**
+     * 预置点
+     */
+    FUNC_TYPE_PRE(2, "预置点"),
+    FUNC_TYPE_SCAN(3, "自动线扫"),
+    FUNC_TYPE_MAX(4, "最大值");
+
+   private int id;
+    private String desc;
+
+    CFG_PTZ_FUNC_TYPE(int id, String desc) {
+        this.id = id;
+        this.desc = desc;
+    }
+
+    public int getId() {
+        return id;
+    }
+
+    public String getDesc() {
+        return desc;
+    }
+
+    public static String getDescById(int id) {
+        for (CFG_PTZ_FUNC_TYPE enumType : CFG_PTZ_FUNC_TYPE.values()) {
+            if (id == enumType.getId()) {
+                return enumType.desc;
+            }
+        }
+        return null;
+    }
+
+    public static int getIdByValue(String desc) {
+        for (CFG_PTZ_FUNC_TYPE enumType : CFG_PTZ_FUNC_TYPE.values()) {
+            if (desc.equals(enumType.getDesc())) {
+                return enumType.getId();
+            }
+        }
+        return -1;
+    }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/CFG_VIDEO_COMPRESSION.java

@@ -0,0 +1,61 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * @author 47040
+ * @since Created at 2021/5/26 20:44
+ */
+public enum CFG_VIDEO_COMPRESSION {
+    VIDEO_FORMAT_MPEG4(0, "MPEG4"),
+    VIDEO_FORMAT_MS_MPEG4(1, "MS-MPEG4"),
+    VIDEO_FORMAT_MPEG2(2, "MPEG2"),
+    VIDEO_FORMAT_MPEG1(3, "MPEG1"),
+    VIDEO_FORMAT_H263(4, "H.263"),
+    VIDEO_FORMAT_MJPG(5, "MJPG"),
+    VIDEO_FORMAT_FCC_MPEG4(6, "FCC-MPEG4"),
+    VIDEO_FORMAT_H264(7, "H.264"),
+    VIDEO_FORMAT_H265(8, "H.265"),
+    VIDEO_FORMAT_SVAC(9, "SVAC");
+
+    private final int value;
+    private final String note;
+
+    CFG_VIDEO_COMPRESSION(int givenValue, String note) {
+        this.value = givenValue;
+        this.note = note;
+    }
+
+    public String getNote() {
+        return note;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    public static String getNoteByValue(int givenValue) {
+        for (CFG_VIDEO_COMPRESSION enumType : CFG_VIDEO_COMPRESSION.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+    public static int getValueByNote(String givenNote) {
+        for (CFG_VIDEO_COMPRESSION enumType : CFG_VIDEO_COMPRESSION.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+
+    public static CFG_VIDEO_COMPRESSION getEnum(int value) {
+        for (CFG_VIDEO_COMPRESSION e : CFG_VIDEO_COMPRESSION.values()) {
+            if (e.getValue() == value)
+                return e;
+        }
+        return CFG_VIDEO_COMPRESSION.VIDEO_FORMAT_H264;
+    }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/DH_LOG_QUERY_TYPE.java

@@ -0,0 +1,50 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * 日志查询类型
+ *
+ * @author 47081
+ */
+public enum DH_LOG_QUERY_TYPE {
+    /**
+     * 所有日志
+     */
+    DHLOG_ALL,
+    /**
+     * 系统日志
+     */
+    DHLOG_SYSTEM,
+    /**
+     * 配置日志
+     */
+    DHLOG_CONFIG,
+    /**
+     * 存储相关
+     */
+    DHLOG_STORAGE,
+    /**
+     * 报警日志
+     */
+    DHLOG_ALARM,
+    /**
+     * 录象相关
+     */
+    DHLOG_RECORD,
+    /**
+     * 帐号相关
+     */
+    DHLOG_ACCOUNT,
+    /**
+     * 清除日志
+     */
+    DHLOG_CLEAR,
+    /**
+     * 回放相关
+     */
+    DHLOG_PLAYBACK,
+    /**
+     * 前端管理运行相关
+     */
+    DHLOG_MANAGER;
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EMDeviceType.java

@@ -0,0 +1,296 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * @author 47081
+ * @version 1.0
+ * @description 设备类型
+ * @date 2020/9/12
+ */
+public enum EMDeviceType {
+    /**
+     * none
+     */
+    NET_PRODUCT_NONE(0, "未知"),
+    /**
+     * 非实时MACE
+     */
+    NET_DVR_NONREALTIME_MACE(1, "非实时MACE"),
+    /**
+     * 非实时
+     */
+    NET_DVR_NONREALTIME(2, "非实时"),
+    /**
+     * 网络视频服务器
+     */
+    NET_NVS_MPEG1(3, "网络视频服务器"),
+    /**
+     * MPEG1二路录像机
+     */
+    NET_DVR_MPEG1_2(4, "MPEG1二路录像机"),
+    /**
+     * MPEG1八路录像机
+     */
+    NET_DVR_MPEG1_8(5, "MPEG1八路录像机"),
+    /**
+     * MPEG4八路录像机
+     */
+    NET_DVR_MPEG4_8(6, "MPEG4八路录像机"),
+    /**
+     * MPEG4十六路录像机
+     */
+    NET_DVR_MPEG4_16(7, "MPEG4十六路录像机"),
+    /**
+     * LB系列录像机
+     */
+    NET_DVR_MPEG4_SX2(8, "LB系列录像机"),
+    /**
+     * GB系列录像机
+     */
+    NET_DVR_MEPG4_ST2(9, "GB系列录像机"),
+    /**
+     * HB系列录像机
+     */
+    NET_DVR_MEPG4_SH2(10, "HB系列录像机"),
+    /**
+     * GBE系列录像机
+     */
+    NET_DVR_MPEG4_GBE(11, "GBE系列录像机"),
+    /**
+     * II代网络视频服务器
+     */
+    NET_DVR_MPEG4_NVSII(12, "II代网络视频服务器"),
+    /**
+     * 新标准配置协议
+     */
+    NET_DVR_STD_NEW(13, "新标准配置协议"),
+    /**
+     * DDNS服务器
+     */
+    NET_DVR_DDNS(14, "DDNS服务器"),
+    /**
+     * ATM机
+     */
+    NET_DVR_ATM(15, "ATM机"),
+    /**
+     * 二代非实时NB系列机器
+     */
+    NET_NB_SERIAL(16, "二代非实时NB系列机器"),
+    /**
+     * LN系列产品
+     */
+    NET_LN_SERIAL(17, "LN系列产品"),
+    /**
+     * BAV系列产品
+     */
+    NET_BAV_SERIAL(18, "BAV系列产品"),
+    /**
+     * SDIP系列产品
+     */
+    NET_SDIP_SERIAL(19, "SDIP系列产品"),
+    /**
+     * IPC系列产品
+     */
+    NET_IPC_SERIAL(20, "IPC系列产品"),
+    /**
+     * NVS B系列
+     */
+    NET_NVS_B(21, "NVS B系列"),
+    /**
+     * NVS H系列
+     */
+    NET_NVS_C(22, "NVS H系列"),
+    /**
+     * NVS S系列
+     */
+    NET_NVS_S(23, "NVS S系列"),
+    /**
+     * NVS E系列
+     */
+    NET_NVS_E(24, "NVS E系列"),
+    /**
+     * 从QueryDevState中查询设备类型,以字符串格式
+     */
+    NET_DVR_NEW_PROTOCOL(25, "从QueryDevState中查询设备类型,以字符串格式"),
+    /**
+     * 解码器
+     */
+    NET_NVD_SERIAL(26, "解码器"),
+    /**
+     * N5
+     */
+    NET_DVR_N5(27, "N5"),
+    /**
+     * 混合DVR
+     */
+    NET_DVR_MIX_DVR(28, "混合DVR"),
+    /**
+     * SVR系列
+     */
+    NET_SVR_SERIAL(29, "SVR系列"),
+    /**
+     * SVR-BS
+     */
+    NET_SVR_BS(30, "SVR-BS"),
+    /**
+     * NVR系列
+     */
+    NET_NVR_SERIAL(31, "NVR系列"),
+    /**
+     * N51
+     */
+    NET_DVR_N51(32, "N51"),
+    /**
+     * ITSE 智能分析盒
+     */
+    NET_ITSE_SERIAL(33, "ITSE 智能分析盒"),
+    /**
+     * 智能交通像机设备
+     */
+    NET_ITC_SERIAL(34, "智能交通像机设备"),
+    /**
+     * 雷达测速仪HWS
+     */
+    NET_HWS_SERIAL(35, "雷达测速仪HWS"),
+    /**
+     * 便携式音视频录像机
+     */
+    NET_PVR_SERIAL(36, "便携式音视频录像机"),
+    /**
+     * IVS（智能视频服务器系列）
+     */
+    NET_IVS_SERIAL(37, "IVS（智能视频服务器系列）"),
+    /**
+     * 通用智能视频侦测服务器
+     */
+    NET_IVS_B(38, "通用智能视频侦测服务器"),
+    /**
+     * 目标识别服务器
+     */
+    NET_IVS_F(39, "目标识别服务器"),
+    /**
+     * 视频质量诊断服务器
+     */
+    NET_IVS_V(40, "视频质量诊断服务器"),
+    /**
+     * 矩阵
+     */
+    NET_MATRIX_SERIAL(41, "矩阵"),
+    /**
+     * N52
+     */
+    NET_DVR_N52(42, "N52"),
+    /**
+     * N56
+     */
+    NET_DVR_N56(43, "N56"),
+    /**
+     * ESS
+     */
+    NET_ESS_SERIAL(44, "ESS"),
+    /**
+     * 人数统计服务器
+     */
+    NET_IVS_PC(45, "人数统计服务器"),
+    /**
+     * pc-nvr
+     */
+    NET_PC_NVR(46, "pc-nvr"),
+    /**
+     * 大屏控制器
+     */
+    NET_DSCON(47, "大屏控制器"),
+    /**
+     * 网络视频存储服务器
+     */
+    NET_EVS(48, "网络视频存储服务器"),
+    /**
+     * 嵌入式智能分析视频系统
+     */
+    NET_EIVS(49, "嵌入式智能分析视频系统"),
+    /**
+     * DVR-N6
+     */
+    NET_DVR_N6(50, "DVR-N6"),
+    /**
+     * 万能解码器
+     */
+    NET_UDS(51, "万能解码器"),
+    /**
+     * 银行报警主机
+     */
+    NET_AF6016(52, "银行报警主机"),
+    /**
+     * 视频网络报警主机
+     */
+    NET_AS5008(53, "视频网络报警主机"),
+    /**
+     * 网络报警主机
+     */
+    NET_AH2008(54, "网络报警主机"),
+    /**
+     * 报警主机系列
+     */
+    NET_A_SERIAL(55, "报警主机系列"),
+    /**
+     * 门禁系列产品
+     */
+    NET_BSC_SERIAL(56, "门禁系列产品"),
+    /**
+     * NVS系列产品
+     */
+    NET_NVS_SERIAL(57, "NVS系列产品"),
+    /**
+     * VTO系列产品
+     */
+    NET_VTO_SERIAL(58, "VTO系列产品"),
+    /**
+     * VTNC系列产品
+     */
+    NET_VTNC_SERIAL(59, "VTNC系列产品"),
+    /**
+     * TPC系列产品(热成像设备)
+     */
+    NET_TPC_SERIAL(60, "TPC系列产品(热成像设备)"),
+    /**
+     * 无线中继设备
+     */
+    NET_ASM_SERIAL(61, "无线中继设备"),
+    /**
+     * 管理机
+     */
+    NET_VTS_SERIAL(62, "管理机");
+
+    private int type;
+    private String desc;
+
+    private EMDeviceType(int type, String desc) {
+        this.type = type;
+        this.desc = desc;
+    }
+
+    public int getType() {
+        return type;
+    }
+
+    public void setType(int type) {
+        this.type = type;
+    }
+
+    public String getDesc() {
+        return desc;
+    }
+
+    public void setDesc(String desc) {
+        this.desc = desc;
+    }
+
+    public static EMDeviceType getEMDeviceType(int type) {
+        for (EMDeviceType deviceType : EMDeviceType.values()) {
+            if (deviceType.getType() == type) {
+                return deviceType;
+            }
+        }
+        return null;
+    }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_ABNORMAL_OBJECT_TYPE.java

@@ -0,0 +1,52 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * @author 251823
+ * @description 目标类型
+ * @date 2022/12/19 11:30:59
+ */
+public enum EM_ABNORMAL_OBJECT_TYPE {
+	/**
+	 * 未知
+	 */
+    ABNORMAL_OBJECT_TYPE_UNKNOWN(0, "未知"),
+	/**
+	 * 猪
+	 */
+    ABNORMAL_OBJECT_TYPE_PIG(1, "猪");
+
+	private int value;
+	private String note;
+
+	public String getNote() {
+		return note;
+	}
+
+	public int getValue() {
+		return value;
+	}
+
+	EM_ABNORMAL_OBJECT_TYPE(int givenValue, String note) {
+		this.value = givenValue;
+		this.note = note;
+	}
+
+	public static String getNoteByValue(int givenValue) {
+		for (EM_ABNORMAL_OBJECT_TYPE enumType : EM_ABNORMAL_OBJECT_TYPE.values()) {
+			if (givenValue == enumType.getValue()) {
+				return enumType.getNote();
+			}
+		}
+		return null;
+	}
+
+	public static int getValueByNote(String givenNote) {
+		for (EM_ABNORMAL_OBJECT_TYPE enumType : EM_ABNORMAL_OBJECT_TYPE.values()) {
+			if (givenNote.equals(enumType.getNote())) {
+				return enumType.getValue();
+			}
+		}
+		return -1;
+	}
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_ABSTRACT_STATE.java

@@ -0,0 +1,70 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * @author 260611
+ * @description 计算特征向量结果
+ * @origin autoTool
+ * @date 2023/06/28 14:07:32
+ */
+public enum EM_ABSTRACT_STATE {
+	/**
+     * 未知
+     */
+    EM_ABSTRACT_UNKNOWN(0, "未知"),
+	/**
+     * 重建成功
+     */
+    EM_ABSTRACT_SUCCESS(1, "重建成功"),
+	/**
+     * 重建失败
+     */
+    EM_ABSTRACT_FALSE(2, "重建失败"),
+	/**
+     * 重建过程中(仅针对GroupID)
+     */
+    EM_ABSTRACT_PROCESS(3, "重建过程中(仅针对GroupID)");
+
+	private int value;
+	private String note;
+
+	public String getNote() {
+		return note;
+	}
+
+	public int getValue() {
+		return value;
+	}
+
+	EM_ABSTRACT_STATE(int givenValue, String note) {
+		this.value = givenValue;
+		this.note = note;
+	}
+
+	public static String getNoteByValue(int givenValue) {
+		for (EM_ABSTRACT_STATE enumType : EM_ABSTRACT_STATE.values()) {
+			if (givenValue == enumType.getValue()) {
+				return enumType.getNote();
+			}
+		}
+		return null;
+	}
+
+	public static int getValueByNote(String givenNote) {
+		for (EM_ABSTRACT_STATE enumType : EM_ABSTRACT_STATE.values()) {
+			if (givenNote.equals(enumType.getNote())) {
+				return enumType.getValue();
+			}
+		}
+		return -1;
+	}
+
+	public static EM_ABSTRACT_STATE getEnum(int value) {
+		for (EM_ABSTRACT_STATE e : EM_ABSTRACT_STATE.values()) {
+			if (e.getValue() == value) {
+				return e;
+			}
+		}
+		return EM_ABSTRACT_STATE.EM_ABSTRACT_UNKNOWN;
+	}
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_ACCESSORY_ALARM_TYPE.java

@@ -0,0 +1,81 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+
+/** 
+* @author 291189
+* @description  报警类型 
+* @date 2022/08/31 14:44:15
+*/
+public enum EM_ACCESSORY_ALARM_TYPE {
+/**
+未知
+*/
+    EM_ACCESSORY_ALARM_UNKNOWN(-1, "未知"),
+/**
+入侵
+*/
+    EM_ACCESSORY_ALARM_INTRUSION(0, "入侵"),
+/**
+火警
+*/
+    EM_ACCESSORY_ALARM_FIRE(1, "火警"),
+/**
+医疗
+*/
+    EM_ACCESSORY_ALARM_MEDICAL(2, "医疗"),
+/**
+紧急
+*/
+    EM_ACCESSORY_ALARM_PANIC(3, "紧急"),
+/**
+燃气
+*/
+    EM_ACCESSORY_ALARM_GAS(4, "燃气"),
+/**
+双按钮紧急按钮报警类型
+*/
+    EM_ACCESSORY_ALARM_HOLDUP(5, "双按钮紧急按钮报警类型");
+
+private int value;
+private String note;
+
+public String getNote() {
+        return note;
+    }
+
+public int getValue() {
+        return value;
+    }
+
+EM_ACCESSORY_ALARM_TYPE(int givenValue, String note) {
+        this.value = givenValue;
+        this.note = note;
+    }
+
+public static String getNoteByValue(int givenValue) {
+        for (EM_ACCESSORY_ALARM_TYPE enumType : EM_ACCESSORY_ALARM_TYPE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+public static int getValueByNote(String givenNote) {
+        for (EM_ACCESSORY_ALARM_TYPE enumType : EM_ACCESSORY_ALARM_TYPE.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -2;
+    }
+
+public static EM_ACCESSORY_ALARM_TYPE getEnum(int value) {
+        for (EM_ACCESSORY_ALARM_TYPE e : EM_ACCESSORY_ALARM_TYPE.values()) {
+            if (e.getValue() == value)
+                return e;
+        }
+        return EM_ACCESSORY_ALARM_TYPE.EM_ACCESSORY_ALARM_UNKNOWN;
+    }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_ACCESSORY_INPUT_TYPE.java

@@ -0,0 +1,65 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+
+/** 
+* @author 291189
+* @description  输入类型 
+* @date 2022/08/31 14:44:16
+*/
+public enum EM_ACCESSORY_INPUT_TYPE {
+/**
+未知
+*/
+    EM_ACCESSORY_INPUT_UNKNOWN(-1, "未知"),
+/**
+防拆
+*/
+    EM_ACCESSORY_INPUT_TAMPER(0, "防拆"),
+/**
+报警输入
+*/
+    EM_ACCESSORY_INPUT_SENSOR(1, "报警输入");
+
+private int value;
+private String note;
+
+public String getNote() {
+        return note;
+    }
+
+public int getValue() {
+        return value;
+    }
+
+EM_ACCESSORY_INPUT_TYPE(int givenValue, String note) {
+        this.value = givenValue;
+        this.note = note;
+    }
+
+public static String getNoteByValue(int givenValue) {
+        for (EM_ACCESSORY_INPUT_TYPE enumType : EM_ACCESSORY_INPUT_TYPE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+public static int getValueByNote(String givenNote) {
+        for (EM_ACCESSORY_INPUT_TYPE enumType : EM_ACCESSORY_INPUT_TYPE.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -2;
+    }
+
+public static EM_ACCESSORY_INPUT_TYPE getEnum(int value) {
+        for (EM_ACCESSORY_INPUT_TYPE e : EM_ACCESSORY_INPUT_TYPE.values()) {
+            if (e.getValue() == value)
+                return e;
+        }
+        return EM_ACCESSORY_INPUT_TYPE.EM_ACCESSORY_INPUT_UNKNOWN;
+    }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_ACCESSORY_SENSITIVITY.java

@@ -0,0 +1,69 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+
+/** 
+* @author 291189
+* @description  灵敏度 
+* @date 2022/08/31 14:44:15
+*/
+public enum EM_ACCESSORY_SENSITIVITY {
+/**
+未知
+*/
+    EM_ACCESSORY_SENSITIVITY_UNKNOWN(0, "未知"),
+/**
+低灵敏度
+*/
+    EM_ACCESSORY_SENSITIVITY_LOW(1, "低灵敏度"),
+/**
+中灵敏度
+*/
+    EM_ACCESSORY_SENSITIVITY_MEDIUM(2, "中灵敏度"),
+/**
+高灵敏度
+*/
+    EM_ACCESSORY_SENSITIVITY_HIGH(3, "高灵敏度");
+
+private int value;
+private String note;
+
+public String getNote() {
+        return note;
+    }
+
+public int getValue() {
+        return value;
+    }
+
+EM_ACCESSORY_SENSITIVITY(int givenValue, String note) {
+        this.value = givenValue;
+        this.note = note;
+    }
+
+public static String getNoteByValue(int givenValue) {
+        for (EM_ACCESSORY_SENSITIVITY enumType : EM_ACCESSORY_SENSITIVITY.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+public static int getValueByNote(String givenNote) {
+        for (EM_ACCESSORY_SENSITIVITY enumType : EM_ACCESSORY_SENSITIVITY.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+
+public static EM_ACCESSORY_SENSITIVITY getEnum(int value) {
+        for (EM_ACCESSORY_SENSITIVITY e : EM_ACCESSORY_SENSITIVITY.values()) {
+            if (e.getValue() == value)
+                return e;
+        }
+        return EM_ACCESSORY_SENSITIVITY.EM_ACCESSORY_SENSITIVITY_UNKNOWN;
+    }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_ACCESSORY_VOLUME.java

@@ -0,0 +1,69 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+
+/** 
+* @author 291189
+* @description  设备布撤防时音量 
+* @date 2022/08/31 14:44:16
+*/
+public enum EM_ACCESSORY_VOLUME {
+/**
+未知
+*/
+    EM_ACCESSORY_VOLUME_UNKNOWN(0, "未知"),
+/**
+低音量
+*/
+    EM_ACCESSORY_VOLUME_LOW(1, "低音量"),
+/**
+中音量
+*/
+    EM_ACCESSORY_VOLUME_MEDIUM(2, "中音量"),
+/**
+高音量
+*/
+    EM_ACCESSORY_VOLUME_HIGH(3, "高音量");
+
+private int value;
+private String note;
+
+public String getNote() {
+        return note;
+    }
+
+public int getValue() {
+        return value;
+    }
+
+EM_ACCESSORY_VOLUME(int givenValue, String note) {
+        this.value = givenValue;
+        this.note = note;
+    }
+
+public static String getNoteByValue(int givenValue) {
+        for (EM_ACCESSORY_VOLUME enumType : EM_ACCESSORY_VOLUME.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+public static int getValueByNote(String givenNote) {
+        for (EM_ACCESSORY_VOLUME enumType : EM_ACCESSORY_VOLUME.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+
+public static EM_ACCESSORY_VOLUME getEnum(int value) {
+        for (EM_ACCESSORY_VOLUME e : EM_ACCESSORY_VOLUME.values()) {
+            if (e.getValue() == value)
+                return e;
+        }
+        return EM_ACCESSORY_VOLUME.EM_ACCESSORY_VOLUME_UNKNOWN;
+    }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_ACCESS_SENSOR_TYPE.java

@@ -0,0 +1,50 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * @author 251823
+ * @description 门磁类型
+ * @date 2021/01/11
+ */
+public enum EM_ACCESS_SENSOR_TYPE {
+	// 未知
+    EM_ACCESS_SENSOR_TYPE_UNKNOWN(-1, "未知"),
+	// 常开
+    EM_ACCESS_SENSOR_TYPE_NO(0, "常开"),
+	// 常闭
+    EM_ACCESS_SENSOR_TYPE_NC(1, "常闭");
+
+	private int value;
+	private String note;
+
+	private EM_ACCESS_SENSOR_TYPE(int givenValue, String note) {
+		this.value = givenValue;
+		this.note = note;
+	}
+
+	public String getNote() {
+		return note;
+	}
+
+	public int getValue() {
+		return value;
+	}
+
+	public static String getNoteByValue(int givenValue) {
+		for (EM_ACCESS_SENSOR_TYPE enumType : EM_ACCESS_SENSOR_TYPE.values()) {
+			if (givenValue == enumType.getValue()) {
+				return enumType.getNote();
+			}
+		}
+		return null;
+	}
+
+	public static int getValueByNote(String givenNote) {
+		for (EM_ACCESS_SENSOR_TYPE enumType : EM_ACCESS_SENSOR_TYPE.values()) {
+			if (givenNote.equals(enumType.getNote())) {
+				return enumType.getValue();
+			}
+		}
+		return -2;
+	}
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_ACCOUNT_PROTOCOL.java

@@ -0,0 +1,51 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * 协议类型
+*/
+public enum EM_ACCOUNT_PROTOCOL
+{
+    /**
+     * 通用协议
+    */
+    EM_ACCOUNT_PROTOCOL_NORMAL(0, "通用协议"),
+    /**
+     * TTLV协议
+    */
+    EM_ACCOUNT_PROTOCOL_TTLV(1, "TTLV协议");
+
+    private int value;
+    private String note;
+
+    public String getNote() {
+        return note;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    EM_ACCOUNT_PROTOCOL(int givenValue, String note) {
+        this.value = givenValue;
+        this.note = note;
+    }
+
+    public static String getNoteByValue(int givenValue) {
+        for (EM_ACCOUNT_PROTOCOL enumType : EM_ACCOUNT_PROTOCOL.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+    public static int getValueByNote(String givenNote) {
+        for (EM_ACCOUNT_PROTOCOL enumType : EM_ACCOUNT_PROTOCOL.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_ACROSS_PARKING.java

@@ -0,0 +1,65 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * 是否跨位
+ *
+ * @author 47040
+ * @since Created in 2020/11/18 14:40
+ */
+public enum EM_ACROSS_PARKING {
+    /**
+     * 未知
+     */
+    EM_ACROSS_PARKING_UNKNOWN(0, "未知"),
+    /**
+     * 未跨位
+     */
+    EM_ACROSS_PARKING_NO(1, "未跨位"),
+    /**
+     * 跨位
+     */
+    EM_ACROSS_PARKING_YES(2, "跨位");
+
+    private int value;
+    private String note;
+
+    EM_ACROSS_PARKING(int givenValue, String note) {
+        this.value = givenValue;
+        this.note = note;
+    }
+
+    public String getNote() {
+        return note;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    public static String getNoteByValue(int givenValue) {
+        for (EM_ACROSS_PARKING enumType : EM_ACROSS_PARKING.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+    public static int getValueByNote(String givenNote) {
+        for (EM_ACROSS_PARKING enumType : EM_ACROSS_PARKING.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+
+    public static EM_ACROSS_PARKING getEnum(int value) {
+        for (EM_ACROSS_PARKING e : EM_ACROSS_PARKING.values()) {
+            if (e.getValue() == value)
+                return e;
+        }
+        return EM_ACROSS_PARKING.EM_ACROSS_PARKING_UNKNOWN;
+    }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_ACTION.java

@@ -0,0 +1,80 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * @author 251823
+ * @description 物体动作支持类型
+ * @date 2022/06/16 11:14:19
+ */
+public enum EM_ACTION {
+	/**
+	 * 未知类型
+	 */
+    EM_ACTION_UNKNOWN(0, "未知类型"),
+	/**
+	 * 第一次出现在检测区域中，或者跟踪时物理分离动作中尚未确认的新物体
+	 */
+    EM_ACTION_APPEAR(1, "第一次出现在检测区域中，或者跟踪时物理分离动作中尚未确认的新物体"),
+	/**
+	 * 正在运动，物体被正常跟踪
+	 */
+    EM_ACTION_MOVE(2, "正在运动，物体被正常跟踪"),
+	/**
+	 * 物体停止运动，这个物体不会在出现在下一帧物体列表中，物体开始移动后再恢复在列表中
+	 */
+    EM_ACTION_STAY(3, "物体停止运动，这个物体不会在出现在下一帧物体列表中，物体开始移动后再恢复在列表中"),
+	/**
+	 * 物体从原来的区域移除，或者被遮盖，或者跟踪失败，移除的物体ID不会被自动删除，并且物体重现出现是有可能再次被使用
+	 */
+    EM_ACTION_REMOVE(4, "物体从原来的区域移除，或者被遮盖，或者跟踪失败，移除的物体ID不会被自动删除，并且物体重现出现是有可能再次被使用"),
+	/**
+	 * 运动到跟踪区域之外，或者达到了算法跟踪物体的上限而被清除，消失的物体ID将不再出现
+	 */
+    EM_ACTION_DISAPPEAR(5, "运动到跟踪区域之外，或者达到了算法跟踪物体的上限而被清除，消失的物体ID将不再出现"),
+	/**
+	 * 从其他物体中分离出来，可以用来检测物体遗留，关联ID表示从这个ID对应物体分离
+	 */
+    EM_ACTION_SPLIT(6, "从其他物体中分离出来，可以用来检测物体遗留，关联ID表示从这个ID对应物体分离"),
+	/**
+	 * 合并到其他物体，可以用来检查物体保全，关联ID表示合并到这个ID对相应的物体
+	 */
+    EM_ACTION_MERGE(7, "合并到其他物体，可以用来检查物体保全，关联ID表示合并到这个ID对相应的物体"),
+	/**
+	 * 如果算法无法确定分离动作中某个物体是原先同一个物体，应该创建先一个新的物体，证据充分后再重命名为旧的物体ID，关联ID表示暂时使用的新的ID。
+	 */
+    EM_ACTION_RENAME(8, "如果算法无法确定分离动作中某个物体是原先同一个物体，应该创建先一个新的物体，证据充分后再重命名为旧的物体ID，关联ID表示暂时使用的新的ID。");
+
+	private int value;
+	private String note;
+
+	public String getNote() {
+		return note;
+	}
+
+	public int getValue() {
+		return value;
+	}
+
+	EM_ACTION(int givenValue, String note) {
+		this.value = givenValue;
+		this.note = note;
+	}
+
+	public static String getNoteByValue(int givenValue) {
+		for (EM_ACTION enumType : EM_ACTION.values()) {
+			if (givenValue == enumType.getValue()) {
+				return enumType.getNote();
+			}
+		}
+		return null;
+	}
+
+	public static int getValueByNote(String givenNote) {
+		for (EM_ACTION enumType : EM_ACTION.values()) {
+			if (givenNote.equals(enumType.getNote())) {
+				return enumType.getValue();
+			}
+		}
+		return -1;
+	}
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_AC_UNLOCK_MODE.java

@@ -0,0 +1,238 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+
+/** 
+* @author 291189
+* @description  开锁模式 
+* @origin autoTool
+* @date 2023/02/10 14:34:21
+*/
+public enum EM_AC_UNLOCK_MODE {
+/**
+未知
+*/
+    EM_AC_UNLOCK_MODE_UNKNOWN(0, "未知"),
+/**
+只允许密码开锁
+*/
+    EM_AC_UNLOCK_MODE_PWD_ONLY(1, "只允许密码开锁"),
+/**
+只允许刷卡开锁
+*/
+    EM_AC_UNLOCK_MODE_CARD(2, "只允许刷卡开锁"),
+/**
+密码或刷卡开锁
+*/
+    EM_AC_UNLOCK_MODE_PWD_OR_CARD(3, "密码或刷卡开锁"),
+/**
+先刷卡后密码开锁
+*/
+    EM_AC_UNLOCK_MODE_CARD_FIRST(4, "先刷卡后密码开锁"),
+/**
+先密码后刷卡开锁
+*/
+    EM_AC_UNLOCK_MODE_PWD_FIRST(5, "先密码后刷卡开锁"),
+/**
+分时段开门
+*/
+    EM_AC_UNLOCK_MODE_SECTION(6, "分时段开门"),
+/**
+仅信息开锁
+*/
+    EM_AC_UNLOCK_MODE_FINGERPRINTONLY(7, "仅信息开锁"),
+/**
+密码或刷卡或信息开锁
+*/
+    EM_AC_UNLOCK_MODE_PWD_OR_CARD_OR_FINGERPRINT(8, "密码或刷卡或信息开锁"),
+/**
+密码+刷卡+信息组合开锁
+*/
+    EM_AC_UNLOCK_MODE_PWD_AND_CARD_AND_FINGERPINT(9, "密码+刷卡+信息组合开锁"),
+/**
+密码+信息组合开锁
+*/
+    EM_AC_UNLOCK_MODE_PWD_AND_FINGERPRINT(10, "密码+信息组合开锁"),
+/**
+刷卡+信息开锁
+*/
+    EM_AC_UNLOCK_MODE_CARD_AND_FINGERPRINT(11, "刷卡+信息开锁"),
+/**
+多人开锁
+*/
+    EM_AC_UNLOCK_MODE_MULTI_PERSON(12, "多人开锁"),
+/**
+人证对比
+*/
+    EM_AC_UNLOCK_MODE_FACEIDCARD(13, "人证对比"),
+/**
+证件+ 人证比对
+*/
+    EM_AC_UNLOCK_MODE_FACEIDCARD_AND_IDCARD(14, "证件+ 人证比对"),
+/**
+人证比对或刷卡或信息
+*/
+    EM_AC_UNLOCK_MODE_FACEIDCARD_OR_CARD_OR_FINGER(15, "人证比对或刷卡或信息"),
+/**
+(证件+认证比对)或刷卡或信息
+*/
+    EM_AC_UNLOCK_MODE_FACEIPCARDANDIDCARD_OR_CARD_OR_FINGER(16, "(证件+认证比对)或刷卡或信息"),
+/**
+UserID+密码
+*/
+    EM_AC_UNLOCK_MODE_USERID_AND_PWD(17, "UserID+密码"),
+/**
+只允许目标开锁
+*/
+    EM_AC_UNLOCK_MODE_FACE_ONLY(18, "只允许目标开锁"),
+/**
+目标+密码开锁
+*/
+    EM_AC_UNLOCK_MODE_FACE_AND_PWD(19, "目标+密码开锁"),
+/**
+信息+密码开锁
+*/
+    EM_AC_UNLOCK_MODE_FINGERPRINT_AND_PWD(20, "信息+密码开锁"),
+/**
+信息+目标开锁
+*/
+    EM_AC_UNLOCK_MODE_FINGERPRINT_AND_FACE(21, "信息+目标开锁"),
+/**
+刷卡+目标开锁
+*/
+    EM_AC_UNLOCK_MODE_CARD_AND_FACE(22, "刷卡+目标开锁"),
+/**
+目标或密码开锁
+*/
+    EM_AC_UNLOCK_MODE_FACE_OR_PWD(23, "目标或密码开锁"),
+/**
+信息或密码开锁
+*/
+    EM_AC_UNLOCK_MODE_FINGERPRINT_OR_PWD(24, "信息或密码开锁"),
+/**
+信息或目标开锁
+*/
+    EM_AC_UNLOCK_MODE_FINGERPRINT_OR_FACE(25, "信息或目标开锁"),
+/**
+刷卡或目标开锁
+*/
+    EM_AC_UNLOCK_MODE_CARD_OR_FACE(26, "刷卡或目标开锁"),
+/**
+刷卡或信息开锁
+*/
+    EM_AC_UNLOCK_MODE_CARD_OR_FINGERPRINT(27, "刷卡或信息开锁"),
+/**
+信息+目标+密码开锁
+*/
+    EM_AC_UNLOCK_MODE_FINGERPRINT_AND_FACE_AND_PWD(28, "信息+目标+密码开锁"),
+/**
+刷卡+目标+密码开锁
+*/
+    EM_AC_UNLOCK_MODE_CARD_AND_FACE_AND_PWD(29, "刷卡+目标+密码开锁"),
+/**
+刷卡+信息+密码开锁
+*/
+    EM_AC_UNLOCK_MODE_CARD_AND_FINGERPRINT_AND_PWD(30, "刷卡+信息+密码开锁"),
+/**
+卡+信息+目标组合开锁
+*/
+    EM_AC_UNLOCK_MODE_CARD_AND_FINGERPRINT_AND_FACE(31, "卡+信息+目标组合开锁"),
+/**
+信息或目标或密码
+*/
+    EM_AC_UNLOCK_MODE_FINGERPRINT_OR_FACE_OR_PWD(32, "信息或目标或密码"),
+/**
+卡或目标或密码开锁
+*/
+    EM_AC_UNLOCK_MODE_CARD_OR_FACE_OR_PWD(33, "卡或目标或密码开锁"),
+/**
+卡或信息或目标开锁
+*/
+    EM_AC_UNLOCK_MODE_CARD_OR_FINGERPRINT_OR_FACE(34, "卡或信息或目标开锁"),
+/**
+卡+信息+目标+密码组合开锁
+*/
+    EM_AC_UNLOCK_MODE_CARD_AND_FINGERPRINT_AND_FACE_AND_PWD(35, "卡+信息+目标+密码组合开锁"),
+/**
+卡或信息或目标或密码开锁
+*/
+    EM_AC_UNLOCK_MODE_CARD_OR_FINGERPRINT_OR_FACE_OR_PWD(36, "卡或信息或目标或密码开锁"),
+/**
+(证件+人证比对)或 刷卡 或 目标
+*/
+    EM_AC_UNLOCK_MODE_FACEIPCARDANDIDCARD_OR_CARD_OR_FACE(37, "(证件+人证比对)或 刷卡 或 目标"),
+/**
+人证比对 或 刷卡(二维码) 或 目标
+*/
+    EM_AC_UNLOCK_MODE_FACEIDCARD_OR_CARD_OR_FACE(38, "人证比对 或 刷卡(二维码) 或 目标"),
+/**
+(卡+密码）或（信息+密码）默认为2
+*/
+    EM_AC_UNLOCK_MODE_CARDANDPWD_OR_FINGERPRINTANDPWD(39, "(卡+密码）或（信息+密码）默认为2"),
+/**
+人证(照片)或目标
+*/
+    EM_AC_UNLOCK_MODE_PHOTO_OR_FACE(40, "人证(照片)或目标"),
+/**
+人证(信息)
+*/
+    EM_AC_UNLOCK_MODE_FINGERPRINT(41, "人证(信息)"),
+/**
+人证(照片+信息)
+*/
+    EM_AC_UNLOCK_MODE_PHOTO_AND_FINGERPRINT(42, "人证(照片+信息)"),
+/**
+人证或刷卡或信息或目标或密码
+*/
+    EM_AC_UNLOCK_MODE_FACEIDCARD_OR_CARD_OR_FINGERPRINT_OR_FACE_OR_PASSWORD(43, "人证或刷卡或信息或目标或密码"),
+/**
+多用户类型
+*/
+    EM_AC_UNLOCK_MODE_MULTI_USER_TYPE(44, "多用户类型"),
+/**
+人证或健康码
+*/
+    EM_AC_UNLOCK_MODE_FACEIDCARD_OR_HEALTHCODE(45, "人证或健康码");
+
+private int value;
+private String note;
+
+public String getNote() {
+        return note;
+    }
+
+public int getValue() {
+        return value;
+    }
+
+EM_AC_UNLOCK_MODE(int givenValue, String note) {
+        this.value = givenValue;
+        this.note = note;
+    }
+
+public static String getNoteByValue(int givenValue) {
+        for (EM_AC_UNLOCK_MODE enumType : EM_AC_UNLOCK_MODE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+public static int getValueByNote(String givenNote) {
+        for (EM_AC_UNLOCK_MODE enumType : EM_AC_UNLOCK_MODE.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+
+public static EM_AC_UNLOCK_MODE getEnum(int value) {
+        for (EM_AC_UNLOCK_MODE e : EM_AC_UNLOCK_MODE.values()) {
+            if (e.getValue() == value)
+                return e;
+        }
+        return EM_AC_UNLOCK_MODE.EM_AC_UNLOCK_MODE_UNKNOWN;
+    }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_AGE_GROUP_TYPE.java

@@ -0,0 +1,9 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+public enum EM_AGE_GROUP_TYPE {
+    EM_AGE_GROUP_UNKNOWN,   // 未知
+    EM_AGE_GROUP_OLD,       // 老人
+    EM_AGE_GROUP_ADULT,     // 成年人
+    EM_AGE_GROUP_CHILD;     // 小孩
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_AGE_SEG.java

@@ -0,0 +1,67 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * 年龄段
+*/
+public enum EM_AGE_SEG
+{
+    /**
+     * 未知
+    */
+    EM_AGE_SEG_UNKOWN(0, "未知"),
+    /**
+     * 婴儿
+    */
+    EM_AGE_SEG_BABY(2, "婴儿"),
+    /**
+     * 幼儿
+    */
+    EM_AGE_SEG_CHILD(10, "幼儿"),
+    /**
+     * 青年
+    */
+    EM_AGE_SEG_YOUTH(28, "青年"),
+    /**
+     * 中年
+    */
+    EM_AGE_SEG_MIDDLE(50, "中年"),
+    /**
+     * 老年
+    */
+    EM_AGE_SEG_OLD(60, "老年");
+
+    private int value;
+    private String note;
+
+    public String getNote() {
+        return note;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    EM_AGE_SEG(int givenValue, String note) {
+        this.value = givenValue;
+        this.note = note;
+    }
+
+    public static String getNoteByValue(int givenValue) {
+        for (EM_AGE_SEG enumType : EM_AGE_SEG.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+    public static int getValueByNote(String givenNote) {
+        for (EM_AGE_SEG enumType : EM_AGE_SEG.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_AIRBORNE_TYPE.java

@@ -0,0 +1,69 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+
+/** 
+* @author 291189
+* @description  挂空悬浮物具体类型 
+* @date 2022/06/28 19:44:54
+*/
+public enum EM_AIRBORNE_TYPE {
+/**
+未知
+*/
+    EM_AIRBORNE_TYPE_UNKNOWN(0, "未知"),
+/**
+塑料袋
+*/
+    EM_AIRBORNE_TYPE_PLASTICBAG(1, "塑料袋"),
+/**
+织物
+*/
+    EM_AIRBORNE_TYPE_TEXTILE(2, "织物"),
+/**
+风筝
+*/
+    EM_AIRBORNE_TYPE_KITE(3, "风筝");
+
+private int value;
+private String note;
+
+public String getNote() {
+        return note;
+    }
+
+public int getValue() {
+        return value;
+    }
+
+EM_AIRBORNE_TYPE(int givenValue, String note) {
+        this.value = givenValue;
+        this.note = note;
+    }
+
+public static String getNoteByValue(int givenValue) {
+        for (EM_AIRBORNE_TYPE enumType : EM_AIRBORNE_TYPE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+public static int getValueByNote(String givenNote) {
+        for (EM_AIRBORNE_TYPE enumType : EM_AIRBORNE_TYPE.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+
+public static EM_AIRBORNE_TYPE getEnum(int value) {
+        for (EM_AIRBORNE_TYPE e : EM_AIRBORNE_TYPE.values()) {
+            if (e.getValue() == value)
+                return e;
+        }
+        return EM_AIRBORNE_TYPE.EM_AIRBORNE_TYPE_UNKNOWN;
+    }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_ALARMOUT_POLE.java

@@ -0,0 +1,26 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * @author 47081
+ * @version 1.0
+ * @description 输出有效模式
+ * @date 2021/2/22
+ */
+public enum EM_ALARMOUT_POLE {
+  /** 未知 */
+    EM_ALARMOUT_POLE_UNKNOWN,
+  /** 低电平有效 */
+    EM_ALARMOUT_POLE_LOW,
+  /** 高电平有效 */
+    EM_ALARMOUT_POLE_HIGH;
+
+  public static EM_ALARMOUT_POLE getAlarmOutPole(int pole) {
+    for (EM_ALARMOUT_POLE alarmOutPole : EM_ALARMOUT_POLE.values()) {
+      if (alarmOutPole.ordinal() == pole) {
+        return alarmOutPole;
+      }
+    }
+    return EM_ALARMOUT_POLE_UNKNOWN;
+  }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_ALARM_ONECLICKARMING_FUNCTION.java

@@ -0,0 +1,60 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * @author 251823
+ * @description 功能
+ * @date 2023/03/16 09:04:49
+ */
+public enum EM_ALARM_ONECLICKARMING_FUNCTION {
+	/**
+	 * 未知
+	 */
+    EM_ALARM_ONECLICKARMING_FUNCTION_UNKNOWN(0, "未知"),
+	/**
+	 * 开关
+	 */
+    EM_ALARM_ONECLICKARMING_FUNCTION_ONOFF(1, "开关"),
+	/**
+	 * 只开
+	 */
+    EM_ALARM_ONECLICKARMING_FUNCTION_ONONLY(2, "只开"),
+	/**
+	 * 只关
+	 */
+    EM_ALARM_ONECLICKARMING_FUNCTION_OFFONLY(3, "只关");
+
+	private int value;
+	private String note;
+
+	public String getNote() {
+		return note;
+	}
+
+	public int getValue() {
+		return value;
+	}
+
+	EM_ALARM_ONECLICKARMING_FUNCTION(int givenValue, String note) {
+		this.value = givenValue;
+		this.note = note;
+	}
+
+	public static String getNoteByValue(int givenValue) {
+		for (EM_ALARM_ONECLICKARMING_FUNCTION enumType : EM_ALARM_ONECLICKARMING_FUNCTION.values()) {
+			if (givenValue == enumType.getValue()) {
+				return enumType.getNote();
+			}
+		}
+		return null;
+	}
+
+	public static int getValueByNote(String givenNote) {
+		for (EM_ALARM_ONECLICKARMING_FUNCTION enumType : EM_ALARM_ONECLICKARMING_FUNCTION.values()) {
+			if (givenNote.equals(enumType.getNote())) {
+				return enumType.getValue();
+			}
+		}
+		return -1;
+	}
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_ALARM_ONECLICKARMING_TRIGGEROPTION.java

@@ -0,0 +1,56 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * @author 251823
+ * @description 触发类型
+ * @date 2023/03/16 09:04:49
+ */
+public enum EM_ALARM_ONECLICKARMING_TRIGGEROPTION {
+	/**
+	 * 未知
+	 */
+    EM_ALARM_ONECLICKARMING_TRIGGEROPTION_UNKNOWN(0, "未知"),
+	/**
+	 * 脉冲
+	 */
+    EM_ALARM_ONECLICKARMING_TRIGGEROPTION_IMPULSE(1, "脉冲"),
+	/**
+	 * 双稳定
+	 */
+    EM_ALARM_ONECLICKARMING_TRIGGEROPTION_BISTABLE(2, "双稳定");
+
+	private int value;
+	private String note;
+
+	public String getNote() {
+		return note;
+	}
+
+	public int getValue() {
+		return value;
+	}
+
+	EM_ALARM_ONECLICKARMING_TRIGGEROPTION(int givenValue, String note) {
+		this.value = givenValue;
+		this.note = note;
+	}
+
+	public static String getNoteByValue(int givenValue) {
+		for (EM_ALARM_ONECLICKARMING_TRIGGEROPTION enumType : EM_ALARM_ONECLICKARMING_TRIGGEROPTION.values()) {
+			if (givenValue == enumType.getValue()) {
+				return enumType.getNote();
+			}
+		}
+		return null;
+	}
+
+	public static int getValueByNote(String givenNote) {
+		for (EM_ALARM_ONECLICKARMING_TRIGGEROPTION enumType : EM_ALARM_ONECLICKARMING_TRIGGEROPTION.values()) {
+			if (givenNote.equals(enumType.getNote())) {
+				return enumType.getValue();
+			}
+		}
+		return -1;
+	}
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_ALARM_RULE_TYPE.java

@@ -0,0 +1,59 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * 比对报警规则
+*/
+public enum EM_ALARM_RULE_TYPE
+{
+    /**
+     * 未知
+    */
+    EM_ALARM_RULE_UNKNOWN(-1, "未知"),
+    /**
+     * 不报警
+    */
+    EM_ALARM_RULE_NONE(0, "不报警"),
+    /**
+     * 比对成功报警
+    */
+    EM_ALARM_RULE_SUCCESS(1, "比对成功报警"),
+    /**
+     * 比对失败报警
+    */
+    EM_ALARM_RULE_FAIL(2, "比对失败报警");
+
+    private int value;
+    private String note;
+
+    public String getNote() {
+        return note;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    EM_ALARM_RULE_TYPE(int givenValue, String note) {
+        this.value = givenValue;
+        this.note = note;
+    }
+
+    public static String getNoteByValue(int givenValue) {
+        for (EM_ALARM_RULE_TYPE enumType : EM_ALARM_RULE_TYPE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+    public static int getValueByNote(String givenNote) {
+        for (EM_ALARM_RULE_TYPE enumType : EM_ALARM_RULE_TYPE.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_ALARM_TRANSMIT_ALARM_TYPE.java

@@ -0,0 +1,79 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * 报警类型
+*/
+public enum EM_ALARM_TRANSMIT_ALARM_TYPE
+{
+    /**
+     * 未知
+    */
+    EM_ALARM_TRANSMIT_ALARM_TYPE_UNKNOWN(0, "未知"),
+    /**
+     * "PreventRemove"   防拆
+    */
+    EM_ALARM_TRANSMIT_ALARM_TYPE_PREVENTREMOVE(1, "\"PreventRemove\"   防拆"),
+    /**
+     * "LowerPower"  低电压
+    */
+    EM_ALARM_TRANSMIT_ALARM_TYPE_LOWERPOWER(2, "\"LowerPower\"  低电压"),
+    /**
+     * "Key"          钥匙
+    */
+    EM_ALARM_TRANSMIT_ALARM_TYPE_KEY(3, "\"Key\"          钥匙"),
+    /**
+     * "Duress"       胁迫
+    */
+    EM_ALARM_TRANSMIT_ALARM_TYPE_DURESS(4, "\"Duress\"       胁迫"),
+    /**
+     * "BatteryLost"  电池不在位
+    */
+    EM_ALARM_TRANSMIT_ALARM_TYPE_BATTERYLOST(5, "\"BatteryLost\"  电池不在位"),
+    /**
+     * "PSTNBreakLine"电话线断开
+    */
+    EM_ALARM_TRANSMIT_ALARM_TYPE_PSTN_BREAKLINE(6, "\"PSTNBreakLine\"电话线断开"),
+    /**
+     * "EmergencyHelp"紧急求助
+    */
+    EM_ALARM_TRANSMIT_ALARM_TYPE_EMERGENCY_HELP(7, "\"EmergencyHelp\"紧急求助"),
+    /**
+     * "AlarmIn"      报警输入
+    */
+    EM_ALARM_TRANSMIT_ALARM_TYPE_ALARMIN(8, "\"AlarmIn\"      报警输入");
+
+    private int value;
+    private String note;
+
+    public String getNote() {
+        return note;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    EM_ALARM_TRANSMIT_ALARM_TYPE(int givenValue, String note) {
+        this.value = givenValue;
+        this.note = note;
+    }
+
+    public static String getNoteByValue(int givenValue) {
+        for (EM_ALARM_TRANSMIT_ALARM_TYPE enumType : EM_ALARM_TRANSMIT_ALARM_TYPE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+    public static int getValueByNote(String givenNote) {
+        for (EM_ALARM_TRANSMIT_ALARM_TYPE enumType : EM_ALARM_TRANSMIT_ALARM_TYPE.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_ALARM_TRANSMIT_DEV_SRC_TYPE.java

@@ -0,0 +1,59 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * 报警源设备的类型
+*/
+public enum EM_ALARM_TRANSMIT_DEV_SRC_TYPE
+{
+    /**
+     * 未知
+    */
+    EM_ALARM_TRANSMIT_DEV_SRC_TYPE_UNKNOWN(0, "未知"),
+    /**
+     * Digit   数字
+    */
+    EM_ALARM_TRANSMIT_DEV_SRC_TYPE_DIGIT(1, "Digit   数字"),
+    /**
+     * Analog 模拟
+    */
+    EM_ALARM_TRANSMIT_DEV_SRC_TYPE_ANALOG(2, "Analog 模拟"),
+    /**
+     * SmartLock 智能锁
+    */
+    EM_ALARM_TRANSMIT_DEV_SRC_TYPE_SMARTLOCK(3, "SmartLock 智能锁");
+
+    private int value;
+    private String note;
+
+    public String getNote() {
+        return note;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    EM_ALARM_TRANSMIT_DEV_SRC_TYPE(int givenValue, String note) {
+        this.value = givenValue;
+        this.note = note;
+    }
+
+    public static String getNoteByValue(int givenValue) {
+        for (EM_ALARM_TRANSMIT_DEV_SRC_TYPE enumType : EM_ALARM_TRANSMIT_DEV_SRC_TYPE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+    public static int getValueByNote(String givenNote) {
+        for (EM_ALARM_TRANSMIT_DEV_SRC_TYPE enumType : EM_ALARM_TRANSMIT_DEV_SRC_TYPE.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_ALARM_USERAUTHORITY.java

@@ -0,0 +1,92 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * @author 251823
+ * @description 用户的权限列表
+ * @date 2023/03/16 09:04:48
+ */
+public enum EM_ALARM_USERAUTHORITY {
+	/**
+	 * 未知
+	 */
+    EM_ALARM_USERAUTHORITY_UNKNOWN(0, "未知"),
+	/**
+	 * 布防
+	 */
+    EM_ALARM_USERAUTHORITY_ARMING(1, "布防"),
+	/**
+	 * 强制布防
+	 */
+    EM_ALARM_USERAUTHORITY_FORCEARMING(2, "强制布防"),
+	/**
+	 * 撤防
+	 */
+    EM_ALARM_USERAUTHORITY_DISARM(3, "撤防"),
+	/**
+	 * 旁路
+	 */
+    EM_ALARM_USERAUTHORITY_BYPASS(4, "旁路"),
+	/**
+	 * 永久旁路
+	 */
+    EM_ALARM_USERAUTHORITY_PERMANENTBYPASS(5, "永久旁路"),
+	/**
+	 * 消警
+	 */
+    EM_ALARM_USERAUTHORITY_ALARMCONFIRM(6, "消警"),
+	/**
+	 * 查询日志
+	 */
+    EM_ALARM_USERAUTHORITY_QUERYLOG(7, "查询日志"),
+	/**
+	 * 调试模式
+	 */
+    EM_ALARM_USERAUTHORITY_DEBUGMODE(8, "调试模式"),
+	/**
+	 * 更改基本程序，如：升级程序
+	 */
+    EM_ALARM_USERAUTHORITY_UPGRADE(9, "更改基本程序，如：升级程序"),
+	/**
+	 * 添加/更改配置参数
+	 */
+    EM_ALARM_USERAUTHORITY_SYSTEMCONFIG(10, "添加/更改配置参数"),
+	/**
+	 * 用户管理
+	 */
+    EM_ALARM_USERAUTHORITY_USERMANAGEMENT(11, "用户管理");
+
+	private int value;
+	private String note;
+
+	public String getNote() {
+		return note;
+	}
+
+	public int getValue() {
+		return value;
+	}
+
+	EM_ALARM_USERAUTHORITY(int givenValue, String note) {
+		this.value = givenValue;
+		this.note = note;
+	}
+
+	public static String getNoteByValue(int givenValue) {
+		for (EM_ALARM_USERAUTHORITY enumType : EM_ALARM_USERAUTHORITY.values()) {
+			if (givenValue == enumType.getValue()) {
+				return enumType.getNote();
+			}
+		}
+		return null;
+	}
+
+	public static int getValueByNote(String givenNote) {
+		for (EM_ALARM_USERAUTHORITY enumType : EM_ALARM_USERAUTHORITY.values()) {
+			if (givenNote.equals(enumType.getNote())) {
+				return enumType.getValue();
+			}
+		}
+		return -1;
+	}
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_ALARM_USER_GROUP.java

@@ -0,0 +1,64 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * @author 251823
+ * @description 用户所在组
+ * @date 2023/03/16 09:04:49
+ */
+public enum EM_ALARM_USER_GROUP {
+	/**
+	 * 未知
+	 */
+    EM_ALARM_USER_GROUP_UNKNOWN(0, "未知"),
+	/**
+	 * 管理员
+	 */
+    EM_ALARM_USER_GROUP_ADMIN(1, "管理员"),
+	/**
+	 * 安装员
+	 */
+    EM_ALARM_USER_GROUP_INSTALLER(2, "安装员"),
+	/**
+	 * 制造商
+	 */
+    EM_ALARM_USER_GROUP_MANUFACTURER(3, "制造商"),
+	/**
+	 * 操作员
+	 */
+    EM_ALARM_USER_GROUP_OPERATOR(4, "操作员");
+
+	private int value;
+	private String note;
+
+	public String getNote() {
+		return note;
+	}
+
+	public int getValue() {
+		return value;
+	}
+
+	EM_ALARM_USER_GROUP(int givenValue, String note) {
+		this.value = givenValue;
+		this.note = note;
+	}
+
+	public static String getNoteByValue(int givenValue) {
+		for (EM_ALARM_USER_GROUP enumType : EM_ALARM_USER_GROUP.values()) {
+			if (givenValue == enumType.getValue()) {
+				return enumType.getNote();
+			}
+		}
+		return null;
+	}
+
+	public static int getValueByNote(String givenNote) {
+		for (EM_ALARM_USER_GROUP enumType : EM_ALARM_USER_GROUP.values()) {
+			if (givenNote.equals(enumType.getNote())) {
+				return enumType.getValue();
+			}
+		}
+		return -1;
+	}
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_ALGORITHM_PARTITION_TYPE.java

@@ -0,0 +1,28 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * @author 47081
+ * @version 1.0
+ * @description 分区类型
+ * @date 2021/2/20
+ */
+public enum EM_ALGORITHM_PARTITION_TYPE {
+  /** 未知 */
+    EM_ALGORITHM_PARTITION_UNKNOWN,
+  /** ext4分区 */
+    EM_ALGORITHM_PARTITION_EXT4,
+  /** suqshfs分区 */
+    EM_ALGORITHM_PARTITION_SUQSHFS,
+  /** ubifs分区 */
+    EM_ALGORITHM_PARTITION_UBIFS;
+
+  public static EM_ALGORITHM_PARTITION_TYPE getAlgorithmPartitionType(int type) {
+    for (EM_ALGORITHM_PARTITION_TYPE partitionType : EM_ALGORITHM_PARTITION_TYPE.values()) {
+      if (partitionType.ordinal() == type) {
+        return partitionType;
+      }
+    }
+    return EM_ALGORITHM_PARTITION_UNKNOWN;
+  }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_ALGORITHM_TYPE.java

@@ -0,0 +1,56 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * @author 251823
+ * @description 加密算法类型
+ * @date 2022/11/03 09:43:17
+ */
+public enum EM_ALGORITHM_TYPE {
+	/**
+	 * 未知加密算法
+	 */
+    EM_ALGORITHM_TYPE_UNKNOWN(0, "未知加密算法"),
+	/**
+	 * AES256-OFB加密算法
+	 */
+    EM_ALGORITHM_TYPE_AES256_OFB(1, "AES256-OFB加密算法"),
+	/**
+	 * SM加密算法
+	 */
+    EM_ALGORITHM_TYPE_SM4_OFB(2, "SM加密算法");
+
+	private int value;
+	private String note;
+
+	public String getNote() {
+		return note;
+	}
+
+	public int getValue() {
+		return value;
+	}
+
+	EM_ALGORITHM_TYPE(int givenValue, String note) {
+		this.value = givenValue;
+		this.note = note;
+	}
+
+	public static String getNoteByValue(int givenValue) {
+		for (EM_ALGORITHM_TYPE enumType : EM_ALGORITHM_TYPE.values()) {
+			if (givenValue == enumType.getValue()) {
+				return enumType.getNote();
+			}
+		}
+		return null;
+	}
+
+	public static int getValueByNote(String givenNote) {
+		for (EM_ALGORITHM_TYPE enumType : EM_ALGORITHM_TYPE.values()) {
+			if (givenNote.equals(enumType.getNote())) {
+				return enumType.getValue();
+			}
+		}
+		return -1;
+	}
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_ALLOW_PERMIT_FLAG.java

@@ -0,0 +1,69 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+
+/** 
+* @author 291189
+* @description 电子通行证状态（添加）
+* @date 2022/03/08 11:25:17
+*/
+public enum EM_ALLOW_PERMIT_FLAG {
+/**
+未知
+*/
+    EM_ALLOW_PERMIT_FLAG_UNKNOWN(0, "未知"),
+/**
+没有电子通行证
+*/
+    EM_ALLOW_PERMIT_FLAG_NO(1, "没有电子通行证"),
+/**
+电子通行证有效
+*/
+    EM_ALLOW_PERMIT_FLAG_EFFECTIVE(2, "电子通行证有效"),
+/**
+电子通行证无效
+*/
+    EM_ALLOW_PERMIT_FLAG_INVALID(3, "电子通行证无效");
+
+private int value;
+private String note;
+
+public String getNote() {
+        return note;
+    }
+
+public int getValue() {
+        return value;
+    }
+
+EM_ALLOW_PERMIT_FLAG(int givenValue, String note) {
+        this.value = givenValue;
+        this.note = note;
+    }
+
+public static String getNoteByValue(int givenValue) {
+        for (EM_ALLOW_PERMIT_FLAG enumType : EM_ALLOW_PERMIT_FLAG.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+public static int getValueByNote(String givenNote) {
+        for (EM_ALLOW_PERMIT_FLAG enumType : EM_ALLOW_PERMIT_FLAG.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+
+public static EM_ALLOW_PERMIT_FLAG getEnum(int value) {
+        for (EM_ALLOW_PERMIT_FLAG e : EM_ALLOW_PERMIT_FLAG.values()) {
+            if (e.getValue() == value)
+                return e;
+        }
+        return EM_ALLOW_PERMIT_FLAG.EM_ALLOW_PERMIT_FLAG_UNKNOWN;
+    }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_ANALYSE_TASK_ERROR.java

@@ -0,0 +1,77 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+
+/** 
+* @author 291189
+* @description  智能分析任务错误码 
+* @date 2022/12/01 20:05:32
+*/
+public enum EM_ANALYSE_TASK_ERROR {
+/**
+未知
+*/
+    EM_ANALYSE_TASK_ERROR_UNKNOWN(1, "未知"),
+/**
+解码能力不足
+*/
+    EM_ANALYSE_TASK_ERROR_INSUFFICIENT_DECODING_CAPABILITY(2, "解码能力不足"),
+/**
+智能能力不足
+*/
+    EM_ANALYSE_TASK_ERROR_INSUFFICIENT_INTELLIGENCE_CAPABILITY(3, "智能能力不足"),
+/**
+码流格式不支持
+*/
+    EM_ANALYSE_TASK_ERROR_BITSTREAM_FORMAT_NOT_SUPPORTED(4, "码流格式不支持"),
+/**
+分析器离线
+*/
+    EM_ANALYSE_TASK_ERROR_ANALYZER_OFF_LINE(5, "分析器离线"),
+/**
+分析器上线
+*/
+    EM_ANALYSE_TASK_ERROR_ANALYZER_ON_LINE(6, "分析器上线");
+
+private int value;
+private String note;
+
+public String getNote() {
+        return note;
+    }
+
+public int getValue() {
+        return value;
+    }
+
+EM_ANALYSE_TASK_ERROR(int givenValue, String note) {
+        this.value = givenValue;
+        this.note = note;
+    }
+
+public static String getNoteByValue(int givenValue) {
+        for (EM_ANALYSE_TASK_ERROR enumType : EM_ANALYSE_TASK_ERROR.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+public static int getValueByNote(String givenNote) {
+        for (EM_ANALYSE_TASK_ERROR enumType : EM_ANALYSE_TASK_ERROR.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return 0;
+    }
+
+public static EM_ANALYSE_TASK_ERROR getEnum(int value) {
+        for (EM_ANALYSE_TASK_ERROR e : EM_ANALYSE_TASK_ERROR.values()) {
+            if (e.getValue() == value)
+                return e;
+        }
+        return EM_ANALYSE_TASK_ERROR.EM_ANALYSE_TASK_ERROR_UNKNOWN;
+    }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_ANALYSE_TASK_START_RULE.java

@@ -0,0 +1,61 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+
+/** 
+* @author 291189
+* @description  智能任务启动规则 
+* @date 2022/06/28 16:19:15
+*/
+public enum EM_ANALYSE_TASK_START_RULE {
+/**
+立刻启动
+*/
+    EM_ANALYSE_TASK_START_NOW(0, "立刻启动"),
+/**
+稍候手动启动
+*/
+    EM_ANALYSE_TASK_START_LATER(1, "稍候手动启动");
+
+private int value;
+private String note;
+
+public String getNote() {
+        return note;
+    }
+
+public int getValue() {
+        return value;
+    }
+
+EM_ANALYSE_TASK_START_RULE(int givenValue, String note) {
+        this.value = givenValue;
+        this.note = note;
+    }
+
+public static String getNoteByValue(int givenValue) {
+        for (EM_ANALYSE_TASK_START_RULE enumType : EM_ANALYSE_TASK_START_RULE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+public static int getValueByNote(String givenNote) {
+        for (EM_ANALYSE_TASK_START_RULE enumType : EM_ANALYSE_TASK_START_RULE.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+
+public static EM_ANALYSE_TASK_START_RULE getEnum(int value) {
+        for (EM_ANALYSE_TASK_START_RULE e : EM_ANALYSE_TASK_START_RULE.values()) {
+            if (e.getValue() == value)
+                return e;
+        }
+        return EM_ANALYSE_TASK_START_RULE.EM_ANALYSE_TASK_START_NOW;
+    }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_ANGLE_TYPE.java

@@ -0,0 +1,30 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+
+import com.inspect.nvr.daHuaCarme.jna.NetSDKLib;
+
+/**
+ * 角度
+ * 
+ * @author ： 260611
+ * @since ： Created in 2021/10/19 19:35
+ */
+public class EM_ANGLE_TYPE extends NetSDKLib.SdkStructure {
+    /**
+     *  未知
+     */
+    public static final int   EM_ANGLE_UNKNOWN = 0;
+    /**
+     *  正面
+     */
+    public static final int   EM_ANGLE_FRONT = 1;
+    /**
+     *  侧面
+     */
+    public static final int   EM_ANGLE_SIDE = 2;
+    /**
+     *  背面
+     */
+    public static final int   EM_ANGLE_BACK = 3;
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_ANTI_MISPRESS_TYPE.java

@@ -0,0 +1,69 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+
+/** 
+* @author 291189
+* @description  防误按模式 
+* @date 2022/08/31 14:44:16
+*/
+public enum EM_ANTI_MISPRESS_TYPE {
+/**
+未知
+*/
+    EM_ANTI_MISPRESS_UNKNOWN(0, "未知"),
+/**
+按下0.1s生效
+*/
+    EM_ANTI_MISPRESS_OFF(1, "按下0.1s生效"),
+/**
+长按3s有效
+*/
+    EM_ANTI_MISPRESS_LONG(2, "长按3s有效"),
+/**
+间断1s内连续按2次
+*/
+    EM_ANTI_MISPRESS_DOUBLE(3, "间断1s内连续按2次");
+
+private int value;
+private String note;
+
+public String getNote() {
+        return note;
+    }
+
+public int getValue() {
+        return value;
+    }
+
+EM_ANTI_MISPRESS_TYPE(int givenValue, String note) {
+        this.value = givenValue;
+        this.note = note;
+    }
+
+public static String getNoteByValue(int givenValue) {
+        for (EM_ANTI_MISPRESS_TYPE enumType : EM_ANTI_MISPRESS_TYPE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+public static int getValueByNote(String givenNote) {
+        for (EM_ANTI_MISPRESS_TYPE enumType : EM_ANTI_MISPRESS_TYPE.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+
+public static EM_ANTI_MISPRESS_TYPE getEnum(int value) {
+        for (EM_ANTI_MISPRESS_TYPE e : EM_ANTI_MISPRESS_TYPE.values()) {
+            if (e.getValue() == value)
+                return e;
+        }
+        return EM_ANTI_MISPRESS_TYPE.EM_ANTI_MISPRESS_UNKNOWN;
+    }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_APP_DEBUG_STATE.java

@@ -0,0 +1,55 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * APP的调试状态
+*/
+public enum EM_APP_DEBUG_STATE
+{
+    /**
+     * 未知
+    */
+    EM_APP_DEBUG_STATE_UNKNOWN(0, "未知"),
+    /**
+     * 开启调试
+    */
+    EM_APP_DEBUG_STATE_ENABLE(1, "开启调试"),
+    /**
+     * 关闭调试
+    */
+    EM_APP_DEBUG_STATE_DISABLE(2, "关闭调试");
+
+    private int value;
+    private String note;
+
+    public String getNote() {
+        return note;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    EM_APP_DEBUG_STATE(int givenValue, String note) {
+        this.value = givenValue;
+        this.note = note;
+    }
+
+    public static String getNoteByValue(int givenValue) {
+        for (EM_APP_DEBUG_STATE enumType : EM_APP_DEBUG_STATE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+    public static int getValueByNote(String givenNote) {
+        for (EM_APP_DEBUG_STATE enumType : EM_APP_DEBUG_STATE.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_APP_LICENSE_STATE.java

@@ -0,0 +1,59 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * APP的证书状态
+*/
+public enum EM_APP_LICENSE_STATE
+{
+    /**
+     * 未知
+    */
+    EM_APP_LICENSE_STATE_UNKNOEN(0, "未知"),
+    /**
+     * 证书试用期
+    */
+    EM_APP_LICENSE_STATE_IN_TRAL(1, "证书试用期"),
+    /**
+     * 证书正式合法
+    */
+    EM_APP_LICENSE_STATE_IN_LICENSE(2, "证书正式合法"),
+    /**
+     * 证书过期
+    */
+    EM_APP_LICENSE_STATE_EXPIRED(3, "证书过期");
+
+    private int value;
+    private String note;
+
+    public String getNote() {
+        return note;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    EM_APP_LICENSE_STATE(int givenValue, String note) {
+        this.value = givenValue;
+        this.note = note;
+    }
+
+    public static String getNoteByValue(int givenValue) {
+        for (EM_APP_LICENSE_STATE enumType : EM_APP_LICENSE_STATE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+    public static int getValueByNote(String givenNote) {
+        for (EM_APP_LICENSE_STATE enumType : EM_APP_LICENSE_STATE.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_APP_RUNNING_STATE.java

@@ -0,0 +1,59 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * APP的运行状态
+*/
+public enum EM_APP_RUNNING_STATE
+{
+    /**
+     * 未知
+    */
+    EM_APP_RUNNING_STATE_UNKNOWN(0, "未知"),
+    /**
+     * 运行中
+    */
+    EM_APP_RUNNING_STATE_RUNNING(1, "运行中"),
+    /**
+     * 已停止
+    */
+    EM_APP_RUNNING_STATE_STOP(2, "已停止"),
+    /**
+     * 异常状态
+    */
+    EM_APP_RUNNING_STATE_ERROR(3, "异常状态");
+
+    private int value;
+    private String note;
+
+    public String getNote() {
+        return note;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    EM_APP_RUNNING_STATE(int givenValue, String note) {
+        this.value = givenValue;
+        this.note = note;
+    }
+
+    public static String getNoteByValue(int givenValue) {
+        for (EM_APP_RUNNING_STATE enumType : EM_APP_RUNNING_STATE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+    public static int getValueByNote(String givenNote) {
+        for (EM_APP_RUNNING_STATE enumType : EM_APP_RUNNING_STATE.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_AREAALARM_TRIGGER_TYPE.java

@@ -0,0 +1,73 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+
+/** 
+* @author 291189
+* @description  区域报警触发类型 
+* @date 2022/07/19 19:31:27
+*/
+public enum EM_AREAALARM_TRIGGER_TYPE {
+/**
+未知
+*/
+    EM_AREAALARM_TRIGGER_TYPE_UNKNOWN(0, "未知"),
+/**
+通道打开
+*/
+    EM_AREAALARM_TRIGGER_TYPE_ALARM(1, "通道打开"),
+/**
+通道防拆
+*/
+    EM_AREAALARM_TRIGGER_TYPE_TAMPER(2, "通道防拆"),
+/**
+通道遮挡
+*/
+    EM_AREAALARM_TRIGGER_TYPE_MASK(3, "通道遮挡"),
+/**
+通道防短
+*/
+    EM_AREAALARM_TRIGGER_TYPE_SHORT(4, "通道防短");
+
+private int value;
+private String note;
+
+public String getNote() {
+        return note;
+    }
+
+public int getValue() {
+        return value;
+    }
+
+EM_AREAALARM_TRIGGER_TYPE(int givenValue, String note) {
+        this.value = givenValue;
+        this.note = note;
+    }
+
+public static String getNoteByValue(int givenValue) {
+        for (EM_AREAALARM_TRIGGER_TYPE enumType : EM_AREAALARM_TRIGGER_TYPE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+public static int getValueByNote(String givenNote) {
+        for (EM_AREAALARM_TRIGGER_TYPE enumType : EM_AREAALARM_TRIGGER_TYPE.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+
+public static EM_AREAALARM_TRIGGER_TYPE getEnum(int value) {
+        for (EM_AREAALARM_TRIGGER_TYPE e : EM_AREAALARM_TRIGGER_TYPE.values()) {
+            if (e.getValue() == value)
+                return e;
+        }
+        return EM_AREAALARM_TRIGGER_TYPE.EM_AREAALARM_TRIGGER_TYPE_UNKNOWN;
+    }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_AREAARM_TRIGGERMODE.java

@@ -0,0 +1,100 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * @author 291189
+ * @description 区域防区操作方式
+ * @date 2022/07/19 10:09:08
+ */
+public enum EM_AREAARM_TRIGGERMODE {
+	/**
+	 * 未知
+	 */
+    EM_AREAARM_TRIGGERMODE_UNKNOWN(0, "未知"),
+	/**
+	 * 键盘
+	 */
+    EM_AREAARM_TRIGGERMODE_KEYPAD(1, "键盘"),
+	/**
+	 * 遥控器
+	 */
+    EM_AREAARM_TRIGGERMODE_REMOTECONTROL(2, "遥控器"),
+	/**
+	 * 用户操作
+	 */
+    EM_AREAARM_TRIGGERMODE_USER(3, "用户操作"),
+	/**
+	 * 本地
+	 */
+    EM_AREAARM_TRIGGERMODE_LOCAL(4, "本地"),
+	/**
+	 * 定时器
+	 */
+    EM_AREAARM_TRIGGERMODE_TIMER(5, "定时器"),
+	/**
+	 * Key类型防区
+	 */
+    EM_AREAARM_TRIGGERMODE_KEY(6, "Key类型防区"),
+	/**
+	 * 远程操作(电话反控、短信反控、手机App、平台客户端等)
+	 */
+    EM_AREAARM_TRIGGERMODE_REMOTE(7, "远程操作(电话反控、短信反控、手机App、平台客户端等)"),
+	/**
+	 * DSS平台客户端
+	 */
+    EM_AREAARM_TRIGGERMODE_DSS(8, "DSS平台客户端"),
+	/**
+	 * DSSPro平台客户端
+	 */
+    EM_AREAARM_TRIGGERMODE_DSSPRO(9, "DSSPro平台客户端"),
+	/**
+	 * 手机客户端
+	 */
+    EM_AREAARM_TRIGGERMODE_DMSS(10, "手机客户端"),
+	/**
+	 * Smart pss、ICC平台
+	 */
+    EM_AREAARM_TRIGGERMODE_PLATFORM(11, "Smart pss、ICC平台");
+
+	private int value;
+	private String note;
+
+	public String getNote() {
+		return note;
+	}
+
+	public int getValue() {
+		return value;
+	}
+
+	EM_AREAARM_TRIGGERMODE(int givenValue, String note) {
+		this.value = givenValue;
+		this.note = note;
+	}
+
+	public static String getNoteByValue(int givenValue) {
+		for (EM_AREAARM_TRIGGERMODE enumType : EM_AREAARM_TRIGGERMODE.values()) {
+			if (givenValue == enumType.getValue()) {
+				return enumType.getNote();
+			}
+		}
+		return null;
+	}
+
+	public static int getValueByNote(String givenNote) {
+		for (EM_AREAARM_TRIGGERMODE enumType : EM_AREAARM_TRIGGERMODE.values()) {
+			if (givenNote.equals(enumType.getNote())) {
+				return enumType.getValue();
+			}
+		}
+		return -1;
+	}
+
+	public static EM_AREAARM_TRIGGERMODE getEnum(int value) {
+		for (EM_AREAARM_TRIGGERMODE e : EM_AREAARM_TRIGGERMODE.values()) {
+			if (e.getValue() == value)
+				return e;
+		}
+		return EM_AREAARM_TRIGGERMODE.EM_AREAARM_TRIGGERMODE_UNKNOWN;
+	}
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_AREAARM_USER.java

@@ -0,0 +1,84 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * @author 291189
+ * @description 区域防区操作用户
+ * @date 2022/07/19 10:09:08
+ */
+public enum EM_AREAARM_USER {
+	/**
+	 * 未知
+	 */
+    EM_AREAARM_USER_UNKNOWN(0, "未知"),
+	/**
+	 *
+	 */
+    EM_AREAARM_USER_SUPERVISOR(1, ""),
+	/**
+	 * 管理用户
+	 */
+    EM_AREAARM_USER_MANAGER(2, "管理用户"),
+	/**
+	 * 主用户
+	 */
+    EM_AREAARM_USER_MASTER(3, "主用户"),
+	/**
+	 * 普通用户
+	 */
+    EM_AREAARM_USER_USER(4, "普通用户"),
+	/**
+	 * 临时用户
+	 */
+    EM_AREAARM_USER_TEMPORARY(5, "临时用户"),
+	/**
+	 * 胁迫用户
+	 */
+    EM_AREAARM_USER_DURESS(6, "胁迫用户"),
+	/**
+	 * 巡逻用户
+	 */
+    EM_AREAARM_USER_PATROL(7, "巡逻用户");
+
+	private int value;
+	private String note;
+
+	public String getNote() {
+		return note;
+	}
+
+	public int getValue() {
+		return value;
+	}
+
+	EM_AREAARM_USER(int givenValue, String note) {
+		this.value = givenValue;
+		this.note = note;
+	}
+
+	public static String getNoteByValue(int givenValue) {
+		for (EM_AREAARM_USER enumType : EM_AREAARM_USER.values()) {
+			if (givenValue == enumType.getValue()) {
+				return enumType.getNote();
+			}
+		}
+		return null;
+	}
+
+	public static int getValueByNote(String givenNote) {
+		for (EM_AREAARM_USER enumType : EM_AREAARM_USER.values()) {
+			if (givenNote.equals(enumType.getNote())) {
+				return enumType.getValue();
+			}
+		}
+		return -1;
+	}
+
+	public static EM_AREAARM_USER getEnum(int value) {
+		for (EM_AREAARM_USER e : EM_AREAARM_USER.values()) {
+			if (e.getValue() == value)
+				return e;
+		}
+		return EM_AREAARM_USER.EM_AREAARM_USER_UNKNOWN;
+	}
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_AREA_TYPE.java

@@ -0,0 +1,55 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * 车道线属性
+*/
+public enum EM_AREA_TYPE
+{
+    /**
+     * 未知
+    */
+    EM_AREA_TYPE_UNKNOWN(0, "未知"),
+    /**
+     * 信号灯
+    */
+    EM_AREA_TYPE_SIGNAL_LIGHT(1, "信号灯"),
+    /**
+     * LED屏
+    */
+    EM_AREA_TYPE_LED_SCREEN(2, "LED屏");
+
+    private int value;
+    private String note;
+
+    public String getNote() {
+        return note;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    EM_AREA_TYPE(int givenValue, String note) {
+        this.value = givenValue;
+        this.note = note;
+    }
+
+    public static String getNoteByValue(int givenValue) {
+        for (EM_AREA_TYPE enumType : EM_AREA_TYPE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+    public static int getValueByNote(String givenNote) {
+        for (EM_AREA_TYPE enumType : EM_AREA_TYPE.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_ARMING_TYPE.java

@@ -0,0 +1,65 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+
+/** 
+* @author 291189
+* @description  布防模式 
+* @date 2022/08/31 14:44:17
+*/
+public enum EM_ARMING_TYPE {
+/**
+未知
+*/
+    EM_ARMING_UNKNOWN(-1, "未知"),
+/**
+在家布防
+*/
+    EM_ARMING_ATHOME(0, "在家布防"),
+/**
+外出布防
+*/
+    EM_ARMING_OUT(1, "外出布防");
+
+private int value;
+private String note;
+
+public String getNote() {
+        return note;
+    }
+
+public int getValue() {
+        return value;
+    }
+
+EM_ARMING_TYPE(int givenValue, String note) {
+        this.value = givenValue;
+        this.note = note;
+    }
+
+public static String getNoteByValue(int givenValue) {
+        for (EM_ARMING_TYPE enumType : EM_ARMING_TYPE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+public static int getValueByNote(String givenNote) {
+        for (EM_ARMING_TYPE enumType : EM_ARMING_TYPE.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -2;
+    }
+
+public static EM_ARMING_TYPE getEnum(int value) {
+        for (EM_ARMING_TYPE e : EM_ARMING_TYPE.values()) {
+            if (e.getValue() == value)
+                return e;
+        }
+        return EM_ARMING_TYPE.EM_ARMING_UNKNOWN;
+    }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_ARM_STATE.java

@@ -0,0 +1,58 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * @author 251823
+ * @description 布撤防状态
+ * @date 2021/11/08
+ */
+public enum EM_ARM_STATE {
+	// 未知
+    EM_ARM_STATE_UNKNOWN(0, "未知"),
+	// Total布防
+    EM_ARM_STATE_TOTAL_ARMING(1, "Total布防"),
+	// partial1布防
+    EM_ARM_STATE_PARTIAL1_ARMING(2, "partial1布防"),
+	// partial2布防
+    EM_ARM_STATE_PARTIAL2_ARMING(3, "partial2布防"),
+	// partial1+2布防
+    EM_ARM_STATE_PARTIAL1_PARTIAL2_ARMING(4, "partial1+2布防"),
+	// 强制布防
+    EM_ARM_STATE_FORCEARMING(5, "强制布防"),
+	// 撤防
+    EM_ARM_STATE_DISARMING(6, "撤防");
+
+	private int value;
+	private String note;
+
+	private EM_ARM_STATE(int givenValue, String note) {
+		this.value = givenValue;
+		this.note = note;
+	}
+
+	public String getNote() {
+		return note;
+	}
+
+	public int getValue() {
+		return value;
+	}
+
+	public static String getNoteByValue(int givenValue) {
+		for (EM_ARM_STATE enumType : EM_ARM_STATE.values()) {
+			if (givenValue == enumType.getValue()) {
+				return enumType.getNote();
+			}
+		}
+		return null;
+	}
+
+	public static int getValueByNote(String givenNote) {
+		for (EM_ARM_STATE enumType : EM_ARM_STATE.values()) {
+			if (givenNote.equals(enumType.getNote())) {
+				return enumType.getValue();
+			}
+		}
+		return -1;
+	}
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_ARM_TYPE.java

@@ -0,0 +1,80 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * @author 291189
+ * @description 布撤防类型
+ * @date 2022/07/19 10:54:34
+ */
+public enum EM_ARM_TYPE {
+	/**
+	 * 未知
+	 */
+    EM_ARM_TYPE_UNKNOWN(0, "未知"),
+	/**
+	 * Total布防
+	 */
+    EM_ARM_TYPE_TOTAL_ARMING(1, "Total布防"),
+	/**
+	 * partial1布防
+	 */
+    EM_ARM_TYPE_PARTIAL1_ARMING(2, "partial1布防"),
+	/**
+	 * partial2布防
+	 */
+    EM_ARM_TYPE_PARTIAL2_ARMING(3, "partial2布防"),
+	/**
+	 * partial1+2布防
+	 */
+    EM_ARM_TYPE_PARTIAL_ARMING(4, "partial1+2布防"),
+	/**
+	 * 强制布防
+	 */
+    EM_ARM_TYPE_DENFENCE_ARMING(5, "强制布防"),
+	/**
+	 * 撤防
+	 */
+    EM_ARM_TYPE_DISARMING(6, "撤防");
+
+	private int value;
+	private String note;
+
+	public String getNote() {
+		return note;
+	}
+
+	public int getValue() {
+		return value;
+	}
+
+	EM_ARM_TYPE(int givenValue, String note) {
+		this.value = givenValue;
+		this.note = note;
+	}
+
+	public static String getNoteByValue(int givenValue) {
+		for (EM_ARM_TYPE enumType : EM_ARM_TYPE.values()) {
+			if (givenValue == enumType.getValue()) {
+				return enumType.getNote();
+			}
+		}
+		return null;
+	}
+
+	public static int getValueByNote(String givenNote) {
+		for (EM_ARM_TYPE enumType : EM_ARM_TYPE.values()) {
+			if (givenNote.equals(enumType.getNote())) {
+				return enumType.getValue();
+			}
+		}
+		return -1;
+	}
+
+	public static EM_ARM_TYPE getEnum(int value) {
+		for (EM_ARM_TYPE e : EM_ARM_TYPE.values()) {
+			if (e.getValue() == value)
+				return e;
+		}
+		return EM_ARM_TYPE.EM_ARM_TYPE_UNKNOWN;
+	}
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_ASG_BATTERY_STATE.java

@@ -0,0 +1,55 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * 闸机电池状态
+*/
+public enum EM_ASG_BATTERY_STATE
+{
+    /**
+     * 未知
+    */
+    EM_ASG_BATTERY_STATE_UNKNOWN(0, "未知"),
+    /**
+     * 不在位
+    */
+    EM_ASG_BATTERY_STATE_NOT_IN_PLACE(1, "不在位"),
+    /**
+     * 在位
+    */
+    EM_ASG_BATTERY_STATE_IN_PLACE(2, "在位");
+
+    private int value;
+    private String note;
+
+    public String getNote() {
+        return note;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    EM_ASG_BATTERY_STATE(int givenValue, String note) {
+        this.value = givenValue;
+        this.note = note;
+    }
+
+    public static String getNoteByValue(int givenValue) {
+        for (EM_ASG_BATTERY_STATE enumType : EM_ASG_BATTERY_STATE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+    public static int getValueByNote(String givenNote) {
+        for (EM_ASG_BATTERY_STATE enumType : EM_ASG_BATTERY_STATE.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_ASG_WORK_MODE.java

@@ -0,0 +1,49 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * @author 47081
+ * @version 1.0
+ * @description 工作模式
+ * @date 2021/2/7
+ */
+public enum EM_ASG_WORK_MODE {
+  /** 未知 */
+    EM_ASG_WORK_MODE_UNKNOWN(-1, "未知"),
+  /** 常闭模式 */
+    EM_ASG_WORK_MODE_CLOSE(0, "常闭模式"),
+    EM_ASG_WORK_MODE_OPEN(1, "常开模式");
+
+  private int mode;
+  private String desc;
+
+  EM_ASG_WORK_MODE(int mode, String desc) {
+    this.mode = mode;
+    this.desc = desc;
+  }
+
+  public static EM_ASG_WORK_MODE getAsgWorkMode(int mode) {
+    for (EM_ASG_WORK_MODE workMode : EM_ASG_WORK_MODE.values()) {
+      if (workMode.mode == mode) {
+        return workMode;
+      }
+    }
+    return EM_ASG_WORK_MODE_UNKNOWN;
+  }
+
+  public int getMode() {
+    return mode;
+  }
+
+  public void setMode(int mode) {
+    this.mode = mode;
+  }
+
+  public String getDesc() {
+    return desc;
+  }
+
+  public void setDesc(String desc) {
+    this.desc = desc;
+  }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_ASSOCIATED_RECORD_SOURCE.java

@@ -0,0 +1,46 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+
+import com.inspect.nvr.daHuaCarme.jna.NetSDKLib;
+
+/**
+ * 是否与其他目标关联
+ * 
+ * @author ： 260611
+ * @since ： Created in 2021/10/19 19:35
+ */
+public class EM_ASSOCIATED_RECORD_SOURCE extends NetSDKLib.SdkStructure {
+    /**
+     *  未知
+     */
+    public static final int   EM_ASSOCIATED_RECORD_SOURCE_UNKNOWN = -1;
+    /**
+     *  未关联
+     */
+    public static final int   EM_ASSOCIATED_RECORD_SOURCE_NONE = 0;
+    /**
+     *  与人体有关联成功
+     */
+    public static final int   EM_ASSOCIATED_RECORD_SOURCE_HUMAN = 1;
+    /**
+     *  与机动车过车有关联
+     */
+    public static final int   EM_ASSOCIATED_RECORD_SOURCE_MOTOR_VEHICLE_PASSING = 2;
+    /**
+     *  与机动车违章有关联
+     */
+    public static final int   EM_ASSOCIATED_RECORD_SOURCE_MOTOR_VEHICLE_VIOLATION = 3;
+    /**
+     *  与结构化机动车有关联
+     */
+    public static final int   EM_ASSOCIATED_RECORD_SOURCE_STRUCTURED_MOTOR_VEHICLE = 4;
+    /**
+     *  与人脸有关联
+     */
+    public static final int   EM_ASSOCIATED_RECORD_SOURCE_FACE = 5;
+    /**
+     *  与非机动车有关联
+     */
+    public static final int   EM_ASSOCIATED_RECORD_SOURCE_NON_MOTOR_VEHICLE = 6;
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_ATTACH_TOPICS.java

@@ -0,0 +1,65 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+
+/**
+ * @author 260611
+ * @description 订阅类型
+ * @date 2022/04/20 10:16:56
+ */
+public enum EM_ATTACH_TOPICS {
+    /**
+     * 表示订阅所有属性和事件
+     */
+    EM_ATTACH_TOPICS_ALL(0, " *  表示订阅所有属性和事件"),
+    /**
+     * Props  表示订阅设备属性上报
+     */
+    EM_ATTACH_TOPICS_PROPS(1, " Props  表示订阅设备属性上报"),
+    /**
+     * Events  标识订阅设备事件上报
+     */
+    EM_ATTACH_TOPICS_EVENTS(2, " Events  标识订阅设备事件上报");
+
+    private int value;
+    private String note;
+
+    public String getNote() {
+        return note;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    EM_ATTACH_TOPICS(int givenValue, String note) {
+        this.value = givenValue;
+        this.note = note;
+    }
+
+    public static String getNoteByValue(int givenValue) {
+        for (EM_ATTACH_TOPICS enumType : EM_ATTACH_TOPICS.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+    public static int getValueByNote(String givenNote) {
+        for (EM_ATTACH_TOPICS enumType : EM_ATTACH_TOPICS.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+
+    public static EM_ATTACH_TOPICS getEnum(int value) {
+        for (EM_ATTACH_TOPICS e : EM_ATTACH_TOPICS.values()) {
+            if (e.getValue() == value)
+                return e;
+        }
+        return EM_ATTACH_TOPICS.EM_ATTACH_TOPICS_ALL;
+    }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_AUDIO_DATA_SOURCE_TYPE.java

@@ -0,0 +1,52 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * @author 251823
+ * @description 音频解码能力数据流源类型
+ * @date 2021/01/06
+ */
+public enum EM_AUDIO_DATA_SOURCE_TYPE {
+	// 未知数据类型
+    EM_AUDIO_DATA_SOURCE_TYPE_UNKNOWN(-1, "未知数据类型"),
+	// 对讲数据
+    EM_AUDIO_DATA_SOURCE_TYPE_TALK(0, "对讲数据"),
+	// 普通音频数据，如伴音
+    EM_AUDIO_DATA_SOURCE_TYPE_NORMAL(1, "普通音频数据，如伴音"),
+	// 报警音频数据流
+    EM_AUDIO_DATA_SOURCE_TYPE_ALARM(2, "报警音频数据流");
+
+	private int value;
+	private String note;
+
+	private EM_AUDIO_DATA_SOURCE_TYPE(int givenValue, String note) {
+		this.value = givenValue;
+		this.note = note;
+	}
+
+	public String getNote() {
+		return note;
+	}
+
+	public int getValue() {
+		return value;
+	}
+
+	public static String getNoteByValue(int givenValue) {
+		for (EM_AUDIO_DATA_SOURCE_TYPE enumType : EM_AUDIO_DATA_SOURCE_TYPE.values()) {
+			if (givenValue == enumType.getValue()) {
+				return enumType.getNote();
+			}
+		}
+		return null;
+	}
+
+	public static int getValueByNote(String givenNote) {
+		for (EM_AUDIO_DATA_SOURCE_TYPE enumType : EM_AUDIO_DATA_SOURCE_TYPE.values()) {
+			if (givenNote.equals(enumType.getNote())) {
+				return enumType.getValue();
+			}
+		}
+		return -2;
+	}
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_AUDIO_DATA_TYPE.java

@@ -0,0 +1,30 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * @author 47081
+ * @version 1.0
+ * @description 音频数据类型
+ * @date 2021/2/22
+ */
+public enum EM_AUDIO_DATA_TYPE {
+  /** 默认 */
+    EM_AUDIO_DATA_TYPE_DEFAULT,
+  /** 音频强制转换为AAC */
+    EM_AUDIO_DATA_TYPE_AAC,
+  /** 音频强制转换为G711A */
+    EM_AUDIO_DATA_TYPE_G711A,
+  /** 音频强制转换为G711U */
+    EM_AUDIO_DATA_TYPE_G711U,
+  /** 音频强制转换为MP2 */
+    EM_AUDIO_DATA_TYPE_MP2;
+
+  public static EM_AUDIO_DATA_TYPE getAudioDataType(int type) {
+    for (EM_AUDIO_DATA_TYPE audioType : EM_AUDIO_DATA_TYPE.values()) {
+      if (audioType.ordinal() == type) {
+        return audioType;
+      }
+    }
+    return EM_AUDIO_DATA_TYPE_DEFAULT;
+  }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_AUDIO_MUTATION_ALARM_TYPE.java

@@ -0,0 +1,50 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * 声音类型枚举
+*/
+public enum EM_AUDIO_MUTATION_ALARM_TYPE
+{
+    AUDIO_MUTATION_UNKNOW(0, ""),
+    AUDIO_MUTATION_CRY(1, ""),
+    AUDIO_MUTATION_ALARM(2, ""),
+    AUDIO_MUTATION_GUNSHOT(3, ""),
+    AUDIO_MUTATION_EXPLOSION(4, ""),
+    AUDIO_MUTATION_SCREAM(5, ""),
+    AUDIO_MUTATION_CRASHINGGLASS(6, "");
+
+    private int value;
+    private String note;
+
+    public String getNote() {
+        return note;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    EM_AUDIO_MUTATION_ALARM_TYPE(int givenValue, String note) {
+        this.value = givenValue;
+        this.note = note;
+    }
+
+    public static String getNoteByValue(int givenValue) {
+        for (EM_AUDIO_MUTATION_ALARM_TYPE enumType : EM_AUDIO_MUTATION_ALARM_TYPE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+    public static int getValueByNote(String givenNote) {
+        for (EM_AUDIO_MUTATION_ALARM_TYPE enumType : EM_AUDIO_MUTATION_ALARM_TYPE.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_AUDIO_SOURCE_FLAG.java

@@ -0,0 +1,50 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * @author 251823
+ * @description 音频数据来源
+ * @date 2021/12/29
+ */
+public enum EM_AUDIO_SOURCE_FLAG {
+	// 未知状态
+    EM_AUDIO_SOURCE_FLAG_UNKNOWN(-1, "未知状态"),
+	// 本地录音数据，可以发送给设备
+    EM_AUDIO_SOURCE_FLAG_LOCAL(0, "本地录音数据，可以发送给设备"),
+	// 远程音频数据，即从设备接收到音频数据
+    EM_AUDIO_SOURCE_FLAG_REMOTE(1, "远程音频数据，即从设备接收到音频数据");
+
+	private int value;
+	private String note;
+
+	private EM_AUDIO_SOURCE_FLAG(int givenValue, String note) {
+		this.value = givenValue;
+		this.note = note;
+	}
+
+	public String getNote() {
+		return note;
+	}
+
+	public int getValue() {
+		return value;
+	}
+
+	public static String getNoteByValue(int givenValue) {
+		for (EM_AUDIO_SOURCE_FLAG enumType : EM_AUDIO_SOURCE_FLAG.values()) {
+			if (givenValue == enumType.getValue()) {
+				return enumType.getNote();
+			}
+		}
+		return null;
+	}
+
+	public static int getValueByNote(String givenNote) {
+		for (EM_AUDIO_SOURCE_FLAG enumType : EM_AUDIO_SOURCE_FLAG.values()) {
+			if (givenNote.equals(enumType.getNote())) {
+				return enumType.getValue();
+			}
+		}
+		return -2;
+	}
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_AUTO_PROTECT_WEEK.java

@@ -0,0 +1,62 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * @author 251823
+ * @description 自动维护星期
+ * @date 2021/08/24
+ */
+public enum EM_AUTO_PROTECT_WEEK {
+	// 未知
+    EM_AUTO_PROTECT_UNKNOWN(0, "未知"),
+	// 星期一
+    EM_AUTO_PROTECT_MONDAY(1, "星期一"),
+	// 星期二
+    EM_AUTO_PROTECT_TUESDAY(2, "星期二"),
+	// 星期三
+    EM_AUTO_PROTECT_WEDNESDAY(3, "星期三"),
+	// 星期四
+    EM_AUTO_PROTECT_THURSDAY(4, "星期四"),
+	// 星期五
+    EM_AUTO_PROTECT_FIRDAY(5, "星期五"),
+	// 星期六
+    EM_AUTO_PROTECT_SATURDAY(6, "星期六"),
+	// 星期天
+    EM_AUTO_PROTECT_SUNDAY(7, "星期天"),
+	// 每天
+    EM_AUTO_PROTECT_EVERYDAY(8, "每天");
+
+	private int value;
+	private String note;
+
+	private EM_AUTO_PROTECT_WEEK(int givenValue, String note) {
+		this.value = givenValue;
+		this.note = note;
+	}
+
+	public String getNote() {
+		return note;
+	}
+
+	public int getValue() {
+		return value;
+	}
+
+	public static String getNoteByValue(int givenValue) {
+		for (EM_AUTO_PROTECT_WEEK enumType : EM_AUTO_PROTECT_WEEK.values()) {
+			if (givenValue == enumType.getValue()) {
+				return enumType.getNote();
+			}
+		}
+		return null;
+	}
+
+	public static int getValueByNote(String givenNote) {
+		for (EM_AUTO_PROTECT_WEEK enumType : EM_AUTO_PROTECT_WEEK.values()) {
+			if (givenNote.equals(enumType.getNote())) {
+				return enumType.getValue();
+			}
+		}
+		return -1;
+	}
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_BACKLIGHT_MODE.java

@@ -0,0 +1,67 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+
+/** 
+* @author 291189
+* @description  背光补偿模式，当背光模式为Backlight时有效 
+* @origin autoTool
+* @date 2023/11/30 16:22:26
+*/
+public enum EM_BACKLIGHT_MODE {
+	/**
+     * 未知模式
+     */
+    EM_BACKLIGHT_UNKONW(0, "未知模式"),
+	/**
+     * 默认模式
+     */
+    EM_BACKLIGHT_DEFAULT(1, "默认模式"),
+	/**
+     * 自定义区域模式
+     */
+    EM_BACKLIGHT_REGION(2, "自定义区域模式");
+
+private int value;
+private String note;
+
+public String getNote() {
+        return note;
+    }
+
+public int getValue() {
+        return value;
+    }
+
+EM_BACKLIGHT_MODE(int givenValue, String note) {
+        this.value = givenValue;
+        this.note = note;
+    }
+
+public static String getNoteByValue(int givenValue) {
+        for (EM_BACKLIGHT_MODE enumType : EM_BACKLIGHT_MODE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+public static int getValueByNote(String givenNote) {
+        for (EM_BACKLIGHT_MODE enumType : EM_BACKLIGHT_MODE.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+
+public static EM_BACKLIGHT_MODE getEnum(int value) {
+        for (EM_BACKLIGHT_MODE e : EM_BACKLIGHT_MODE.values()) {
+            if (e.getValue() == value){
+                return e;
+            }
+        }
+        return EM_BACKLIGHT_MODE.EM_BACKLIGHT_UNKONW;
+    }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_BACKUP_ERROR_CODE.java

@@ -0,0 +1,78 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * @author 251823
+ * @description 备份模式设置错误码
+ * @date 2021/09/28
+ */
+public enum EM_BACKUP_ERROR_CODE {
+	// 未知
+    EM_BACKUP_ERROR_CODE_UNKNOWN(-1, "未知"),
+	// 备份模式设置成功
+    EM_BACKUP_ERROR_CODE_SUCCESS(0, "备份模式设置成功"),
+	// 周期方案表有误
+    EM_BACKUP_ERROR_CODE_CYCLE_PLAN(1, "周期方案表有误"),
+	// 绿信比表有误
+    EM_BACKUP_ERROR_CODE_GREEN_LETTER(2, "绿信比表有误"),
+	// 时基方案表有误
+    EM_BACKUP_ERROR_CODE_TIME_BASE_PLAN(3, "时基方案表有误"),
+	// 日计划表有误
+    EM_BACKUP_ERROR_CODE_DAY_PLAN(4, "日计划表有误"),
+	// 动作方案表有误
+    EM_BACKUP_ERROR_CODE_ACTION_PLAN(5, "动作方案表有误"),
+	// 相序表有误
+    EM_BACKUP_ERROR_CODE_PHASE_SEQUENCE(6, "相序表有误"),
+	// 通道表有误
+    EM_BACKUP_ERROR_CODE_CHANNEL_TABLE(7, "通道表有误"),
+	// 跟随相位表有误
+    EM_BACKUP_ERROR_CODE_FOLLOW_PHASE_TABLE(8, "跟随相位表有误"),
+	// 相位冲突
+    EM_BACKUP_ERROR_CODE_PHASE_CONFLCT(9, "相位冲突"),
+	// 下发方案超时
+    EM_BACKUP_ERROR_CODE_DELIVERY_PLAN(10, "下发方案超时"),
+	// 车道表设置有误
+    EM_BACKUP_ERROR_CODE_LANE_TABLE_SETTING(11, "车道表设置有误"),
+    // 用于信号灯，提示信号灯不支持短连接路口
+    EM_BACKUP_ERROR_CODE_NOT_SUPPORT_SHORT_JUNCTIONS(12, "用于信号灯，提示信号灯不支持短连接路口"),
+    // 通道配置有误 用于信号灯 无掉头箭头灯、直行非机动车灯、左转非机动车灯、公交信号灯--可变车道
+    EM_BACKUP_ERROR_CODE_CHANNEL_CONFIGURATION(13, "通道配置有误"),
+    // 可变车道方案表有误
+    EM_BACKUP_ERROR_CODE_VARIABLEE_LANE_TABLE(14, "可变车道方案表有误	"),
+    // 周计划方案表有误
+    EM_BACKUP_ERROR_CODE_WEEKLY_PLAN(15, "周计划方案表有误");
+
+	private int value;
+	private String note;
+
+	private EM_BACKUP_ERROR_CODE(int givenValue, String note) {
+		this.value = givenValue;
+		this.note = note;
+	}
+
+	public String getNote() {
+		return note;
+	}
+
+	public int getValue() {
+		return value;
+	}
+
+	public static String getNoteByValue(int givenValue) {
+		for (EM_BACKUP_ERROR_CODE enumType : EM_BACKUP_ERROR_CODE.values()) {
+			if (givenValue == enumType.getValue()) {
+				return enumType.getNote();
+			}
+		}
+		return null;
+	}
+
+	public static int getValueByNote(String givenNote) {
+		for (EM_BACKUP_ERROR_CODE enumType : EM_BACKUP_ERROR_CODE.values()) {
+			if (givenNote.equals(enumType.getNote())) {
+				return enumType.getValue();
+			}
+		}
+		return -2;
+	}
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_BACKUP_FORMAT.java

@@ -0,0 +1,46 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+/**
+ * 
+ * @author 119178
+ *
+ */
+public enum EM_BACKUP_FORMAT {
+    EM_BACKUP_FORMAT_ASF(0, "asf"),// "asf"
+    EM_BACKUP_FORMAT_DAV(1, "dav"),// "dav"
+    EM_BACKUP_FORMAT_MP4(2, "mp4");// "mp4"
+
+	private int value;
+	private String note;
+
+	private EM_BACKUP_FORMAT(int givenValue, String note) {
+		this.value = givenValue;
+		this.note = note;
+	}
+
+	public String getNote() {
+		return note;
+	}
+
+	public int getValue() {
+		return value;
+	}
+
+	public static String getNoteByValue(int givenValue) {
+		for (EM_TRAFFICSTROBE_STATUS enumType : EM_TRAFFICSTROBE_STATUS.values()) {
+			if (givenValue == enumType.getValue()) {
+				return enumType.getNote();
+			}
+		}
+		return null;
+	}
+
+	public static int getValueByNote(String givenNote) {
+		for (EM_TRAFFICSTROBE_STATUS enumType : EM_TRAFFICSTROBE_STATUS.values()) {
+			if (givenNote.equals(enumType.getNote())) {
+				return enumType.getValue();
+			}
+		}
+		return -1;
+	}
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_BACKUP_SOURCE_MODE.java

@@ -0,0 +1,41 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+public enum EM_BACKUP_SOURCE_MODE {
+    EM_SOURCE_MODE_SINGLE(0, "Single"),// "Single",/*单个备份模式*/
+    EM_SOURCE_MODE_COMBIN(1, "Combin");// "Combin",/*合并备份模式*/
+
+	private int value;
+	private String note;
+
+	private EM_BACKUP_SOURCE_MODE(int givenValue, String note) {
+		this.value = givenValue;
+		this.note = note;
+	}
+
+	public String getNote() {
+		return note;
+	}
+
+	public int getValue() {
+		return value;
+	}
+
+	public static String getNoteByValue(int givenValue) {
+		for (EM_TRAFFICSTROBE_STATUS enumType : EM_TRAFFICSTROBE_STATUS.values()) {
+			if (givenValue == enumType.getValue()) {
+				return enumType.getNote();
+			}
+		}
+		return null;
+	}
+
+	public static int getValueByNote(String givenNote) {
+		for (EM_TRAFFICSTROBE_STATUS enumType : EM_TRAFFICSTROBE_STATUS.values()) {
+			if (givenNote.equals(enumType.getNote())) {
+				return enumType.getValue();
+			}
+		}
+		return -1;
+	}
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_BACKUP_SOURCE_TYPE.java

@@ -0,0 +1,42 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+public enum EM_BACKUP_SOURCE_TYPE {
+    EM_SOURCE_TYPE_REALTIME(0, "RealTime"),// "RealTime", /*实时源*/,源类型有效
+    EM_SOURCE_TYPE_LOCAL(1, "Local"),// "Local", /*本地源*/
+    EM_SOURCE_TYPE_NETWORK(2, "Network");// "Network", /*网络源*/
+
+	private int value;
+	private String note;
+
+	private EM_BACKUP_SOURCE_TYPE(int givenValue, String note) {
+		this.value = givenValue;
+		this.note = note;
+	}
+
+	public String getNote() {
+		return note;
+	}
+
+	public int getValue() {
+		return value;
+	}
+
+	public static String getNoteByValue(int givenValue) {
+		for (EM_TRAFFICSTROBE_STATUS enumType : EM_TRAFFICSTROBE_STATUS.values()) {
+			if (givenValue == enumType.getValue()) {
+				return enumType.getNote();
+			}
+		}
+		return null;
+	}
+
+	public static int getValueByNote(String givenNote) {
+		for (EM_TRAFFICSTROBE_STATUS enumType : EM_TRAFFICSTROBE_STATUS.values()) {
+			if (givenNote.equals(enumType.getNote())) {
+				return enumType.getValue();
+			}
+		}
+		return -1;
+	}
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_BACKUP_TARGET_MODE.java

@@ -0,0 +1,42 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+public enum EM_BACKUP_TARGET_MODE {
+    EM_TARGET_MODE_SYNC(0, "Sync"),// "Sync", /*同步备份*/
+    EM_TARGET_MODE_TURN(1, "Turn"),// "Turn", /*轮训备份*/
+    EM_TARGET_MODE_CYCLE(2, "Cycle");// "Cycle", /*循环备份*/
+
+	private int value;
+	private String note;
+
+	private EM_BACKUP_TARGET_MODE(int givenValue, String note) {
+		this.value = givenValue;
+		this.note = note;
+	}
+
+	public String getNote() {
+		return note;
+	}
+
+	public int getValue() {
+		return value;
+	}
+
+	public static String getNoteByValue(int givenValue) {
+		for (EM_TRAFFICSTROBE_STATUS enumType : EM_TRAFFICSTROBE_STATUS.values()) {
+			if (givenValue == enumType.getValue()) {
+				return enumType.getNote();
+			}
+		}
+		return null;
+	}
+
+	public static int getValueByNote(String givenNote) {
+		for (EM_TRAFFICSTROBE_STATUS enumType : EM_TRAFFICSTROBE_STATUS.values()) {
+			if (givenNote.equals(enumType.getNote())) {
+				return enumType.getValue();
+			}
+		}
+		return -1;
+	}
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_BACKUP_TARGET_TYPE.java

@@ -0,0 +1,41 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+public enum EM_BACKUP_TARGET_TYPE {
+    EM_TARGET_TYPE_LOCAL(0, "Local"),// "Local", /*本地源*/
+    EM_TARGET_TYPE_NETWORK(1, "Network");// "Network", /*网络源*/
+
+	private int value;
+	private String note;
+
+	private EM_BACKUP_TARGET_TYPE(int givenValue, String note) {
+		this.value = givenValue;
+		this.note = note;
+	}
+
+	public String getNote() {
+		return note;
+	}
+
+	public int getValue() {
+		return value;
+	}
+
+	public static String getNoteByValue(int givenValue) {
+		for (EM_TRAFFICSTROBE_STATUS enumType : EM_TRAFFICSTROBE_STATUS.values()) {
+			if (givenValue == enumType.getValue()) {
+				return enumType.getNote();
+			}
+		}
+		return null;
+	}
+
+	public static int getValueByNote(String givenNote) {
+		for (EM_TRAFFICSTROBE_STATUS enumType : EM_TRAFFICSTROBE_STATUS.values()) {
+			if (givenNote.equals(enumType.getNote())) {
+				return enumType.getValue();
+			}
+		}
+		return -1;
+	}
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_BAG_TYPE.java

@@ -0,0 +1,42 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+import com.inspect.nvr.daHuaCarme.jna.NetSDKLib;
+
+
+/**
+ * 包类型
+ * 
+ * @author ： 260611
+ * @since ： Created in 2021/10/19 19:35
+ */
+public class EM_BAG_TYPE extends NetSDKLib.SdkStructure {
+    /**
+     *  未知
+     */
+    public static final int   EM_BAG_UNKNOWN = 0;
+    /**
+     *  手提包
+     */
+    public static final int   EM_BAG_HANDBAG = 1;
+    /**
+     *  肩包
+     */
+    public static final int   EM_BAG_SHOULDERBAG = 2;
+    /**
+     *  背包
+     */
+    public static final int   EM_BAG_KNAPSACK = 3;
+    /**
+     *  拉杆箱
+     */
+    public static final int   EM_BAG_DRAWBARBOX = 4;
+    /**
+     *  腰包
+     */
+    public static final int   EM_BAG_WAISTPACK = 5;
+    /**
+     *  无包
+     */
+    public static final int   EM_BAG_NONE = 6;
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_BATTERY_EXIST_STATE.java

@@ -0,0 +1,42 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+public enum EM_BATTERY_EXIST_STATE {
+    EM_BATTERY_EXIST_STATE_UNKNOWN(0, "电池在位未知"),
+    EM_BATTERY_EXIST_STATE_EXIST(1, "电池在位"),// 电池在位
+    EM_BATTERY_EXIST_STATE_MISSING(2, "电池丢失");// 电池丢失
+
+    private int value;
+    private String note;
+
+    private EM_BATTERY_EXIST_STATE(int givenValue, String note) {
+        this.value = givenValue;
+        this.note = note;
+    }
+
+    public String getNote() {
+        return note;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    public static String getNoteByValue(int givenValue) {
+        for (EM_BATTERY_EXIST_STATE enumType : EM_BATTERY_EXIST_STATE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+    public static int getValueByNote(String givenNote) {
+        for (EM_BATTERY_EXIST_STATE enumType : EM_BATTERY_EXIST_STATE.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_BATTERY_STATE.java

@@ -0,0 +1,42 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+public enum EM_BATTERY_STATE {
+    EM_BATTERY_STATE_UNKNOWN(0, "电量未知"),
+    EM_BATTERY_STATE_NORMAL(1, "电量正常"),// 电量正常
+    EM_BATTERY_STATE_LOW(2, "电量低");// 电量低
+
+    private int value;
+    private String note;
+
+    private EM_BATTERY_STATE(int givenValue, String note) {
+        this.value = givenValue;
+        this.note = note;
+    }
+
+    public String getNote() {
+        return note;
+    }
+
+    public int getValue() {
+        return value;
+    }
+
+    public static String getNoteByValue(int givenValue) {
+        for (EM_BATTERY_STATE enumType : EM_BATTERY_STATE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+    public static int getValueByNote(String givenNote) {
+        for (EM_BATTERY_STATE enumType : EM_BATTERY_STATE.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_BATTERY_TEMPER_STATE.java

@@ -0,0 +1,56 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+/**
+ * @author 251823
+ * @description 电池温度状态
+ * @date 2022/03/31
+ */
+public enum EM_BATTERY_TEMPER_STATE {
+	// 未知
+    EM_BATTERY_TEMPER_STATE_UNKNOWN(0, "未知"),
+	// 低温
+    EM_BATTERY_TEMPER_STATE_LOW_TEMPER(1, "低温"),
+	// 常温
+    EM_BATTERY_TEMPER_STATE_NORMAL_TEMPER(2, "常温"),
+	// 高温
+    EM_BATTERY_TEMPER_STATE_HIGH_TEMPER(3, "高温"),
+	// 超温
+    EM_BATTERY_TEMPER_STATE_OVER_TEMPER(4, "超温"),
+	// 异常
+    EM_BATTERY_TEMPER_STATE_ABNORMAL_TEMPER(5, "异常");
+
+	private int value;
+	private String note;
+
+	private EM_BATTERY_TEMPER_STATE(int givenValue, String note) {
+		this.value = givenValue;
+		this.note = note;
+	}
+
+	public String getNote() {
+		return note;
+	}
+
+	public int getValue() {
+		return value;
+	}
+
+	public static String getNoteByValue(int givenValue) {
+		for (EM_BATTERY_TEMPER_STATE enumType : EM_BATTERY_TEMPER_STATE.values()) {
+			if (givenValue == enumType.getValue()) {
+				return enumType.getNote();
+			}
+		}
+		return null;
+	}
+
+	public static int getValueByNote(String givenNote) {
+		for (EM_BATTERY_TEMPER_STATE enumType : EM_BATTERY_TEMPER_STATE.values()) {
+			if (givenNote.equals(enumType.getNote())) {
+				return enumType.getValue();
+			}
+		}
+		return -1;
+	}
+}
+

src/main/java/com/inspect/nvr/daHuaCarme/jna/dahua/enumeration/EM_BEARD_STATE_TYPE.java

@@ -0,0 +1,30 @@
+package com.inspect.nvr.daHuaCarme.jna.dahua.enumeration;
+
+
+import com.inspect.nvr.daHuaCarme.jna.NetSDKLib;
+
+/**
+ * 胡子状态
+ * 
+ * @author ： 260611
+ * @since ： Created in 2021/10/19 20:21
+ */
+public class EM_BEARD_STATE_TYPE extends NetSDKLib.SdkStructure {
+    /**
+     *  未知
+     */
+    public static final int   EM_BEARD_STATE_UNKNOWN = 0;
+    /**
+     *  未识别
+     */
+    public static final int   EM_BEARD_STATE_NODISTI = 1;
+    /**
+     *  没胡子
+     */
+    public static final int   EM_BEARD_STATE_NOBEARD = 2;
+    /**
+     *  有胡子
+     */
+    public static final int   EM_BEARD_STATE_HAVEBEARD = 3;
+}
+