C6 不拍照

libs/win6422/AccessControl_SDK.h

@@ -0,0 +1,204 @@
+#include "dhnetsdk.h"
+#include "dhnetsdkEx.h"
+#ifndef _AC_DLL_H_
+#define _AC_DLL_H_
+
+#if defined(WIN32) || defined(_WIN32) || defined(_WIN64)
+#ifdef DLL_EXPORT
+#define GENERAL_API  __declspec(dllexport)
+#elif defined(DLL_USE)
+#define GENERAL_API  __declspec(dllimport)
+#else
+#define GENERAL_API
+#endif
+
+#include "windows.h"
+#define CALL_METHOD     _cdecl//WINAPI
+#define CALLBACK	_stdcall
+
+#else
+#define GENERAL_API	extern "C"
+#define CALL_METHOD
+#endif
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#ifdef __OBJC__
+#include "objc/objc.h"
+#else
+#define BOOL    int
+#endif
+
+#ifndef TRUE
+#define TRUE        1
+#endif
+
+#ifndef FALSE
+#define FALSE       0
+#endif
+
+// 登录回调
+typedef void (CALLBACK *fConnectCallback)(const char* szOutParam, void* pUser);
+
+
+// 门禁报警回调
+typedef void (CALLBACK *fAlarmInfoCallback)(const char* szOutParam, void* pUser);
+
+// 初始化SDK
+GENERAL_API BOOL CALL_METHOD Init(fConnectCallback  cb, void* pUser);
+
+
+// 释放SDK资源
+GENERAL_API void CALL_METHOD Cleanup();
+
+// 登录接口
+GENERAL_API BOOL CALL_METHOD Login(const char* szInParam, char* szOutParam, int nOutBufSize);
+
+// 登出接口
+GENERAL_API BOOL CALL_METHOD Logout(const char* szInParam, char* szOutParam, int nOutBufSize);
+
+// 修改设备密码
+GENERAL_API BOOL CALL_METHOD ModifyPassword(const char* szInParam, char* szOutParam, int nOutBufSize);
+
+// 获取设备时间
+GENERAL_API BOOL CALL_METHOD GetTime(const char* szInParam, char* szOutParam, int nOutBufSize);
+
+// 设置设备时间
+GENERAL_API BOOL CALL_METHOD SetTime(const char* szInParam, char* szOutParam, int nOutBufSize);
+
+// 获取设备信息
+GENERAL_API BOOL CALL_METHOD GetDeviceInfo(const char* szInParam, char* szOutParam, int nOutBufSize);
+
+// 获取门禁配置
+GENERAL_API BOOL CALL_METHOD GetDeviceDoorConfig(const char* szInParam, char* szOutParam, int nOutBufSize);
+
+// 设置门禁配置
+GENERAL_API BOOL CALL_METHOD SetDeviceDoorConfig(const char* szInParam, char* szOutParam, int nOutBufSize);
+
+// 设置时间表配置
+GENERAL_API BOOL CALL_METHOD SetTimeScheduleConfig(const char* szInParam, char* szOutParam, int nOutBufSize);
+
+// 设置时间表配置
+GENERAL_API BOOL CALL_METHOD GetTimeScheduleConfig(const char* szInParam, char* szOutParam, int nOutBufSize);
+
+// 门禁人员信息操作
+GENERAL_API BOOL CALL_METHOD OperateUserInfo(const char* szInParam, char* szOutParam, int nOutBufSize);
+
+// 門禁指紋信息操作
+GENERAL_API BOOL CALL_METHOD OperateFingerPrintInfo(const char* szInParam, char* szOutParam, int nOutBufSize);
+
+// 门禁人脸信息操作
+GENERAL_API BOOL CALL_METHOD OperateFaceInfo(const char* szInParam, char* szOutParam, int nOutBufSize);
+
+//设置假日表
+GENERAL_API BOOL CALL_METHOD SetHolidayScheduleConfig(const char* szInParam, char* szOutParam, int nOutBufSize);
+
+// 获取假日表
+GENERAL_API BOOL CALL_METHOD GetHolidayScheduleConfig(const char* szInParam, char* szOutParam, int nOutBufSize);
+
+// 门禁卡信息操作
+GENERAL_API BOOL CALL_METHOD OperateCardInfo(const char* szInParam, char* szOutParam, int nOutBufSize);
+
+// 查询门状态
+GENERAL_API BOOL CALL_METHOD QueryDoorStatus(const char* szInParam, char* szOutParam, int nOutBufSize);
+
+//// 门为对象 设置周计划
+//BOOL SetDoorWeekPlanConfig(String InParam, String OutParam);
+//
+//// 门为对象 获取周计划
+//BOOL GetDoorWeekPlanConfig(String InParam, String OutParam);
+
+// 人为对象的周计划 暂时未实现
+////////////////////////////////////////
+
+//
+//// 设置假日组
+//BOOL SetHolidayGroupConfig(String InParam, String OutParam);
+//
+//// 获取假日组
+//BOOL GetHolidayGroupConfig(String InParam, String OutParam);
+
+
+// 人为对象的假日计划 暂时未实现
+////////////////////////////////////////
+
+// 门为对象 设置假日计划
+//BOOL SetDoorHolidayPlanConfig(String InParam, String OutParam);
+//
+//// 门为对象 获取假日计划
+//BOOL GetDoorHolidayPlanConfig(String InParam, String OutParam);
+//
+//// 设置开门方式
+//BOOL SetOpenDoorType(String InParam, String OutParam);
+//
+//// 获取开门方式
+//BOOL GetOpenDoorType(String InParam, String OutParam);
+//
+//// 设置多人多卡开门
+//BOOL SetOpenDoorGroupConfig(String InParam, String OutParam);
+//
+//// 获取多人多卡开门
+//BOOL GetOpenDoorGroupConfig(String InParam, String OutParam);
+//
+//// 设置 互锁联动门首卡开门 
+//BOOL SetDoorInterlockFirstEnterConfig(String InParam, String OutParam);
+//
+//// 获取 互锁联动门首卡开门 
+//BOOL SetDoorInterlockFirstEnterConfig(String InParam, String OutParam);
+//
+//// 设置 普通门双门互锁
+//BOOL SetInterLockConfig(String InParam, String OutParam);
+//
+//// 获取 普通门双门互锁
+//BOOL GetInterLockConfig(String InParam, String OutParam);
+//
+//// 设置 金库开门配置
+//BOOL SetFirstOpenVaultConfig(String InParam, String OutParam);
+//
+//// 获取 金库开门配置
+//BOOL GetFirstOpenVaultConfig(String InParam, String OutParam);
+//
+//// 金库远程开门
+//BOOL RemoteOpenDoor (String InParam, String OutParam);
+
+//
+//// 门禁卡操作
+//BOOL OperateCardInfo(String InParam, String OutParam);
+//
+//
+//// 门禁指纹操作
+//BOOL OperateFingerprintInfo(String InParam, String OutParam);
+//
+//// 门禁人脸操作
+//BOOL OperateFaceInfo(String InParam, String OutParam);
+//
+//// 门禁报警  设置回调函数，接收门禁设备报警消息
+//BOOL SetMessageCallBack(fAlarmInfoCallback cbFun, void* pUser);
+//
+//// 门禁报警  开始订阅门禁设备消息
+//BOOL StartSubscribeDeviceMessage(String InParam, String OutParam);
+//
+//// 门禁报警  停止订阅门禁设备消息
+//BOOL StopSubscribeDeviceMessage (String InParam, String OutParam);
+//
+//// 开门信息查询
+//BOOL QueryOpenDoorInfo(String InParam, String OutParam);
+//
+//// 门禁状态查询
+//BOOL QueryDoorStatus(String InParam, String OutParam);
+//
+//
+//// 设置 开门时间外的开门配置
+//BOOL SetOutTimeDoorConfig(String InParam, String OutParam);
+//
+//// 获取 开门时间外的开门配置
+//BOOL GetOutTimeDoorConfig(String InParam, String OutParam);
+
+
+#ifdef __cplusplus
+};	//extern "C"
+#endif
+#endif

libs/win6422/HeatMap.h

@@ -0,0 +1,68 @@
+#ifndef _HEATMAP_H__
+#define _HEATMAP_H__
+
+#ifdef WIN32
+	#if defined(HEATMAP_EXPORTS)
+		#define HEATMAP_API __declspec(dllexport)
+	#else
+		#define HEATMAP_API __declspec(dllimport)
+	#endif
+	#define CALLMETHOD __stdcall
+#else 
+	#define HEATMAP_API
+	#define CALLMETHOD 
+#endif
+
+#ifndef HEATMAP_API
+#define HEATMAP_API
+#endif
+
+#ifdef	__cplusplus
+extern "C" {
+#endif
+
+	//Bmp位图信息
+	typedef struct bmpImageInfo
+	{
+		unsigned char *pBuffer;			//Bmp图片数据指针
+		int nWidth;						//图片宽度
+		int nHeight;					//图片高度
+		int nBitCount;					//图片位数,支持8位，24位，32位
+		int nDirection;                 //数据存储方向 0：从上到下，从左到右， 1：从下到上，从左到右
+	}BMPIMAGE_INFO;
+
+	///输入数据信息
+	typedef struct heatMapInfoIn
+	{
+		BMPIMAGE_INFO stuGrayBmpInfo;		//8位Bmp灰度热度图数据：不包含图片头，数据存储方向从上到下
+		BMPIMAGE_INFO stuBkBmpInfo;			//背景图Bmp位图数据：包含图片头，存储方向从下到上
+	}HEATMAP_IMAGE_IN;
+	
+	//输出数据信息
+	typedef struct heatMapInfoOut
+	{
+		unsigned char *pBuffer;				 //输出的彩色热度图数据（包含图片头）,宽高、位数和背景图相同
+		int		nPicSize;					 //图片内存大小(包含头) ：宽*高*nBitCount/8 + 54
+		float  fOpacity;					 //透明度,范围0-1
+	}HEATMAP_IMAGE_Out;
+
+	///\brief 生成热度图数据信息
+	/// param [in] stuBmpInfoIn       Bmp位图数据输入
+	/// param [in] stuBmpInfoOut      Bmp位图数据输出,包含图片头
+	/// param [out] true or false
+	HEATMAP_API bool CALLMETHOD CreateHeatMap(const HEATMAP_IMAGE_IN *stuBmpInfoIn, HEATMAP_IMAGE_Out *stuBmpInfoOut);
+
+	///\brief 将网络二进制数据转化成灰度数据
+	/// param [in] srcData       二进制数据
+	/// param [in] width      宽
+	/// param [in] height       高
+	/// param [in] resultOut      灰度数据
+	/// param [out] true or false
+	HEATMAP_API bool CALLMETHOD TransNetDataToGrayData(unsigned char * srcData, int width, int height, unsigned char * resultOut);;
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif  //_HEATMAP_H__

libs/win6422/IvsDrawer.h

@@ -0,0 +1,706 @@
+#ifndef IVS_DRAWER_H
+#define IVS_DRAWER_H
+
+#include <time.h>
+
+#ifdef _WIN32
+#define IVSDRAWER_API
+#define CALLMETHOD __stdcall
+#else
+#define IVSDRAWER_API
+#define CALLMETHOD
+#endif
+
+#ifdef _WIN32 
+#include <windows.h>
+#define IVS_BOOL        BOOL
+#define IVS_WND_REF 	HWND
+#define IVS_DC_REF		HDC
+#define IVS_COLOR		COLORREF
+#define IVS_RECT		RECT
+typedef POINT			IVSPOINT;
+#else
+#define IVS_BOOL        int
+#define IVS_WND_REF     void*
+#define IVS_DC_REF      void*
+
+typedef struct __IVS_MAC_WND
+{
+    int nWidth;
+    int nHeight;
+}IVS_WND;
+
+typedef struct __IVS_COLOR
+{
+    float cgred;
+    float cggreen;
+    float cgblue;
+}IVS_COLOR;
+
+typedef struct __IVSPOINT
+{
+    float x;
+    float y;
+}IVSPOINT;
+
+typedef struct __IVS_RECT
+{
+    float left;
+    float bottom;
+    float right;
+    float top;
+}IVS_RECT;
+#endif
+
+#ifdef _WIN32
+  #define INT64           __int64
+#else
+	#define DWORD       unsigned int
+	#define INT64       long long
+#endif
+
+typedef enum
+{
+	SHOW_NONE = 0,
+	SHOW_RULE = (1 << 0),
+	SHOW_ALARM = (1 << 1),
+	SHOW_TRACK = (1 << 2),
+	SHOW_ALL = (SHOW_RULE | SHOW_ALARM | SHOW_TRACK),
+}SHOW_TYPE;
+
+typedef enum
+{
+	DRAW_JSON = 0,
+	DRAW_TRACK,
+	DRAW_ALARM,
+	DRAW_RULE,
+	DRAW_ALARMRULE,
+	DRAW_ALARMEX,
+	DRAW_TRACKEX,
+	DRAW_MOVE_CHECK,
+	DRAW_TEST = 9,
+	DRAW_WEB_RULE = 11,
+	DRAW_WEB_ALARM,
+	DRAW_FLOW_INFO,
+	DRAW_TRACKEX2,
+	DRAW_WUXI235_TRACKEX2,
+	DRAW_TRACKEXA1,
+	DRAW_TRACKEX2_TYPE_HUMAN,
+	DRAW_TRACKEX2_TYPE_VEHICLE,
+	DRAW_TRACKEX2_TYPE_NONMOTOR,
+	DRAW_TRACKEX2_TYPE_SHOPPRESENCE, 
+	DRAW_TRACKEX2_TYPE_FLOWBUSINESS,
+	DRAW_INTELFLOW,
+	DRAW_SMARTMOTION,
+	DRAW_END,
+}DRAW_TYPE;
+
+typedef enum
+{
+	IVS_LINGER = 0,				 
+	IVS_TRACKTAIL,				// 轨迹尾巴
+	IVS_GET_OBJECT,
+	IVS_DISABLE_VIDEO_TIME,		// 禁止视频浓缩的时间，默认开启
+	IVS_DISABLE_VIDEO_OBJECT,
+	IVS_TRACK_OBJECT = 6,
+	IVS_SET_PEN_HEIGHT,
+	IVS_TRACK_OBJECT_EX = 8,
+}IVS_CMD_TYPE;
+
+typedef enum
+{
+    DRAW_PEN_DEFAULT = -1,
+    DRAW_PEN_SOLID = 0,
+    DRAW_PEN_DASH,                        
+    DRAW_PEN_DOT,             
+    DRAW_PEN_DASHDOT,         
+    DRAW_PEN_DASHDOTDOT,       
+    DRAW_PEN_NULL,             
+    DRAW_PEN_INSIDEFRAME,     
+    DRAW_PEN_USERSTYLE,        
+    DRAW_PEN_ALTERNATE,        
+}DRAW_PEN_STYLE;
+
+#define IVS_MAX_ACTION_NUM		4
+#define IVS_MAX_EVENT_NUM       64
+#define IVS_MAX_POLYLINE_NUM	32
+#define IVS_MAX_OBJECT_NUM		64
+#define IVS_NAME_NUM		    128
+
+// 二维空间点
+typedef struct 
+{
+	short            nx;
+	short            ny;
+} DH_IVS_SPOINT, *LPDH_IVS_SPOINT;
+
+// 物体对应图片文件信息
+typedef struct  
+{
+	DWORD           dwOffSet;                       // 文件在二进制数据块中的偏移位置, 单位:字节
+	DWORD           dwFileLenth;                    // 文件大小, 单位:字节
+	WORD            wWidth;                         // 图片宽度, 单位:像素
+	WORD            wHeight;                        // 图片高度, 单位:像素
+	char*           pszFilePath;                    // 鉴于历史原因,该成员只在事件上报时有效
+	// 文件路径
+	// 用户使用该字段时需要自行申请空间进行拷贝保存
+	BYTE            bIsDetected;                    // 图片是否算法检测出来的检测过的提交识别服务器时,
+	// 则不需要再时检测定位抠图,1:检测过的,0:没有检测过
+	BYTE			bReserved[3];					// 预留字节数
+	int				nFilePathLen;					// 文件路径长度 既pszFilePath 用户申请的大小
+	DH_IVS_SPOINT	stuPoint;						// 小图左上角在大图的位置，使用绝对坐标系				
+}DH_IVS_PIC_INFO;
+
+typedef struct tagDH_IVS_TIME_EX
+{
+	DWORD                dwYear;                  // 年
+	DWORD                dwMonth;                 // 月
+	DWORD                dwDay;                   // 日
+	DWORD                dwHour;                  // 时
+	DWORD                dwMinute;                // 分
+	DWORD                dwSecond;                // 秒
+	DWORD                dwMillisecond;           // 毫秒
+	DWORD                dwUTC;                   // utc时间(获取时0表示无效，非0有效   下发无效)
+	DWORD				 dwReserved[1];			  // 预留字段
+} DH_IVS_TIME_EX,*LPDH_IVS_TIME_EX;
+// 区域；各边距按整长8192的比例
+typedef struct 
+{
+	long             left;
+	long             top;
+	long             right;
+	long             bottom;
+} DH_IVS_LRECT, *LPDH_IVS_LRECT;
+
+#pragma pack(push)
+#pragma pack(4)
+// 视频分析物体信息结构体
+typedef struct 
+{
+	int                 nObjectID;                          // 物体ID,每个ID表示一个唯一的物体
+	char                szObjectType[128];                  // 物体类型
+	int                 nConfidence;                        // 置信度(0~255),值越大表示置信度越高
+	int                 nAction;                            // 物体动作:1:Appear 2:Move 3:Stay 4:Remove 5:Disappear 6:Split 7:Merge 8:Rename
+	DH_IVS_LRECT         BoundingBox;                        // 包围盒
+	DH_IVS_SPOINT        Center;                             // 物体型心
+	int                 nPolygonNum;                        // 多边形顶点个数
+	DH_IVS_SPOINT        Contour[16];						// 较精确的轮廓多边形
+	DWORD               rgbaMainColor;                      // 表示车牌、车身等物体主要颜色；按字节表示,分别为红、绿、蓝和透明度,例如:RGB值为(0,255,0),透明度为0时, 其值为0x00ff0000.
+	char                szText[128];                        // 物体上相关的带0结束符文本,比如车牌,集装箱号等等
+	char                szObjectSubType[62];                // 物体子类别,根据不同的物体类型,可以取以下子类型：
+	WORD                wColorLogoIndex;                    // 车标索引
+	WORD                wSubBrand;                          // 车辆子品牌 需要通过映射表得到真正的子品牌 映射表详见开发手册
+	BYTE                byReserved1;                     
+	bool                bPicEnble;                          // 是否有物体对应图片文件信息
+	DH_IVS_PIC_INFO     stPicInfo;                          // 物体对应图片信息
+	bool                bShotFrame;                         // 是否是抓拍张的识别结果
+	bool                bColor;                             // 物体颜色(rgbaMainColor)是否可用
+	BYTE                byReserved2;
+	BYTE                byTimeType;                         // 时间表示类型,详见EM_TIME_TYPE说明
+	DH_IVS_TIME_EX     stuCurrentTime;                     // 针对视频浓缩,当前时间戳（物体抓拍或识别时,会将此识别智能帧附在一个视频帧或jpeg图片中,此帧所在原始视频中的出现时间）
+	DH_IVS_TIME_EX     stuStartTime;                       // 开始时间戳（物体开始出现时）
+	DH_IVS_TIME_EX     stuEndTime;                         // 结束时间戳（物体最后出现时）
+	DH_IVS_LRECT         stuOriginalBoundingBox;             // 包围盒(绝对坐标)
+	DH_IVS_LRECT         stuSignBoundingBox;                 // 车标坐标包围盒
+	DWORD               dwCurrentSequence;                  // 当前帧序号（抓下这个物体时的帧）
+	DWORD               dwBeginSequence;                    // 开始帧序号（物体开始出现时的帧序号）
+	DWORD               dwEndSequence;                      // 结束帧序号（物体消逝时的帧序号）
+	INT64               nBeginFileOffset;                   // 开始时文件偏移, 单位: 字节（物体开始出现时,视频帧在原始视频文件中相对于文件起始处的偏移）
+	INT64               nEndFileOffset;                     // 结束时文件偏移, 单位: 字节（物体消逝时,视频帧在原始视频文件中相对于文件起始处的偏移）
+	BYTE                byColorSimilar[8];					// 物体颜色相似度,取值范围：0-100,数组下标值代表某种颜色,详见EM_COLOR_TYPE
+	BYTE                byUpperBodyColorSimilar[8];			// 上半身物体颜色相似度(物体类型为人时有效)
+	BYTE                byLowerBodyColorSimilar[8];			// 下半身物体颜色相似度(物体类型为人时有效)
+	int                 nRelativeID;                        // 相关物体ID
+	char                szSubText[20];                      // "ObjectType"为"Vehicle"或者"Logo"时,表示车标下的某一车系,比如奥迪A6L,由于车系较多,SDK实现时透传此字段,设备如实填写。
+	WORD                wBrandYear;                         // 车辆品牌年款 需要通过映射表得到真正的年款 映射表详见开发手册
+} DH_IVS_OBJECT_INFO;
+#pragma pack(pop)
+
+typedef struct IVS_CONFIG_EVENT
+{
+	char					szEventName[IVS_NAME_NUM];			// 事件名称，详见"事件类型列表"
+	char					szRuleName[IVS_NAME_NUM];			// 规则名称，不同规则不能重名
+	DH_IVS_OBJECT_INFO		stuObject;
+	char					Context[28];
+	int						alarmAction;					    // 与NetSDK定义一致
+	int						alarmType;
+}IVS_CONFIG_EVENT_INFO;
+
+typedef struct IVS_CONFIG_EVENTEX
+{
+	char					szEventName[IVS_NAME_NUM];			// 事件名称，详见"事件类型列表"
+	char					szRuleName[IVS_NAME_NUM];			// 规则名称，不同规则不能重名
+	char					Context[28];					
+	int						alarmAction;					    // 与NetSDK定义一致
+	int						alarmType;
+	int						nObjectNum;
+	DH_IVS_OBJECT_INFO		stuObject[IVS_MAX_OBJECT_NUM];		    // 检测到的物体
+	int						nContext;                           // 该字段未用，作为大类字段
+	void*					pContext;
+}IVS_CONFIG_EVENT_INFOEX;
+
+typedef struct 
+{
+	int						nEventsNum;							// 视频分析规则数
+	IVS_CONFIG_EVENT_INFO	stuEventInfo[IVS_MAX_EVENT_NUM];    // 事件信息
+}IVS_CFG_ANALYSEVENTS_INFO;
+
+typedef struct 
+{
+	int						nEventsNum;							// 视频分析规则数
+	IVS_CONFIG_EVENT_INFOEX stuEventInfo[IVS_MAX_EVENT_NUM];    // 事件信息
+}IVS_CFG_ANALYSEVENTS_INFOEX;
+
+typedef struct
+{
+	int						nX;                                 // 8192坐标系
+	int						nY;		
+}IVS_CFG_POLYLINE;
+
+typedef struct  __IVS_WEB_RULE
+{
+	int						size;
+	int						nRuleType;
+	int						nRuleEnable;
+	int						ndirect1;
+	int						ndirect2;
+	int						nPoint1;
+	int						nPoint2;
+	unsigned char			bActionType[4];
+	DH_IVS_OBJECT_INFO		objectMsg;
+	char					szRuleName[IVS_NAME_NUM];
+	IVS_CFG_POLYLINE		stuDetectLine1[IVS_MAX_POLYLINE_NUM];	//Line
+	IVS_CFG_POLYLINE		stuDetectLine2[IVS_MAX_POLYLINE_NUM];	//Region	
+	int                     nRuleID;
+	IVS_CFG_POLYLINE		stuDirectionLine[2];					//Direction
+	char					szRevered[236];
+}IVS_WEB_RULE;
+
+typedef struct __IVS_WEB_RULE_ARRAY
+{
+	int					    size;
+	int					    nCount;
+	IVS_WEB_RULE*		    pRule;
+}IVS_WEB_RULE_ARRAY;
+
+typedef struct
+{
+	int					objectid;
+	struct tm			startTime;
+	struct tm			endTime;
+	INT64				nBeginFileOffset;				// 开始时文件偏移字节数(物体开始出现时，视频帧在原始视频文件中相对于文件起始处的偏移)
+	INT64				nEndFileOffset;					// 结束时文件偏移字节数(物体消逝时，视频帧在原始视频文件中相对于文件起始处的偏移)
+	int					classid;
+}IVSOBJECT;
+
+typedef struct
+{
+	IVS_BOOL            trackex2objtype;                // 是否显示物体类型，0:否，1:显示，默认不显示
+    IVS_BOOL            trackex2attribute88;            // 是否显示0x88属性包，0:否，1:显示，默认显示
+    IVS_BOOL            trackex2objid;                  // 是否显示物体ID，0:否，1:显示，默认不显示
+    IVS_BOOL            trackex2humanage;	            // 是否显示具体年龄，0:显示年龄段，1:显示年龄，默认显示年龄段
+}TrackEx2Configure;
+
+typedef union
+{
+	IVSOBJECT			object;
+	IVSPOINT			xPt;
+	char				szReverd[128];
+}ObjectContex;
+
+typedef struct _DH_IVS_POINT
+{
+/*************************************************
+** 轨迹点是物体外接矩形的中心
+** 根据X,Y及XSize,YSize计算出的物体外接矩形坐标为
+** (X-XSize, Y-YSize, X+XSize, Y+YSize)
+**************************************************/
+	short 		x; 
+	short 		y; 
+	short		xSize;
+	short		ySize;
+}DH_IVS_POINT; 
+
+typedef struct  _RuleColor
+{
+	int ruletype;
+	IVS_COLOR crColor;		
+}RuleColor;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * 启动IVSDraw(只调用一次)依赖IvsDrawer解析json数据时调用
+ */
+IVSDRAWER_API int CALLMETHOD DRAW_Startup();
+
+/**
+ * 退出IVSDraw
+ */
+IVSDRAWER_API void CALLMETHOD DRAW_Cleanup();
+
+/**
+ * 打开作图端口
+ *
+ * @param[in] nPort 作图端口
+ * @return BOOL，成功返回TRUE，失败返回FALSE
+ */
+IVSDRAWER_API BOOL CALLMETHOD DRAW_Open(int nPort);
+
+/**
+ * 关闭作图端口
+ *
+ * @param[in] nPort 作图端口
+ */
+IVSDRAWER_API void CALLMETHOD DRAW_Close(int nPort);
+
+/**
+ * 重置作图端口
+ *
+ * @param[in] nPort 作图端口
+ * @param[in] nType  详见DRAW_TYPE定义，仅DRAW_TRACK,DRAW_ALARM,DRAW_RULE有效
+ * @return BOOL，成功返回TRUE，失败返回FALSE
+ */
+IVSDRAWER_API BOOL CALLMETHOD DRAW_Reset(int nPort, int nType);
+
+/**
+ * 输入jason格式字符串数据，原始数据未经过解析
+ *
+ * @param[in] nPort 作图端口
+ * @param[in] pJsonData 数据内存地址
+ * @param[in] nDataLen 数据长度
+ * @param[in] nPort 作图端口
+ * @param[in] nFrameSeq 帧序号
+ * @return int，成功返回0，不成功返回-1
+ */
+IVSDRAWER_API int CALLMETHOD DRAW_InputJsonData(int nPort, unsigned char* pJsonData, int nDataLen, int nFrameSeq);
+
+/**
+ * 设置规则颜色
+ *
+ * @param[in] nPort 作图端口
+ * @param[in] nRuleColor 规则名称和规则颜色
+ * @param[in] nRuleNum 规则数
+ * @return int，成功返回0，不成功返回-1
+ */
+IVSDRAWER_API int CALLMETHOD DRAW_SetRuleColor(int nPort,RuleColor* nRuleColor, int nRuleNum);
+
+/**
+ * 输入规则数据，经过jason解析
+ *
+ * @param[in] nPort 作图端口
+ * @param[in] nType 目前没有用到此字段
+ * @param[in] pRuleData 数据内存地址
+ * @param[in] nframe 帧序号
+ * @return int，成功返回0，不成功返回-1
+ */
+IVSDRAWER_API int CALLMETHOD DRAW_InputRuleData(int nPort, int nType, unsigned char* pRuleData, int nframe);
+
+/**
+ * 输入轨迹数据，对应智能分析轨迹帧0xF1(表示辅助帧)0x05(轨迹帧数据)
+ *
+ * @param[in] nPort 作图端口
+ * @param[in] nType 目前没有用到此字段
+ * @param[in] pTrackData 数据内存地址
+ * @param[in] nDataLen 数据长度
+ * @param[in] nFrameSeq 帧序号
+ * @return int，成功返回0，不成功返回-1
+ */
+IVSDRAWER_API int CALLMETHOD DRAW_InputTrackData(int nPort, int nType, unsigned char* pTrackData, int nDataLen,int nFrameSeq);
+
+/**
+ * 输入轨迹数据，智能结构化信息帧0xF1(表示辅助帧)0x0E(结构化数据)或者NVR浓缩信息轨迹点
+ *
+ * @param[in] nPort 作图端口
+ * @param[in] nType nType=7表示智能结构化帧，nType=19表示智能客流，否则表示NVR浓缩信息轨迹点
+ * @param[in] pTrackData 数据内存地址
+ * @param[in] nDataLen 数据长度
+ * @param[in] nFrameSeq 帧序号
+ * @return int，成功返回0，不成功返回-1
+ */
+IVSDRAWER_API int CALLMETHOD DRAW_InputTrackDataEx2(int nPort, int nType, unsigned char* pTrackData, int nDataLen,int nFrameSeq);
+
+/**
+ * 输入警报数据，经过jason解析
+ *
+ * @param[in] nPort 作图端口
+ * @param[in] nType 目前没有用到此字段
+ * @param[in] pAlarmData 数据内存地址
+ * @param[in] nDataLen 数据长度
+ * @return int，成功返回0，不成功返回-1
+ */
+IVSDRAWER_API int CALLMETHOD DRAW_InputAlarmData(int nPort, int nType, unsigned char* pAlarmData, int nDataLen);
+
+/**
+ * 输入警报数据，经过jason解析，与DRAW_InputAlarmData的差异在于数据结构不同
+ *
+ * @param[in] nPort 作图端口
+ * @param[in] nType 目前没有用到此字段
+ * @param[in] pAlarmData 数据内存地址
+ * @param[in] nDataLen 数据长度
+ * @return int，成功返回0，不成功返回-1
+ */
+IVSDRAWER_API int CALLMETHOD DRAW_InputAlarmDataEx(int nPort, int nType, unsigned char* pAlarmData, int nDataLen);
+
+/**
+ * 输入动检信息数据
+ *
+ * @param[in] nPort 作图端口
+ * @param[in] nType 目前没有用到此字段
+ * @param[in] pData 动检信息数据
+ * @param[in] nDataLen 数据长度
+ * @param[in] nFrameSeq 帧序号
+ * @return int，成功返回0，不成功返回-1
+ */
+IVSDRAWER_API int CALLMETHOD DRAW_InputMoveCheckData(int nPort, int nType, unsigned char* pData, int nDataLen, int nFrameSeq);
+
+/**
+ * 指定位置显示一串字符串（可多行，以\n结尾）
+ *
+ * @param[in] nPort 作图端口
+ * @param[in] pTextData 数据地址
+ * @param[in] nTextNumPos pTextData数据对应的结构体个数
+ * @return int，成功返回0，不成功返回-1
+ */
+typedef struct
+{
+    const char* pText;  // 显示的字符串
+	IVSPOINT hPos;      // 显示位置
+	int nFontsize;      // 字体大小
+	int nRed;           // 字体颜色
+	int nGreen;         // 字体颜色
+	int nBlue;          // 字体颜色
+    int nAlignMode;     // 对齐方式，0：左对齐，1：居中对齐，2：右对齐
+}TextData;
+IVSDRAWER_API int CALLMETHOD DRAW_InputTextData(int nPort, TextData* pTextData, int nTextNumPos);
+
+/**
+ * 执行作图操作
+ *
+ * @param[in] nPort 作图端口
+ * @param[in] hDC 作图设备句柄
+ * @param[in] hWnd 窗口句柄
+ * @param[in] nFrameSeq 帧序号
+ * @return int，成功返回0，不成功返回-1
+ */
+IVSDRAWER_API int CALLMETHOD DRAW_Draw(int nPort, IVS_DC_REF hDC, IVS_WND_REF hWnd, int nFrameSeq);
+
+/**
+ * 设置生存时间
+ *
+ * @param[in] nPort 作图端口
+ * @param[in] nType  详见DRAW_TYPE
+ * @param[in] nLifeCount 生存时间
+ * @return int，成功返回0，不成功返回-1
+ */
+IVSDRAWER_API int CALLMETHOD DRAW_SetLifeCount(int nPort, int nType, int nLifeCount);
+
+/**
+ * 设置使能
+ *
+ * @param[in] nPort 作图端口
+ * @param[in] type 类型 参照DRAW_TYPE
+ * @param[in] bEnable 使能标记
+ * @return int，成功返回0，不成功返回-1
+ */
+IVSDRAWER_API int CALLMETHOD DRAW_SetEnable(int nPort, int nType, IVS_BOOL bEnable);
+
+/**
+ * 创建画笔
+ *
+ * @param[in] nPort 作图端口
+ * @param[in] nType 规则类型
+ * @param[in] nPenStyle 画笔格式(实线or虚线)，详见DRAW_PEN_STYLE
+ * @param[in] nWidth 画笔宽度
+ * @param[in] crColor 画笔颜色
+ * @return int，成功返回0，不成功返回-1
+ */
+IVSDRAWER_API int CALLMETHOD DRAW_SetPen(int nPort, int nType, int nPenStyle, int nWidth, IVS_COLOR crColor);
+
+/**
+ * 执行命令操作
+ *
+ * @param[in] nPort 作图端口
+ * @param[in] nCmdType 详见IVS_CMD_TYPE
+ * @param[in] pContext 仅当nCmdType为IVS_TRACK_OBJECT/IVS_TRACK_OBJECT_EX或IVS_GET_OBJECT，指向ObjectContex结构体
+ *                     其他指向int整型
+ * @param[in] nContextSize pContext对应的结构体大小
+ * @return int，成功返回0，不成功返回-1
+ */
+IVSDRAWER_API int CALLMETHOD DRAW_Ioctl(int nPort, int nCmdType, void* pContext, int nContextSize);
+
+/**
+ * 刷新帧序号
+ *
+ * @param[in] nPort 作图端口
+ * @param[in] nFrameSeq 帧序号
+ * @return int，成功返回0，不成功返回-1
+ */
+IVSDRAWER_API int CALLMETHOD DRAW_Refresh(int nPort, int nFrameSeq);
+
+/**
+ * 每调用一次，减少一次规则的生命周期(默认255)，减少到0时删除规则
+ *
+ * @param[in] nPort 作图端口
+ */
+IVSDRAWER_API void CALLMETHOD DRAW_Idle(int nPort);
+
+/**
+ * 清除作图内容
+ *
+ * @param[in] nPort 作图端口
+ * @param[in] nReserved 预留参数
+ */
+IVSDRAWER_API void CALLMETHOD DRAW_Clean(int nPort, int nReserved);
+
+/**
+ * 设置轨迹开始时间（视频浓缩）
+ *
+ * @param[in] nPort 作图端口
+ * @param[in] nTime 时间
+ * @param[in] nObjectId 物体ID
+ * @return int，成功返回0，不成功返回-1
+ */
+IVSDRAWER_API int CALLMETHOD DRAW_SetTime(int nPort, int nTime, int nObjectId);
+
+/**
+ * 设置显示类型，现有的类型有rule，alarm，track
+ *
+ * @param[in] nPort     作图端口
+ * @param[in] nShowType 详见SHOW_TYPE，可组合使用
+ */
+IVSDRAWER_API void CALLMETHOD DRAW_SetShowType(int nPort, int nShowType);
+
+/**
+ * 画track回调
+ *
+ * @param[in] nPort 作图端口
+ * @param[in] pCallBack 回调函数
+ * @param[in] pUserData 回调参数
+ */
+typedef void (CALLMETHOD* OnDrawOneTrack)(int nClassID, int nObjID, DH_IVS_POINT* pPoints, int nPointNum, void* pUserData);
+IVSDRAWER_API void CALLMETHOD DRAW_SetDrawOneTrackCallback(int nPort, OnDrawOneTrack pCallBack, void* pUserData);
+
+/**
+ * 翻译字符串回调
+ *
+ * @param[in] nPort 作图端口
+ * @param[in] pTranslateCBFunc 回调函数
+ * @param[in] pUserData 回调参数
+ */
+typedef int (CALLMETHOD* fTranslateCallback)(unsigned char* strSrc,int nSrsLen, unsigned char* strDst, int* nDstLen, void* pUserData);
+IVSDRAWER_API void CALLMETHOD DRAW_SetTranslateCallback(int nPort, fTranslateCallback pTranslateCBFunc, void* pUserData);
+
+/**
+ * 由此规则产生的track报警会被忽略
+ *
+ * @param[in] nPort 作图端口
+ * @param[in] pRuleName 规则名
+ * @param[in] bEnable 是否开启
+ */
+IVSDRAWER_API void CALLMETHOD DRAW_SetRuleTrackAlarm(int nPort, const char* pRuleName, bool bEnable);
+
+/**
+ * 设置track的显示规则
+ *
+ * @param[in] nPort 作图端口
+ * @param[in] nType: 0：显示所有track（默认方式），1：只显示有报警的track
+ */
+IVSDRAWER_API void CALLMETHOD DRAW_SetShowTrackType(int nPort, int nType);
+
+/**
+ * 设置帧序号
+ *
+ * @param[in] nPort 作图端口
+ * @param[in] nFrameSeq 帧序号
+ */
+IVSDRAWER_API void CALLMETHOD DRAW_SetFrameNum(int nPort, int nFrameSeq);
+
+/**
+ * 根据{大类ID, 物体ID}设置跟踪物体颜色, 形状
+ *
+ * @param[in] nPort 作图端口
+ * @param[in] nClassId 大类ID
+ * @param[in] nObjectId 物体ID
+ * @param[in] crColor 画笔颜色
+ * @param[in] bSpecialShape 1:特殊形状, 0:默认矩形
+ * @param[in] bSpecialSingle 1:只保留当前跟踪框的特殊形状，其他跟踪框回到默认形状 0：形状不变
+ * @return int，成功返回0，不成功返回-1
+ */
+IVSDRAWER_API int CALLMETHOD DRAW_SetTrackObjectColor(int nPort, int nClassId, int nObjectId, IVS_COLOR crColor, bool bSpecialShape, bool bSpecialSingle);
+
+/**
+ * 根据bSpecialShape标志，设置车辆识别跟踪框形状
+ *
+ * @param[in] nPort 作图端口
+ * @param[in] bSpecialShape 1:特殊形状, 0:默认矩形
+ * @return int，成功返回0，不成功返回-1
+ */
+IVSDRAWER_API int CALLMETHOD DRAW_SetTrackEX2Sharp(int nPort, bool bSpecialShape);
+
+/**
+ * 根据trackex2config的设置来显示某些字段，默认是不显示的
+ *
+ * @param[in] nPort 作图端口
+ * @param[in] trackex2config 控制是否显示某些字段
+ */
+IVSDRAWER_API void CALLMETHOD DRAW_SetTrackEx2Config(int nPort, TrackEx2Configure trackex2config);
+
+/**
+ * 根据bEnable控制规则名称是否显示，默认显示
+ *
+ * @param[in] nPort 作图端口
+ * @param[in] bEnable 控制字段
+ */
+IVSDRAWER_API void CALLMETHOD DRAW_SetRuleNameConfig(int nPort, bool bEnable);
+
+/**
+ * 清除配置数据
+ *
+ * @param[in] nPort 作图端口
+ * @param[in] nClearType 清除数据类型 详见IVS_CMD_TYPE
+ */
+IVSDRAWER_API void CALLMETHOD DRAW_ClearIVSConfigData(int nPort, int nClearType);
+
+/**
+ * 设置IVS的显示区域
+ *
+ * @param[in] nPort 作图端口
+ * @param[in] rectRegion 显示区域
+ * @param[in] bEnable 设置使能
+ */
+IVSDRAWER_API void CALLMETHOD DRAW_SetIVSDisplayRegion(int nPort, IVS_RECT *rectRegion, bool bEnable);
+
+/**
+ * NACL与IOS平台特有，设置窗口参数接口
+ *
+ * @param[in] nPort 作图端口
+ * @param[in] nX 窗口左下角X坐标
+ * @param[in] nY 窗口左下角Y坐标
+ * @param[in] nWidth 窗口矩形宽度
+ * @param[in] nHeight 窗口矩形高度
+ */
+IVSDRAWER_API void CALLMETHOD DRAW_SetDrawSurfaceParam(int nPort, int nX, int nY, int nWidth, int nHeight);
+
+/**
+ * MAC平台特有接口
+ * 外部设置显示比例（兼容Retina高清屏幕）
+ * @param[in] nPort 作图端口
+ * @param[in] scale 显示比例
+ */
+IVSDRAWER_API void CALLMETHOD DRAW_SetDisplayScale(int nPort, float scale);
+
+/**
+ * 无效接口
+ */
+IVSDRAWER_API int CALLMETHOD DRAW_GetLastError(int nPort);
+IVSDRAWER_API int CALLMETHOD DRAW_InputJpegData(int nPort, int nType, unsigned char* pJpegData, int nDataLen, int nFrameSeq);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

libs/win6422/StreamPackage.h

@@ -0,0 +1,225 @@
+// StreamPackage.h: interface for the StreamPackage class.
+//
+//////////////////////////////////////////////////////////////////////
+
+#if !defined(AFX_STREAMPACKAGE_H__014CF316_354F_47ED_B30D_D39912DD250D__INCLUDED_)
+#define AFX_STREAMPACKAGE_H__014CF316_354F_47ED_B30D_D39912DD250D__INCLUDED_
+
+#if (defined(WIN32) || defined(WIN64))
+	#define SG_PACKAGE_API	__declspec(dllimport)
+	#define CALLMETHOD			__stdcall
+	#define CALLBACK				__stdcall
+#else
+	#define CALLMETHOD
+	#define CALLBACK
+	#define SG_PACKAGE_API
+#endif
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*码流封装错误类型*/
+typedef enum
+{
+	SG_ERR_NOERR					= 0,			/*成功*/
+	SG_ERR_HANDLE_EMPTY,						/*句柄无效*/
+	SG_ERR_INIT_FAIL,								/*初始化失败*/
+	SG_ERR_PARAM_ERR,							/*参数错误*/
+}SG_ERR_TYPE;
+
+/*码流封装类型*/
+typedef enum
+{
+	SG_STREAM_TYPE_DAV_STREAM		= 19,			/* 封装格式 DAV */
+}SG_STREAM_TYPE;
+
+/*帧类型*/
+typedef enum
+{
+	SG_FRAME_TYPE_VIDEO		= 1,			/* 视频帧 */
+	SG_FRAME_TYPE_AUDIO,						/* 音频帧 */
+	SG_FRAME_TYPE_EXT							/* 大华扩展帧 */
+}SG_FRAME_TYPE;
+
+/*视频帧子类型*/
+typedef enum
+{
+	SG_FRAME_SUB_TYPE_I,										/* I帧 */
+	SG_FRAME_SUB_TYPE_P,										/* P帧 */
+	SG_FRAME_SUB_TYPE_B,										/* B帧 */
+	SG_FRAME_SUB_TYPE_JPEG_FRAME = 8,             /*JPEG 帧*/
+}SG_FRAME_SUB_TYPE;
+
+/*编码类型*/
+typedef enum
+{
+	SG_ENCODE_VIDEO_UNKNOWN		= 0,				/*视频编码格式不可知*/
+	SG_ENCODE_VIDEO_MPEG4 = 1 ,							/*视频编码格式是MPEG4*/
+	SG_ENCODE_VIDEO_JPEG = 3,							/*视频编码格式是标准JPEG*/
+	SG_ENCODE_VIDEO_H264 = 4,						/*视频编码格式是大华码流H264*/
+
+	SG_ENCODE_AUDIO_PCM				= 7,			/*音频编码格式是PCM8*/
+	SG_ENCODE_AUDIO_G711A			= 14,			/*音频编码格式是G711A*/
+	SG_ENCODE_AUDIO_PCM16			= 16,			/*音频编码格式是PCM16*/
+	SG_ENCODE_AUDIO_AAC				= 26,			/*音频编码格式是AAC*/
+	SG_ENCODE_AUDIO_MP2				= 31,			/*音频编码格式是MP2*/
+
+}SG_ENCODE_TYPE;
+
+/*解交错标志*/
+typedef enum
+{
+	SG_DEINTERLACE_NONE = 2,		/*无解交错*/
+}SG_DEINTERLACE_TYPE;
+
+/*加密类型*/
+typedef enum
+{
+	SG_ENCRYPT,
+}SG_ENCRYPT_TYPE;
+
+#pragma pack(1)
+
+/*文件头信息*/
+typedef struct 
+{
+	unsigned int struct_size;
+}SGHeaderInfo;
+
+/*文件尾信息*/
+typedef struct
+{
+	unsigned int struct_size;
+}SGTailerInfo;
+
+//帧数据信息
+typedef struct  
+{
+	unsigned int		struct_size;
+
+	unsigned char*		frame_pointer;		/*帧数据指针*/
+	unsigned int		frame_size;			/*帧数据长度*/
+	unsigned int		frame_type;			/*帧类型	SG_FRAME_TYPE*/
+	unsigned int		frame_sub_type;	/*帧子类型	SG_FRAME_SUB_TYPE*/
+	unsigned int		frame_encode;		/*编码类型	SG_ENCODE_TYPE*/
+	unsigned int		frame_time;			/*帧时间戳*/
+	unsigned int		frame_data;			/*日期时间，UTC时间*/
+
+	unsigned int		width;					/*视频宽度*/
+	unsigned int		heigth;					/*视频高度*/
+	unsigned int		frame_rate;			/*视频帧率*/
+	unsigned int		deinter_lace;			/*解交错信息 SG_DEINTERLACE_TYPE*/
+
+	unsigned int		sample_rate;			/*音频采样率*/
+	unsigned int		bit_per_sample;		/*音频采样位数*/
+	unsigned int		channels;				/*音频通道数*/
+	unsigned int		bit_rate;					/*音频比特率*/
+
+	unsigned char		rtp_channel;			/*通道号*/
+	unsigned char		reserved1[7];
+	unsigned int		frame_seq;				/*帧序号*/
+	unsigned char		reserved[152];			/*保留字段*/
+}SGFrameInfo;
+
+//数据输出信息
+typedef struct
+{
+	unsigned int		struct_size;
+
+	unsigned char*		data_pointer;		/*数据指针*/
+	int					data_size;			/*数据长度*/
+	int					offset_type;		/*数据偏移类型*/
+	unsigned int		offset_pos;			/*数据偏移位置*/
+}SGOutputData;
+
+typedef void* (*SGMalloc_t)(int memory_size);								/*内存分配函数*/
+typedef void  (*SGFree_t)(void* memory_pointer, int memory_size);			/*内存释放函数*/
+typedef void  (*SGDataCB_t)(SGOutputData* data, void* user);				/*数据输出回调函数*/
+
+//创建流封装器信息
+typedef struct  
+{
+	unsigned int		struct_size;
+	
+	void*				user;				/*用户自定义数据*/
+	SGMalloc_t			sg_malloc;			/*用户自定义内存分配函数指针*/
+	SGFree_t			sg_free;			/*用户自定义内存释放函数指针*/
+	SGDataCB_t			sg_datacb;			/*用户自定义数据输出回调函数指针*/
+}SGCreateParam;
+
+#pragma pack()
+
+/********************************************************************
+*	Funcname:			SG_CreateHandle
+*	Purpose:				创建流封装器
+*   InputParam:         nType : 码流封装类型  SG_STREAM_TYPE
+*								pCreateParam : 创建流封装器信息
+*   Return:					void* : 返回打包句柄， 失败返回NULL
+*   Created:				2013.11.28  
+*   Revision Record:   Ver 1.0:z_junjie
+*********************************************************************/
+SG_PACKAGE_API void* CALLMETHOD SG_CreateHandle(unsigned int nType, SGCreateParam* pCreateParam);
+
+/********************************************************************
+*	Funcname: 	    	SG_DestroyHandle
+*	Purpose:				销毁流封装器
+*   InputParam:         handle : 流封装器句柄
+*   Return:					成功返回 SG_ERR_NOERR，失败返回错误码
+*   Created:				2013.11.28  
+*   Revision Record:   Ver 1.0:z_junjie
+*********************************************************************/
+SG_PACKAGE_API int CALLMETHOD SG_DestroyHandle(void* handle);
+
+/********************************************************************
+*	Funcname: 	    	SG_CreateHeader
+*	Purpose:				创建文件头
+*   InputParam:         handle : 流封装器句柄
+*								pHeader : 文件头信息
+*   Return:					成功返回 SG_ERR_NOERR，失败返回错误码
+*   Created:				2013.11.28  
+*   Revision Record:   Ver 1.0:z_junjie
+*********************************************************************/
+SG_PACKAGE_API int CALLMETHOD SG_CreateHeader(void* handle, SGHeaderInfo* pHeader);
+
+/********************************************************************
+*	Funcname: 	    	StreamPacket_InputData
+*	Purpose:				传入媒体数据
+*   InputParam:         handle : 打包句柄
+*								frame_info : 需要打包的媒体信息
+*   Return:					成功返回 SG_ERR_NOERR，失败返回错误码
+*   Created:				2013.11.28  
+*   Revision Record:   Ver 1.0:z_junjie
+*********************************************************************/
+SG_PACKAGE_API int CALLMETHOD SG_InputFrame(void* handle, SGFrameInfo* pFrame);
+
+/********************************************************************
+*	Funcname: 	    	StreamPacket_CreateTailer
+*	Purpose:				删除打包句柄
+*   InputParam:         handle : 打包句柄
+*   Return:					成功返回 SG_ERR_NOERR，失败返回错误码
+*   Created:				2013.11.28  
+*   Revision Record:   Ver 1.0:z_junjie 
+*********************************************************************/
+SG_PACKAGE_API int CALLMETHOD SG_CreateTailer(void* handle, SGTailerInfo* pTailer);
+
+/********************************************************************
+*	Funcname: 	    	SG_SetEncryptType
+*	Purpose:			设置加密类型
+*   InputParam:         handle : 打包句柄
+						type: 加密类型，见SG_ENCRYPT_TYPE
+						key: 秘钥指针
+						keylen: 秘钥长度
+*   Return:             成功返回 SG_ERR_NOERR，失败返回错误码
+*   Created:	        2013.11.28  
+*   Revision Record:    Ver 1.0:z_junjie 
+*********************************************************************/
+SG_PACKAGE_API int CALLMETHOD SG_SetEncryptType(void* handle, int type, unsigned char* key, int keylen);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // !defined(AFX_STREAMPACKAGE_H__014CF316_354F_47ED_B30D_D39912DD250D__INCLUDED_)
+

libs/win6422/StreamParser.h

@@ -0,0 +1,235 @@
+/********************************************************************
+*	Copyright 1992-2008, ZheJiang Dahua Technology Stock Co.Ltd.
+* 						All Rights Reserved
+*	File Name: 	        StreamParser.h	
+*	Description:	    interface for streamParser	 
+*********************************************************************/
+
+#ifndef __STREAM_PARSER_H_
+#define __STREAM_PARSER_H_
+
+#if (defined(WIN32) || defined(WIN64))
+
+	#define SP_API __declspec(dllimport)
+	#define CALLMETHOD __stdcall
+
+#else /*linux or mac*/
+
+	#define SP_API
+	#define CALLMETHOD
+
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*接口返回值*/
+enum SP_RESULT
+{
+    SP_SUCCESS = 0,										/*成功*/
+    SP_ERROR_INVALID_HANDLE = 1,					/*无效句柄*/
+    SP_ERROR_FILE_TYPE_NOSUPPORT = 2,			/*文件类型不支持*/
+    SP_ERROR_STREAM_NOSUPPORT = 3,			/*流类型不支持*/
+    SP_ERROR_PARAMETER = 6,							/*参数有误*/			
+    SP_ERROR_BAD_FORMATTED = 9,     				/*文件格式错误*/
+    SP_ERROR_BUFFER_OVERFLOW = 12,				/*内部缓冲区溢出*/
+    SP_ERROR_SYSTEM_OUT_OF_MEMORY = 13,  /*系统内存不够*/
+    SP_ERROR_LIST_EMPTY = 14,							/*列表为空*/
+};
+
+/*帧类型*/
+enum SP_FRAME_TYPE
+{
+	SP_FRAME_TYPE_UNKNOWN = 0,			/*帧类型不可知*/
+	SP_FRAME_TYPE_VIDEO,				/*帧类型是视频帧*/
+	SP_FRAME_TYPE_AUDIO,				/*帧类型是音频帧*/
+	SP_FRAME_TYPE_DATA					/*帧类型是数据帧*/
+};
+
+/*帧子类型*/
+enum SP_FRAME_SUB_TYPE
+{
+	SP_FRAME_SUB_TYPE_DATA_INVALID		= -1,		/*数据无效*/
+	SP_FRAME_SUB_TYPE_VIDEO_I_FRAME	= 0 ,		/*I帧*/
+	SP_FRAME_SUB_TYPE_VIDEO_P_FRAME,				/*P帧*/
+	SP_FRAME_SUB_TYPE_VIDEO_B_FRAME,				/*B帧*/
+	SP_FRAME_SUB_TYPE_VIDEO_JPEG_FRAME=8,	/*JPEG帧*/
+};						
+
+/*编码类型*/
+enum SP_ENCODE_VIDEO_TYPE
+{
+	SP_ENCODE_VIDEO_UNKNOWN = 0,					/*视频编码格式不可知*/
+	SP_ENCODE_VIDEO_MPEG4 ,								/*视频编码格式是MPEG4*/
+	SP_ENCODE_VIDEO_HI_H264,								/*视频编码格式是海思H264*/
+	SP_ENCODE_VIDEO_JPEG,									/*视频编码格式是标准JPEG*/
+	SP_ENCODE_VIDEO_DH_H264,			/*视频编码格式是大华码流H264*/
+	SP_ENCODE_VIDEO_MPEG2 = 9,          /*视频编码格式是MPEG2*/
+	SP_ENCODE_VIDEO_DH_H265 = 12,		/*视频编码格式是H265*/
+	SP_ENCODE_VIDEO_H263 = 35,      /*视频编码格式是H263*/
+};
+
+enum SP_ENCODE_AUDIO_TYPE
+{
+	SP_ENCODE_AUDIO_UNKNOWN = 0,
+	SP_ENCODE_AUDIO_PCM			= 7,					/*音频编码格式是PCM8*/
+	SP_ENCODE_AUDIO_G729,									/*音频编码格式是G729*/
+	SP_ENCODE_AUDIO_IMA,									/*音频编码格式是IMA*/
+	SP_ENCODE_PCM_MULAW,									/*音频编码格式是PCM MULAW*/
+	SP_ENCODE_AUDIO_G721,									/*音频编码格式是G721*/
+	SP_ENCODE_PCM8_VWIS,									/*音频编码格式是PCM8_VWIS*/
+	SP_ENCODE_MS_ADPCM,									/*音频编码格式是MS_ADPCM*/
+	SP_ENCODE_AUDIO_G711A,								/*音频编码格式是G711A*/
+	SP_ENCODE_AUDIO_AMR,									/*音频编码格式是AMR*/
+	SP_ENCODE_AUDIO_PCM16,								/*音频编码格式是PCM16*/
+	SP_ENCODE_AUDIO_G711U		= 22,				/*音频编码格式是G711U*/
+	SP_ENCODE_AUDIO_G723,									/*音频编码格式是G723*/
+	SP_ENCODE_AUDIO_AAC			= 26,				/*音频编码格式是AAC*/
+	SP_ENCODE_AUDIO_MP2 = 31,					/*音频编码格式是mp2*/
+	SP_ENCODE_AUDIO_OGG,					/*音频编码格式是ogg vorbis*/
+	SP_ENCODE_AUDIO_MP3,					/*音频编码格式是mp3*/
+	SP_ENCODE_AUDIO_G722_1,				/*音频编码格式是G722.1*/
+	SP_ENCODE_AUDIO_AC = 49,						/*音频编码格式是AC3*/
+};
+
+/*加密类型*/
+enum SP_ENCRYPT_TYPE
+{
+    SP_ENCRYPT_UNKOWN = 0,
+    SP_ENCRYPT_AES,
+};
+/*时间信息*/
+typedef struct
+{
+    int nYear;								/*年*/
+    int nMonth;							/*月*/
+    int nDay;								/*日*/
+    int nHour;								/*小时*/
+    int nMinute;							/*分钟*/
+    int nSecond;							/*秒*/
+    int nMilliSecond;					/*毫秒*/
+} SP_TIME;
+
+#pragma pack(1)
+/*帧信息 256字节*/
+typedef struct
+{
+	/*类型*/
+	int					frameType;				/*帧类型*/
+	int					frameSubType;			/*帧子类型*/
+	int					frameEncodeType;	/*帧编码类型*/
+	unsigned char	reserved[4];
+
+	/*数据*/
+	unsigned char*	streamPointer;			/*指向码流数据,NULL表示无效数据*/
+	int					streamLen;				/*码流长度*/
+    unsigned char*	framePointer;			/*指向帧头,NULL表示无效数据*/
+    int					frameLen;					/*帧长度(包括帧头、帧体、帧尾)*/
+    
+    /*时间*/
+    SP_TIME			frameTime;				/*时间信息*/
+    int					timeStamp;				/*时间戳*/
+    
+    /*序号*/
+	int					frameSeq;					/*帧序号*/
+	
+	/*视频属性，关键帧才有*/
+	int					frameRate;				/*帧率*/
+	int					width;						/*宽*/
+	int					height;						/*高*/
+
+    unsigned char  reserved2[8];
+
+	/*音频属性*/
+	int					samplesPerSec;			/*采样频率*/
+	int					bitsPerSample;			/*采样位数*/
+	int					channels;					/*声道数*/
+
+	/*错误标志*/
+	int					isValid;						/*0为有效，非0表示帧错误*/
+
+ #if defined(_WIN64) || defined(__x86_64__)
+ 	/*扩展*/
+ 	unsigned char	reserved3[432];			/*保留字节*/
+ #else
+	/*扩展*/
+ 	unsigned char	reserved3[412];			/*保留字节*/
+ #endif
+} SP_FRAME_INFO;
+#pragma pack()
+
+ /********************************************************************
+ *	Funcname: 	    	SP_CreateStreamParser
+ *	Purpose:				创建流分析器
+ *  InputParam:         nBufferSize: 需要开辟的缓冲区大小，不能小于SP_PaseData每次传入的数据流长度
+ *  OutputParam:      无
+ *  Return:					NULL: 创建流分析器失败
+ *								其他值：流解析器句柄   
+*********************************************************************/
+SP_API void* CALLMETHOD SP_CreateStreamParser(int nBufferSize);
+
+ /********************************************************************
+ *	Funcname: 	    	SP_ParseData
+ *	Purpose:				输入数据流,并同步进行分析
+ *  InputParam:         handle:	通过SP_CreateStreamParser返回的句柄
+ *								stream:	数据流缓冲地址
+ *								length:	数据流长度
+ *  OutputParam:      无
+ *  Return:					0:调用成功
+ *								其他值：失败，通过SP_GetLastError获取错误码    
+*********************************************************************/
+SP_API SP_RESULT CALLMETHOD SP_ParseData(void* handle, unsigned char* stream, int length);
+
+/********************************************************************
+ *	Funcname: 	    	SP_GetOneFrame
+ *	Purpose:				同步获取一帧信息,反复调用直到失败
+ *  InputParam:         handle:	通过SP_CreateStreamParser返回的句柄
+ *								frameInfo: 外部SP_FRAME_INFO的一个结构地址。
+ *  OutputParam:      无
+ *  Return:					0:调用成功
+ *								其他值：失败，通过SP_GetLastError获取错误码    
+*********************************************************************/
+SP_API SP_RESULT CALLMETHOD SP_GetOneFrame(void* handle, SP_FRAME_INFO* frameInfo);
+
+/********************************************************************
+ *	Funcname: 	    	SP_StreamEncryptKey
+ *	Purpose:	        设置实时流解析秘钥
+ *  InputParam:         handle: 通过SP_CreateStreamParser或SP_CreateFileParser返回的句柄。
+ *						type : 秘钥类型 ：SP_ENCRYPT
+ *						key：秘钥数据
+ *						keylen：秘钥长度
+ *  OutputParam:        无
+ *  Return:             0:调用成功
+ *                      其他值：失败，
+*********************************************************************/
+SP_API SP_RESULT CALLMETHOD SP_StreamEncryptKey(void* handle, unsigned int type, unsigned char* key, int keylen);
+
+/********************************************************************
+ *	Funcname: 	    	SP_Destroy
+ *	Purpose:				销毁码流分析器
+ *  InputParam:         handle: 通过SP_CreateStreamParser返回的句柄。
+ *  OutputParam:      无
+ *  Return:					0:调用成功
+ *								其他值：失败，通过SP_GetLastError获取错误码     
+*********************************************************************/
+SP_API SP_RESULT CALLMETHOD SP_Destroy(void* handle);
+
+/********************************************************************
+ *	Funcname: 	    	SP_GetLastError
+ *	Purpose:				获得码流分析库错误码
+ *  InputParam:         handle: 通过SP_CreateStreamParser或SP_CreateFileParser返回的句柄。
+ *  OutputParam:      无
+ *  Return:					0:调用成功
+ *								其他值：失败，通过SP_GetLastError获取错误码   值  
+*********************************************************************/
+SP_API SP_RESULT CALLMETHOD SP_GetLastError(void* handle);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif 
+
+
+

libs/win6422/avglobal.h

@@ -0,0 +1,28 @@
+
+#ifndef AVGLOBAL_H
+#define AVGLOBAL_H
+
+typedef int					AV_int32;	
+typedef unsigned int		AV_uint32;	
+
+#ifndef __OBJC__
+typedef int					AV_BOOL;
+#else
+typedef BOOL				AV_BOOL;
+#endif	
+
+typedef void*				AV_HANDLE;		
+typedef unsigned char		AV_BYTE;	
+typedef float				AV_float;
+
+#ifdef WIN32
+typedef __int64				AV_int64;	
+typedef unsigned __int64	AV_uint64;	
+#else
+typedef long long			AV_int64;
+typedef unsigned long long	AV_uint64;
+#endif	
+	
+#endif
+
+

web/src/main/java/com/zhehekeji/web/controller/CategoryController.java

@@ -0,0 +1,29 @@
+package com.zhehekeji.web.controller;
+
+import com.zhehekeji.core.pojo.Result;
+import com.zhehekeji.web.service.CategoryService;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.multipart.MultipartFile;
+
+import javax.annotation.Resource;
+import java.io.IOException;
+
+@Api(value = "category",tags = "分类管理")
+@RestController
+@RequestMapping("/category")
+public class CategoryController {
+
+    @Resource
+    private CategoryService categoryService;
+
+    @PostMapping("/import")
+    @ApiOperation(value = "分类导入")
+    public Result upload(MultipartFile file) throws IOException {
+        categoryService.importExcel(file);
+        return Result.success();
+    }
+}

web/src/main/java/com/zhehekeji/web/controller/OrderController.java

@@ -9,6 +9,7 @@ import com.zhehekeji.web.pojo.OrderSaveReq;
 import com.zhehekeji.web.pojo.OrderSearch;
 import com.zhehekeji.web.pojo.OrderVO;
 import com.zhehekeji.web.service.OrderService;
+import com.zhehekeji.web.service.PlcOrderInfo;
 import com.zhehekeji.web.service.PlcService;
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiModelProperty;
@@ -50,12 +51,13 @@ public class OrderController {
         return Result.success();
     }
 
-//    @ApiOperation("工单开始信号")
-//    @GetMapping("/start")
-//    public Result orderStart(@ApiParam("工单号") @RequestParam String orderNum, @ApiParam("plc")@RequestParam String plcId){
-//        plcService.orderStart(orderNum,plcId);
-//        return Result.success();
-//    }
+    @ApiOperation("工单开始信号")
+    @PostMapping("/start")
+    public Result orderStart(@ApiParam("工单号") @RequestBody PlcOrderInfo orderNum, @ApiParam("plc")@RequestParam String plcId){
+        orderNum.setOrderNum(plcId+"_"+orderNum.getTaskId());
+        plcService.orderStart(orderNum,plcId);
+        return Result.success();
+    }
 
     @ApiOperation("工单结束信号")
     @GetMapping("/stop")

web/src/main/java/com/zhehekeji/web/controller/StockController.java

@@ -0,0 +1,28 @@
+package com.zhehekeji.web.controller;
+
+import com.zhehekeji.core.pojo.Result;
+import com.zhehekeji.web.service.StockService;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+import org.springframework.web.multipart.MultipartFile;
+
+import javax.annotation.Resource;
+import java.io.IOException;
+
+@Api(value = "Stock",tags = "库存管理")
+@RestController
+@RequestMapping("/stock")
+public class StockController {
+
+    @Resource
+    private StockService stockService;
+    @PostMapping("/import")
+    @ApiOperation(value = "库存导入")
+    public Result upload(MultipartFile file){
+        stockService.importExcel(file);
+        return Result.success();
+    }
+}

web/src/main/java/com/zhehekeji/web/entity/Category.java

@@ -0,0 +1,31 @@
+package com.zhehekeji.web.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.time.LocalDateTime;
+import java.util.Map;
+
+@Data
+@TableName("category")
+public class Category {
+
+    @TableId(type = IdType.AUTO)
+    private Integer id;
+
+    private String name;
+
+    private Integer level;
+
+    private Integer parentId;
+
+    private LocalDateTime updateTime;
+
+    /**
+     * key : name
+     */
+    private Map<String, Category> children;
+}

web/src/main/java/com/zhehekeji/web/entity/OrderLastMedia.java

@@ -25,8 +25,6 @@ public class OrderLastMedia {
 
     private String lastOrderNum;
 
-    private String pics;
-
 //    private String lastPutOrderNum;
 //
 //    @ApiModelProperty("入库照片")

web/src/main/java/com/zhehekeji/web/entity/Stock.java

@@ -1,6 +1,7 @@
 package com.zhehekeji.web.entity;
 
 import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
 import com.baomidou.mybatisplus.annotation.TableId;
 import com.baomidou.mybatisplus.annotation.TableName;
 import lombok.Data;
@@ -18,10 +19,13 @@ public class Stock {
 
     private String shelveId;
 
+    @TableField(value = "`count`")
     private Integer count;
 
+    @TableField(value = "`row`")
     private Integer row;
 
+    @TableField(value = "`column`")
     private Integer column;
 
     private Integer status;

web/src/main/java/com/zhehekeji/web/lib/CallBack.java

@@ -5,6 +5,8 @@ import com.zhehekeji.web.entity.Order;
 import com.zhehekeji.web.mapper.OrderMapper;
 import lombok.extern.slf4j.Slf4j;
 
+import java.util.Date;
+
 @Slf4j
 public class CallBack {
 
@@ -43,4 +45,53 @@ public class CallBack {
             System.out.printf("ReConnect Device[%s] Port[%d]\n", pchDVRIP, nDVRPort);
         }
     }
+
+    public static class CBPTZStatusProcCallBack implements NetSDKLib.fPTZStatusProcCallBack{
+
+        private CBPTZStatusProcCallBack() {
+        }
+
+        private static class CallBackHolder {
+            private static CBPTZStatusProcCallBack instance = new CBPTZStatusProcCallBack();
+        }
+
+        public static CBPTZStatusProcCallBack getInstance() {
+            return CallBackHolder.instance;
+        }
+
+
+        @Override
+        public void invoke(NetSDKLib.LLong lLoginId, NetSDKLib.LLong lAttachHandle, Pointer pBuf, int dwBufLen, long dwUser) {
+            NetSDKLib.NET_PTZ_LOCATION_INFO PTZInfo = new NetSDKLib.NET_PTZ_LOCATION_INFO();
+            ToolKits.GetPointerData(pBuf, PTZInfo);
+            if(PTZInfo.bState == 2){
+                Integer cameraId = CameraConnMap.getCameraIdByLoginId(lLoginId);
+                if(cameraId != null){
+                    OrderInfo orderInfo = CameraCaptureMap.getOrderInfoByStreetId(cameraId);
+                    log.info("cameraId:{}",cameraId);
+                    if(orderInfo != null && !"C6".equals(orderInfo.getCode())){
+                        log.info("cameraId:{} 到位 拍照,code:{},orderNUm:{}",cameraId,orderInfo.getCode(),orderInfo.getOrderNum());
+                        PtzControlModule.pic(cameraId,0,orderInfo);
+                    }
+                    CameraCaptureMap.remove(cameraId);
+                }
+
+            }
+//            System.out.println("-------------时间："+new Date()+"--------------");
+//            System.out.println("通道号:" + PTZInfo.nChannelID);
+//            System.out.println("云台水平运动位置:" + PTZInfo.nPTZPan);
+//            System.out.println("云台垂直运动位置:" + PTZInfo.nPTZTilt);
+//            System.out.println("云台光圈变动位置:" + PTZInfo.nPTZZoom);
+//            System.out.println("云台运动状态:" + PTZInfo.bState);
+//            System.out.println("云台动作:" + PTZInfo.bAction);
+//            System.out.println("云台聚焦状态:" + PTZInfo.bFocusState);
+//            System.out.println("在时间段内预置点状态是否有效:" + PTZInfo.bEffectiveInTimeSection);
+//            System.out.println("聚焦位置:" + PTZInfo.fFocusPosition);
+//            System.out.println("云台水平运动位置:" + PTZInfo.nPTZPan);
+//            System.out.println("云台垂直运动位置:" + PTZInfo.nPTZTilt);
+//            System.out.println("当前倍率:" + (PTZInfo.nZoomValue * 100));  // 真实变倍值 当前倍率（扩大100倍表示）
+        }
+
+    }
+
 }

web/src/main/java/com/zhehekeji/web/lib/CameraCaptureMap.java

@@ -0,0 +1,28 @@
+package com.zhehekeji.web.lib;
+
+import lombok.Data;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@Data
+public class CameraCaptureMap {
+
+    private static Map<Integer,OrderInfo> cameraMap = new HashMap<>();
+
+    public static void put(Integer cameraId,OrderInfo orderInfo){
+        if(cameraId != null && orderInfo != null){
+            cameraMap.put(cameraId,orderInfo);
+        }
+    }
+
+    public static void remove(Integer cameraId){
+        cameraMap.remove(cameraId);
+    }
+
+    public static OrderInfo getOrderInfoByStreetId(Integer cameraId){
+        return cameraMap.get(cameraId);
+    }
+
+
+}

web/src/main/java/com/zhehekeji/web/lib/CaptureRunnable.java

@@ -53,7 +53,7 @@ public class CaptureRunnable implements Runnable {
             if (picPath == null) {
                 return;
             }
-            log.debug("save pic orderNum:{} path:{}", orderInfo.getOrderNum(), path);
+            log.info("save pic orderNum:{} path:{}", orderInfo.getOrderNum(), path);
             String shelveId = orderInfo.getShelveId();
             Integer row = orderInfo.getRow();
             Integer column = orderInfo.getColumn();
@@ -61,6 +61,7 @@ public class CaptureRunnable implements Runnable {
             //同步 防止有照片丢失
             synchronized (orderInfo.getOrderNum().intern()){
                 Order order = orderMapper.getOneByOrderNum(orderInfo.getOrderNum());
+                log.info(" update order get pics:{},orderNum:{}",order.getPicPaths(),orderInfo.getOrderNum());
                 if(order != null){
                     OrderLastMedia orderLastMedia = lastMediaMapper.getOne(shelveId,row,column);
                     if (orderLastMedia == null) {
@@ -72,8 +73,13 @@ public class CaptureRunnable implements Runnable {
                     }else {
                         order.setPicPaths(pics+","+path);
                     }
-                    orderMapper.updateById(order);
-                    //todo 盘点图片 先不做
+                    Order update = new Order();
+                    update.setId(order.getId());
+                    update.setPicPaths(order.getPicPaths());
+                    log.info(" update order set pics:{},orderNum:{}",update.getPicPaths(),orderInfo.getOrderNum());
+                    orderMapper.updateById(update);
+                    log.info(" update over :{}",update.toString());
+
 //                    if(StringUtils.isEmpty(orderLastMedia.getPics())){
 //                        orderLastMedia.setPics(picPath);
 //                    }else {
@@ -83,21 +89,6 @@ public class CaptureRunnable implements Runnable {
                 }
 
             }
-
-            //order.setId(orderInfo.getOrderId());
-//            if (OrderInfo.OrderPathType.GOODS.getType().equals(orderInfo.getType())) {
-//                order.setGoodsPath(path);
-//                orderLastMedia.setLastGoodsOrderNum(orderInfo.getOrderNum());
-//                orderLastMedia.setGoodsPath(path);
-//            } else if (OrderInfo.OrderPathType.PUT.getType().equals(orderInfo.getType())) {
-//                order.setPutPath(path);
-//                orderLastMedia.setLastPutOrderNum(orderInfo.getOrderNum());
-//                orderLastMedia.setPutPath(path);
-//            } else if (OrderInfo.OrderPathType.OUTPUT.getType().equals(orderInfo.getType())) {
-//                order.setOutputPath(path);
-//                orderLastMedia.setLastOutOrderNum(orderInfo.getOrderNum());
-//                orderLastMedia.setOutPutPath(path);
-//            }
             return;
         }
         log.warn("no order");
@@ -109,9 +100,6 @@ public class CaptureRunnable implements Runnable {
         orderLastMedia.setRow(row);
         orderLastMedia.setColumn(column);
         orderLastMedia.setLastOrderNum(orderNum);
-//        orderLastMedia.setLastOutOrderId(0L);
-//        orderLastMedia.setLastPutOrderId(0L);
-//        orderLastMedia.setLastGoodsOrderId(0L);
         lastMediaMapper.insert(orderLastMedia);
         return orderLastMedia;
 

web/src/main/java/com/zhehekeji/web/lib/LoginModule.java

@@ -120,10 +120,29 @@ public class LoginModule {
 		pstOutParam.stuDeviceInfo=m_stDeviceInfo;
 		//m_hLoginHandle = netsdk.CLIENT_LoginEx2(m_strIp, m_nPort, m_strUser, m_strPassword, 0, null, m_stDeviceInfo, nError);
 		m_hLoginHandle=netsdk.CLIENT_LoginWithHighLevelSecurity(pstInParam, pstOutParam);
+		attachPTZStatusProc();
 		return m_hLoginHandle;
 
 	}
 
+	/**
+	 * 订阅云台元数据接口
+	 */
+	public static void attachPTZStatusProc() {
+		NET_IN_PTZ_STATUS_PROC pIn = new NET_IN_PTZ_STATUS_PROC();
+		pIn.nChannel = 0;
+		pIn.cbPTZStatusProc = CallBack.CBPTZStatusProcCallBack.getInstance();
+		pIn.write();
+		NET_OUT_PTZ_STATUS_PROC pOut = new NET_OUT_PTZ_STATUS_PROC();
+		pOut.write();
+		LLong AttachHandle = netsdk.CLIENT_AttachPTZStatusProc(m_hLoginHandle, pIn.getPointer(), pOut.getPointer(),0);
+		if(AttachHandle.longValue() == 0) {
+			System.out.printf("attachPTZStatusProc fail, ErrCode=\n");
+		}else {
+			System.out.println("attachPTZStatusProc success");
+		}
+	}
+
 	/**
 	 * \if ENGLISH_LANG
 	 * Logout Device

web/src/main/java/com/zhehekeji/web/lib/NET_IN_PTZ_STATUS_PROC.java

@@ -0,0 +1,32 @@
+package com.zhehekeji.web.lib;
+
+/**
+ * @author 251823
+ * @description 订阅云台元数据接口输入参数
+ * @date 2021/02/26
+ */
+public class NET_IN_PTZ_STATUS_PROC extends NetSDKLib.SdkStructure{
+	 /**
+     * dwSize;
+     */
+    public int dwSize;
+    /**
+     *  云台通道
+     */
+    public int nChannel;
+
+    /**
+     *  状态回调函数
+     */
+    public NetSDKLib.fPTZStatusProcCallBack cbPTZStatusProc;
+
+    /**
+     *  用户数据
+     */
+    public long dwUser;
+
+    public NET_IN_PTZ_STATUS_PROC(){
+        this.dwSize = this.size();
+    }
+
+}

web/src/main/java/com/zhehekeji/web/lib/NET_OUT_PTZ_STATUS_PROC.java

@@ -0,0 +1,15 @@
+package com.zhehekeji.web.lib;
+/**
+ * @author 251823
+ * @description 订阅云台元数据接口输输出参数
+ * @date 2021/02/26
+ */
+public class NET_OUT_PTZ_STATUS_PROC extends NetSDKLib.SdkStructure{
+	 /**
+     * dwSize;
+     */
+    public int dwSize;
+    public NET_OUT_PTZ_STATUS_PROC(){
+        this.dwSize = this.size();
+    }
+}

web/src/main/java/com/zhehekeji/web/lib/OrderInfo.java

@@ -19,6 +19,8 @@ public class OrderInfo {
 
     private Integer column;
 
+    private String code;
+
     /**
      * 1:入库  2：货位  3：出库
      */

web/src/main/java/com/zhehekeji/web/lib/PtzControlModule.java

@@ -1,6 +1,6 @@
 package com.zhehekeji.web.lib;
 
-import com.sun.jna.Pointer;
+import com.sun.jna.*;
 import com.sun.jna.ptr.IntByReference;
 import com.zhehekeji.common.util.PathUtil;
 import com.zhehekeji.core.util.Assert;
@@ -240,15 +240,13 @@ public class PtzControlModule {
 		download_by_data_type.emDataType = 3;
 		download_by_data_type.emRecordType = 0;
 		download_by_data_type.cbDownLoadPos = mp4ReceiveCB;
-
+		download_by_data_type.write();
 		NetSDKLib.NET_OUT_DOWNLOAD_BY_DATA_TYPE net_out_download_by_data_type = new NetSDKLib.NET_OUT_DOWNLOAD_BY_DATA_TYPE();
-		//NetSDKLib.LLong l = LoginModule.netsdk.CLIENT_DownloadByTimeEx2(CameraConnMap.getConnId(cameraId),channelId,0,startTime,endTime,"./q2q.mp4",null,null,null,null,3,null);
-		log.debug("start download mp4");
-
-		NetSDKLib.LLong l = LoginModule.netsdk.CLIENT_DownloadByDataType(CameraConnMap.getConnId(cameraId),download_by_data_type,net_out_download_by_data_type,0);
-		log.debug("mp4 long：{} "+l.longValue());
+		net_out_download_by_data_type.write();
+		log.info("start download mp4 path:{},startTime:{} ,endTime:{},now:{}",path,startTime.toString(),endTime.toString(),LocalDateTime.now());
+		NetSDKLib.LLong l = LoginModule.netsdk.CLIENT_DownloadByDataType(CameraConnMap.getConnId(cameraId),download_by_data_type.getPointer(),net_out_download_by_data_type.getPointer(),5000);
 		if(l.longValue() == 0){
-			log.error("download error :{}",LoginModule.netsdk.CLIENT_GetLastError());
+			log.error("download error :{}",ToolKits.getErrorCodePrint());
 		}else {
 			OrderRealtime.startDownload(l,orderNum);
 		}

web/src/main/java/com/zhehekeji/web/lib/constant/SDKStructureFieldLenth.java

@@ -0,0 +1,49 @@
+package com.zhehekeji.web.lib.constant;
+
+/**
+ * @author 47081
+ * @version 1.0
+ * @description 一些结构体成员变量的数组长度
+ * @date 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;
+  /** 规则检测区域最大顶点数 */
+  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;
+}

web/src/main/java/com/zhehekeji/web/lib/constant/SDK_ALARM_Ex_TYPE.java

@@ -0,0 +1,42 @@
+package com.zhehekeji.web.lib.constant;
+
+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.zhehekeji.web.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;
+
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/CFG_ACCESS_PROPERTY_TYPE.java

@@ -0,0 +1,26 @@
+package com.zhehekeji.web.lib.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;
+  }
+
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/CFG_EM_ASG_VOICE_DIRECTION.java

@@ -0,0 +1,45 @@
+package com.zhehekeji.web.lib.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;
+  }
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/CFG_EM_BODY_TRAIT.java

@@ -0,0 +1,113 @@
+package com.zhehekeji.web.lib.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;
+	}
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/CFG_EM_FACEDETECT_TYPE.java

@@ -0,0 +1,55 @@
+package com.zhehekeji.web.lib.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;
+	}
+
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/CFG_EM_FACE_SNAP_POLICY.java

@@ -0,0 +1,72 @@
+package com.zhehekeji.web.lib.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;
+	}
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/CFG_EM_FACE_TRAIT.java

@@ -0,0 +1,66 @@
+package com.zhehekeji.web.lib.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_COMPLEXION(5, "肤色"),
+
+    // 口罩
+	CFG_EM_FACE_TRAIT_MASK(6, "口罩"),
+
+    // 表情
+	CFG_EM_FACE_TRAIT_EMOTION(7, "表情");
+
+	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;
+	}
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/CFG_EM_INSTANCE_SUBCLASS_TYPE.java

@@ -0,0 +1,49 @@
+package com.zhehekeji.web.lib.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;
+	}
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/CFG_EM_VOICE_ID.java

@@ -0,0 +1,70 @@
+package com.zhehekeji.web.lib.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;
+  }
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/DH_LOG_QUERY_TYPE.java

@@ -0,0 +1,50 @@
+package com.zhehekeji.web.lib.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
+
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EMDeviceType.java

@@ -0,0 +1,295 @@
+package com.zhehekeji.web.lib.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 EMDeviceType(int type, String desc) {
+        this.type = type;
+        this.desc = desc;
+    }
+
+    private int type;
+    private String 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;
+    }
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_ACROSS_PARKING.java

@@ -0,0 +1,64 @@
+package com.zhehekeji.web.lib.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;
+    }
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_ALARMOUT_POLE.java

@@ -0,0 +1,25 @@
+package com.zhehekeji.web.lib.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;
+  }
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_ALGORITHM_PARTITION_TYPE.java

@@ -0,0 +1,27 @@
+package com.zhehekeji.web.lib.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;
+  }
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_ASG_WORK_MODE.java

@@ -0,0 +1,48 @@
+package com.zhehekeji.web.lib.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;
+  }
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_AUDIO_DATA_SOURCE_TYPE.java

@@ -0,0 +1,54 @@
+package com.zhehekeji.web.lib.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;
+	}
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_AUDIO_DATA_TYPE.java

@@ -0,0 +1,29 @@
+package com.zhehekeji.web.lib.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;
+  }
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_BATTERY_EXIST_STATE.java

@@ -0,0 +1,43 @@
+package com.zhehekeji.web.lib.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;
+    }
+
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_BATTERY_STATE.java

@@ -0,0 +1,41 @@
+package com.zhehekeji.web.lib.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;
+    }
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_CALIBRATEAREA_TYPE.java

@@ -0,0 +1,57 @@
+package com.zhehekeji.web.lib.enumeration;
+
+/**
+ * @author 251823
+ * @description 标定区域类型
+ * @date 2021/01/11
+ */
+public enum EM_CALIBRATEAREA_TYPE {
+	// 错误
+	EM_CALIBRATEAREA_TYPE_ERR(0, "err"),
+
+	//地面，需要N条竖直线段+M条水平线段（（N=3，M=1）；（N=2，M=2）；今后扩展）
+	EM_CALIBRATEAREA_TYPE_GROUD(1, "Groud"),
+
+	//水平面，需要水平面上一点到地面点的投影垂直线段
+	EM_CALIBRATEAREA_TYPE_HORIZONTAL(2, "Horizontal"),
+
+	//垂直面，需要垂直面与地面的交线
+	EM_CALIBRATEAREA_TYPE_VERTICAL(3, "Vertical"),
+
+	//任意平面，N条竖直线段，及每条长度（N=3，及今后扩展）
+	EM_CALIBRATEAREA_TYPE_ANY(4, "Any");
+
+	private int value;
+	private String note;
+
+	private EM_CALIBRATEAREA_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_CALIBRATEAREA_TYPE enumType : EM_CALIBRATEAREA_TYPE.values()) {
+			if (givenValue == enumType.getValue()) {
+				return enumType.getNote();
+			}
+		}
+		return null;
+	}
+
+	public static int getValueByNote(String givenNote) {
+		for (EM_CALIBRATEAREA_TYPE enumType : EM_CALIBRATEAREA_TYPE.values()) {
+			if (givenNote.equals(enumType.getNote())) {
+				return enumType.getValue();
+			}
+		}
+		return -1;
+	}
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_CAMERA_CONNECT_STATE.java

@@ -0,0 +1,51 @@
+package com.zhehekeji.web.lib.enumeration;
+
+/**
+ * @author 251823
+ * @version 1.0
+ * @description 相机连接状态
+ * @date 2020/11/09
+ */
+public enum EM_CAMERA_CONNECT_STATE {
+	// 未知
+	EM_CAMERA_CONNECT_STATE_UNKNOWN(-1, "未知"),
+	// 北向南
+	EM_CAMERA_CONNECT_STATE_UNCONNECT(0, "未连接"),
+	// 东北向西南
+	EM_CAMERA_CONNECT_STATE_CONNECTED(1, "已连接");
+
+	private int value;
+	private String note;
+
+	private EM_CAMERA_CONNECT_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_CAMERA_CONNECT_STATE enumType : EM_CAMERA_CONNECT_STATE.values()) {
+			if (givenValue == enumType.getValue()) {
+				return enumType.getNote();
+			}
+		}
+		return null;
+	}
+
+	public static int getValueByNote(String givenNote) {
+		for (EM_CAMERA_CONNECT_STATE enumType : EM_CAMERA_CONNECT_STATE.values()) {
+			if (givenNote.equals(enumType.getNote())) {
+				return enumType.getValue();
+			}
+		}
+		return -2;
+	}
+
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_CAN_START_STREAM.java

@@ -0,0 +1,67 @@
+package com.zhehekeji.web.lib.enumeration;
+
+/**
+ * 拉流使能
+ *
+ * @author ： 47040
+ * @since ： Created in 2020/9/17 15:53
+ */
+public enum EM_CAN_START_STREAM {
+
+    /**
+     * 未知
+     */
+    EM_CAN_START_STREAM_UNKNOWN(-1, "未知"),
+
+    /**
+     * 不拉流
+     */
+    EM_CAN_START_STREAM_OFF(0, "不拉流"),
+
+    /**
+     * 拉流
+     */
+    EM_CAN_START_STREAM_ON(1, "拉流");
+
+    private int value;
+    private String note;
+
+    EM_CAN_START_STREAM(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_CAN_START_STREAM enumType : EM_CAN_START_STREAM.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+    public static int getValueByNote(String givenNote) {
+        for (EM_CAN_START_STREAM enumType : EM_CAN_START_STREAM.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+
+    public static EM_CAN_START_STREAM getEnum(int value) {
+        for (EM_CAN_START_STREAM e : EM_CAN_START_STREAM.values()) {
+            if (e.getValue() == value)
+                return e;
+        }
+        return EM_CAN_START_STREAM.EM_CAN_START_STREAM_UNKNOWN;
+    }
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_CAPTURE_PROCESS_END_TYPE.java

@@ -0,0 +1,52 @@
+package com.zhehekeji.web.lib.enumeration;
+
+public enum EM_CAPTURE_PROCESS_END_TYPE {
+
+    /**
+     * 未知
+     */
+    EM_CAPTURE_PROCESS_END_TYPE_UNKNOWN(-1,"未知"),
+    /**
+     * 异常
+     */
+    EM_CAPTURE_PROCESS_END_TYPE_ABNORMAL(0,"异常"),
+    /**
+     * 正常
+     */
+    EM_CAPTURE_PROCESS_END_TYPE_NORMAL(1,"正常");
+
+    private int value;
+    private String note;
+
+    private EM_CAPTURE_PROCESS_END_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_CAPTURE_PROCESS_END_TYPE enumType : EM_CAPTURE_PROCESS_END_TYPE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+    public static int getValueByNote(String givenNote) {
+        for (EM_CAPTURE_PROCESS_END_TYPE enumType : EM_CAPTURE_PROCESS_END_TYPE.values()) {
+            if (givenNote.equals(enumType.getNote()) ) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_CFG_CAP_CMD.java

@@ -0,0 +1,35 @@
+package com.zhehekeji.web.lib.enumeration;
+
+/**
+ * 命令类型,对应QueryNewSystemInfo接口
+ */
+public enum EM_CFG_CAP_CMD {
+    /**
+     * 获取设备状态信息 (对应 CFG_CAP_TRAFFIC_DEVICE_STATUS)
+     */
+    CFG_CAP_CMD_DEVICE_STATE("trafficSnap.getDeviceStatus"),
+    /**
+     * 获取查询记录能力集, (对应结构体 CFG_CAP_RECORDFINDER_INFO)
+     */
+    CFG_CAP_CMD_RECORDFINDER("RecordFinder.getCaps"),
+    /**
+     *获取视频诊断进行状态(CFG_VIDEODIAGNOSIS_STATE_INFO)
+     */
+    CFG_CMD_VIDEODIAGNOSIS_GETSTATE("videoDiagnosisServer.getState"),
+    /**
+     * 获取云台支持信息(CFG_CAP_PTZ_ENABLEINFO)
+     */
+    CFG_CAP_CMD_PTZ_ENABLE("ptz.factory.instance");
+    /**
+     * 获取门禁能力集,对应结构体CFG_CAP_ACCESSCONTROL
+     */
+    public static final String CFG_CAP_CMD_ACCESSCONTROLMANAGER="accessControlManager.getCaps";
+    private String cmd;
+    EM_CFG_CAP_CMD(String cmd){
+        this.cmd=cmd;
+    }
+
+    public String getCmd() {
+        return cmd;
+    }
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_CHANNEL_WIDTH.java

@@ -0,0 +1,57 @@
+package com.zhehekeji.web.lib.enumeration;
+
+/**
+ * @author 47081
+ * @version 1.0
+ * @description 通道宽度
+ * @date 2021/2/7
+ */
+public enum EM_CHANNEL_WIDTH {
+  /** 未知 */
+  EM_CHANNEL_WIDTH_UNKNOWN(-1, "未知"),
+  /** 600mm */
+  EM_CHANNEL_WIDTH_600(0, "600mm"),
+  /** 700mm */
+  EM_CHANNEL_WIDTH_700(1, "700mm"),
+  /** 800mm */
+  EM_CHANNEL_WIDTH_800(2, "800mm"),
+  /** 900mm */
+  EM_CHANNEL_WIDTH_900(3, "900mm"),
+  /** 1000mm */
+  EM_CHANNEL_WIDTH_1000(4, "1000mm"),
+  /** 1100mm */
+  EM_CHANNEL_WIDTH_1100(5, "1100mm"),
+  /** 1200mm */
+  EM_CHANNEL_WIDTH_1200(6, "1200mm");
+  private int emWidth;
+  private String desc;
+
+  EM_CHANNEL_WIDTH(int emWidth, String desc) {
+    this.emWidth = emWidth;
+    this.desc = desc;
+  }
+
+  public int getEmWidth() {
+    return emWidth;
+  }
+
+  public void setEmWidth(int emWidth) {
+    this.emWidth = emWidth;
+  }
+
+  public String getDesc() {
+    return desc;
+  }
+
+  public void setDesc(String desc) {
+    this.desc = desc;
+  }
+  public static EM_CHANNEL_WIDTH getChannelWidth(int emWidth){
+    for (EM_CHANNEL_WIDTH channelWidth :EM_CHANNEL_WIDTH.values() ) {
+        if(channelWidth.emWidth==emWidth){
+          return channelWidth;
+        }
+    }
+    return EM_CHANNEL_WIDTH_UNKNOWN;
+  }
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_COLLECTIVITY_STATE.java

@@ -0,0 +1,28 @@
+package com.zhehekeji.web.lib.enumeration;
+
+/**
+ * @author 47081
+ * @version 1.0
+ * @description 诊断结果状态
+ * @date 2021/2/22
+ */
+public enum EM_COLLECTIVITY_STATE {
+  /** 成功 */
+  EM_COLLECTIVITY_STATE_SUCCESSED,
+  /** 失败 */
+  EM_COLLECTIVITY_STATE_FAILED;
+
+  /**
+   * 默认返回failed
+   * @param state
+   * @return
+   */
+  public EM_COLLECTIVITY_STATE getCollectivityState(int state) {
+    for (EM_COLLECTIVITY_STATE collectivityState : EM_COLLECTIVITY_STATE.values()) {
+      if (collectivityState.ordinal() == state) {
+        return collectivityState;
+      }
+    }
+    return EM_COLLECTIVITY_STATE_FAILED;
+  }
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_COLLISION_MODE.java

@@ -0,0 +1,41 @@
+package com.zhehekeji.web.lib.enumeration;
+
+/**
+ * @author 47081
+ * @version 1.0
+ * @description 闸机防冲撞模式
+ * @date 2021/2/7
+ */
+public enum EM_COLLISION_MODE {
+  /** 未知 */
+  EM_COLLISION_MODE_UNKNOWN(-1, "未知"),
+  /** 2s松开离合 */
+  EM_COLLISION_MODE_2S(0, "2s松开离合"),
+  /** 5s松开离合 */
+  EM_COLLISION_MODE_5S(1, "5s松开离合"),
+  /** 人员离开松开离合 */
+  EM_COLLISION_MODE_LEAVING(2, "人员离开松开离合");
+  private int mode;
+  private String desc;
+
+  EM_COLLISION_MODE(int mode, String desc) {
+    this.mode = mode;
+    this.desc = desc;
+  }
+
+  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;
+  }
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_COMPOSIT_CHANNEL_BIND_MODE.java

@@ -0,0 +1,68 @@
+package com.zhehekeji.web.lib.enumeration;
+
+/**
+ * 默认组合通道绑定模式
+ *
+ * @author ： 47040
+ * @since ： Created in 2020/9/27 15:32
+ */
+public enum EM_COMPOSIT_CHANNEL_BIND_MODE {
+    /**
+     * 未知
+     */
+    EM_COMPOSIT_CHANNEL_BIND_MODE_UNKNOWN(0, "未知"),
+    /**
+     * 自动
+     */
+    EM_COMPOSIT_CHANNEL_BIND_MODE_AUTOMATIC(1, "自动"),
+    /**
+     * 半自动
+     */
+    EM_COMPOSIT_CHANNEL_BIND_MODE_SEMIAUTOMATIC(2, "半自动"),
+    /**
+     * 手动
+     */
+    EM_COMPOSIT_CHANNEL_BIND_MODE_MANUAL(3, "手动");
+
+    private int value;
+    private String note;
+
+    EM_COMPOSIT_CHANNEL_BIND_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_COMPOSIT_CHANNEL_BIND_MODE enumType : EM_COMPOSIT_CHANNEL_BIND_MODE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+    public static int getValueByNote(String givenNote) {
+        for (EM_COMPOSIT_CHANNEL_BIND_MODE enumType : EM_COMPOSIT_CHANNEL_BIND_MODE.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+
+    public static EM_COMPOSIT_CHANNEL_BIND_MODE getEnum(int value) {
+        for (EM_COMPOSIT_CHANNEL_BIND_MODE e : EM_COMPOSIT_CHANNEL_BIND_MODE.values()) {
+            if (e.getValue() == value)
+                return e;
+        }
+        return EM_COMPOSIT_CHANNEL_BIND_MODE.EM_COMPOSIT_CHANNEL_BIND_MODE_UNKNOWN;
+    }
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_COURSECOMPOSITE_OPERATE_TYPE.java

@@ -0,0 +1,84 @@
+package com.zhehekeji.web.lib.enumeration;
+
+import com.zhehekeji.web.lib.structure.*;
+
+/**
+ * 录播主机组合通道操作
+ *
+ * @author ： 47040
+ * @since ： Created in 2020/9/28 19:49
+ */
+public enum EM_COURSECOMPOSITE_OPERATE_TYPE {
+    /**
+     * 控制组合通道与逻辑通道，对应结构体
+     * pInParam = {@link NET_IN_COURSECOMPOSITE_LOCK_CONTROL}
+     * pOutParam = {@link NET_OUT_COURSECOMPOSITE_LOCK_CONTROL}
+     */
+    EM_COURSECOMPOSITE_TYPE_LOCK_CONTROL(0, "控制组合通道与逻辑通道"),
+    /**
+     * 获取组合通道与逻辑通道的锁定信息，对应结构体
+     * pInParam = {@link NET_IN_COURSECOMPOSITE_GET_LOCKINFO}
+     * pOutParam = {@link NET_OUT_COURSECOMPOSITE_GET_LOCKINFO}
+     */
+    EM_COURSECOMPOSITE_TYPE_GET_LOCKINFO(1, "获取组合通道与逻辑通道的锁定信息"),
+    /**
+     * 获取组合通道信息,对应结构体
+     * pInParam = {@link NET_IN_COURSECOMPOSITE_GET_INFO}
+     * pOutParam = {@link NET_OUT_COURSECOMPOSITE_GET_INFO}
+     */
+    EM_COURSECOMPOSITE_TYPE_GET_INFO(2, "获取组合通道信息"),
+    /**
+     * 设置组合通道信息,对应结构体
+     * pInParam = {@link NET_IN_COURSECOMPOSITE_SET_INFO}
+     * pOutParam = {@link NET_OUT_COURSECOMPOSITE_SET_INFO}
+     */
+    EM_COURSECOMPOSITE_TYPE_SET_INFO(3, "设置组合通道信息"),
+    /**
+     * 将组合通道信息更新到time时的信息，对应结构体
+     * pInParam = {@link NET_IN_COURSECOMPOSITE_UPDATE_INFO}
+     * pOutParam = {@link NET_OUT_COURSECOMPOSITE_UPDATE_INFO}
+     */
+    EM_COURSECOMPOSITE_TYPE_UPDATE_INFO(4, "将组合通道信息更新到time时的信息");
+
+    private int value;
+    private String note;
+
+    EM_COURSECOMPOSITE_OPERATE_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_COURSECOMPOSITE_OPERATE_TYPE enumType : EM_COURSECOMPOSITE_OPERATE_TYPE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+    public static int getValueByNote(String givenNote) {
+        for (EM_COURSECOMPOSITE_OPERATE_TYPE enumType : EM_COURSECOMPOSITE_OPERATE_TYPE.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+
+    public static EM_COURSECOMPOSITE_OPERATE_TYPE getEnum(int value) {
+        for (EM_COURSECOMPOSITE_OPERATE_TYPE e : EM_COURSECOMPOSITE_OPERATE_TYPE.values()) {
+            if (e.getValue() == value)
+                return e;
+        }
+        return EM_COURSECOMPOSITE_OPERATE_TYPE.EM_COURSECOMPOSITE_TYPE_LOCK_CONTROL;
+    }
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_COURSERECORD_OPERATE_TYPE.java

@@ -0,0 +1,78 @@
+package com.zhehekeji.web.lib.enumeration;
+
+import com.zhehekeji.web.lib.structure.*;
+
+/**
+ * 录播主机录像信息操作
+ *
+ * @author ： 47040
+ * @since ： Created in 2020/9/28 19:17
+ */
+public enum EM_COURSERECORD_OPERATE_TYPE {
+    /**
+     * 获取教室录像信息,对应结构体
+     * pInParam = {@link NET_IN_COURSERECORD_GETINFO}
+     * pOutParam = {@link NET_OUT_COURSERECORD_GETINFO}
+     */
+    EM_COURSERECORDE_TYPE_GET_INFO(0, "获取教室录像信息"),
+    /**
+     * 设置教室录像信息,对应结构体
+     * pInParam = {@link NET_IN_COURSERECORD_SETINFO}
+     * pOutParam = {@link NET_OUT_COURSERECORD_SETINFO}
+     */
+    EM_COURSERECORDE_TYPE_SET_INFO(1, "设置教室录像信息"),
+    /**
+     * 将录像信息更新到time时的信息,对应结构体
+     * pInParam = {@link NET_IN_COURSERECORD_UPDATE_INFO}
+     * pOutParam = {@link NET_OUT_COURSERECORD_UPDATE_INFO}
+     */
+    EM_COURSERECORDE_TYPE_UPDATE_INFO(2, "将录像信息更新到time时的信息"),
+    /**
+     * 获取当前课程教室已录制时间,对应结构体
+     * pInParam = {@link NET_IN_COURSERECORD_GET_TIME}
+     * pOutParam = {@link NET_OUT_COURSERECORD_GET_TIME}
+     */
+    EM_COURSERECORDE_TYPE_GET_TIME(3, "获取当前课程教室已录制时间");
+
+    private int value;
+    private String note;
+
+    EM_COURSERECORD_OPERATE_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_COURSERECORD_OPERATE_TYPE enumType : EM_COURSERECORD_OPERATE_TYPE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+    public static int getValueByNote(String givenNote) {
+        for (EM_COURSERECORD_OPERATE_TYPE enumType : EM_COURSERECORD_OPERATE_TYPE.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+
+    public static EM_COURSERECORD_OPERATE_TYPE getEnum(int value) {
+        for (EM_COURSERECORD_OPERATE_TYPE e : EM_COURSERECORD_OPERATE_TYPE.values()) {
+            if (e.getValue() == value)
+                return e;
+        }
+        return EM_COURSERECORD_OPERATE_TYPE.EM_COURSERECORDE_TYPE_GET_INFO;
+    }
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_COURSE_LOCK_TYPE.java

@@ -0,0 +1,69 @@
+package com.zhehekeji.web.lib.enumeration;
+
+/**
+ * 课程录像锁定类型
+ *
+ * @author ： 47040
+ * @since ： Created in 2020/9/28 16:27
+ */
+public enum EM_COURSE_LOCK_TYPE {
+    /**
+     * 未知
+     */
+    EM_COURSE_LOCK_TYPE_UNKNOWN(-1, "未知"),
+    /**
+     * 全部类型
+     */
+    EM_COURSE_LOCK_TYPE_ALL(0, "全部类型"),
+    /**
+     * 非锁定类型
+     */
+    EM_COURSE_LOCK_TYPE_NON_LOCKING(1, "非锁定类型"),
+    /**
+     * 锁定类型
+     */
+    EM_COURSE_LOCK_TYPE_LOCK(2, "锁定类型");
+
+    private int value;
+    private String note;
+
+    EM_COURSE_LOCK_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_COURSE_LOCK_TYPE enumType : EM_COURSE_LOCK_TYPE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+    public static int getValueByNote(String givenNote) {
+        for (EM_COURSE_LOCK_TYPE enumType : EM_COURSE_LOCK_TYPE.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+
+    public static EM_COURSE_LOCK_TYPE getEnum(int value) {
+        for (EM_COURSE_LOCK_TYPE e : EM_COURSE_LOCK_TYPE.values()) {
+            if (e.getValue() == value)
+                return e;
+        }
+        return EM_COURSE_LOCK_TYPE.EM_COURSE_LOCK_TYPE_UNKNOWN;
+    }
+
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_COURSE_RECORD_COMPRESSION_TYPE.java

@@ -0,0 +1,64 @@
+package com.zhehekeji.web.lib.enumeration;
+
+/**
+ * 课程录像压缩类型
+ *
+ * @author ： 47040
+ * @since ： Created in 2020/9/28 16:55
+ */
+public enum EM_COURSE_RECORD_COMPRESSION_TYPE {
+    /**
+     * 未知
+     */
+    EM_COURSE_RECORD_COMPRESSION_TYPE_UNKNOWN(0, "未知"),
+    /**
+     * H.264 默认值
+     */
+    EM_COURSE_RECORD_COMPRESSION_TYPE_H264(1, "H.264 默认值"),
+    /**
+     * H.265
+     */
+    EM_COURSE_RECORD_COMPRESSION_TYPE_H265(2, "H.265");
+
+    private int value;
+    private String note;
+
+    EM_COURSE_RECORD_COMPRESSION_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_COURSE_RECORD_COMPRESSION_TYPE enumType : EM_COURSE_RECORD_COMPRESSION_TYPE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+    public static int getValueByNote(String givenNote) {
+        for (EM_COURSE_RECORD_COMPRESSION_TYPE enumType : EM_COURSE_RECORD_COMPRESSION_TYPE.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+
+    public static EM_COURSE_RECORD_COMPRESSION_TYPE getEnum(int value) {
+        for (EM_COURSE_RECORD_COMPRESSION_TYPE e : EM_COURSE_RECORD_COMPRESSION_TYPE.values()) {
+            if (e.getValue() == value)
+                return e;
+        }
+        return EM_COURSE_RECORD_COMPRESSION_TYPE.EM_COURSE_RECORD_COMPRESSION_TYPE_UNKNOWN;
+    }
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_COURSE_RECORD_TYPE.java

@@ -0,0 +1,71 @@
+package com.zhehekeji.web.lib.enumeration;
+
+/**
+ * 课程录像类型
+ *
+ * @author ： 47040
+ * @since ： Created in 2020/9/28 16:31
+ */
+public enum EM_COURSE_RECORD_TYPE {
+    /**
+     * 未知
+     */
+    EM_COURSE_RECORD_TYPE_UNKNOWN(-1, "未知"),
+
+    /**
+     * 全部录像类型
+     */
+    EM_COURSE_RECORD_TYPE_ALL(0, "全部录像类型"),
+
+    /**
+     * 导播录像类型
+     */
+    EM_COURSE_RECORD_TYPE_GUIDED_BROADCAST(1, "导播录像类型"),
+
+    /**
+     * 互动录像类型
+     */
+    EM_COURSE_RECORD_TYPE_GUIDED_INTERACTION(2, "互动录像类型");
+
+    private int value;
+    private String note;
+
+    EM_COURSE_RECORD_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_COURSE_RECORD_TYPE enumType : EM_COURSE_RECORD_TYPE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+    public static int getValueByNote(String givenNote) {
+        for (EM_COURSE_RECORD_TYPE enumType : EM_COURSE_RECORD_TYPE.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+
+    public static EM_COURSE_RECORD_TYPE getEnum(int value) {
+        for (EM_COURSE_RECORD_TYPE e : EM_COURSE_RECORD_TYPE.values()) {
+            if (e.getValue() == value)
+                return e;
+        }
+        return EM_COURSE_RECORD_TYPE.EM_COURSE_RECORD_TYPE_UNKNOWN;
+    }
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_COURSE_STATE.java

@@ -0,0 +1,60 @@
+package com.zhehekeji.web.lib.enumeration;
+
+/**
+ * 课程状态
+ *
+ * @author ： 47040
+ * @since ： Created in 2020/9/17 16:00
+ */
+public enum EM_COURSE_STATE {
+    /**
+     * 未知
+     */
+    EM_COURSE_STATE_UNKNOWN(0, "未知"),
+    /**
+     * 未录制
+     */
+    EM_COURSE_STATE_NOT_RECORD(1, "未录制"),
+    /**
+     * 录制中
+     */
+    EM_COURSE_STATE_IN_RECORDING(2, "录制中"),
+    /**
+     * 已录制
+     */
+    EM_COURSE_STATE_ALREADY_RECORDED(3, "已录制");
+
+    private int value;
+    private String note;
+
+    EM_COURSE_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_COURSE_STATE enumType : EM_COURSE_STATE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+    public static int getValueByNote(String givenNote) {
+        for (EM_COURSE_STATE enumType : EM_COURSE_STATE.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_CURRENT_STATE_TYPE.java

@@ -0,0 +1,43 @@
+package com.zhehekeji.web.lib.enumeration;
+
+public enum EM_CURRENT_STATE_TYPE {
+    EM_CURRENT_STATE_UNKNOWN(0, "电流状态未知"),
+    EM_CURRENT_STATE_OVER_CURRENT(1, "电流过载"),                      // 电流过载
+    EM_CURRENT_STATE_NORMAL(2, "电流正常"),                            // 电流正常
+    EM_CURRENT_STATE_UNDER_CURRENT(3, "电源欠流");                     // 电源欠流
+
+    private int value;
+    private String note;
+
+    private EM_CURRENT_STATE_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_CURRENT_STATE_TYPE enumType : EM_CURRENT_STATE_TYPE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+    public static int getValueByNote(String givenNote) {
+        for (EM_CURRENT_STATE_TYPE enumType : EM_CURRENT_STATE_TYPE.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_CUSTOM_DEV_PROTOCOL_TYPE.java

@@ -0,0 +1,79 @@
+package com.zhehekeji.web.lib.enumeration;
+
+/**
+ * @author ： 47040
+ * @since ： Created in 2020/8/13 9:54
+ */
+public enum EM_CUSTOM_DEV_PROTOCOL_TYPE {
+
+    /**
+     * Private
+     */
+    EM_CUSTOM_DEV_PROTOCOL_TYPE_PRIVATE(0, "Private"),
+    /**
+     * Dahua2
+     */
+    EM_CUSTOM_DEV_PROTOCOL_TYPE_DAHUA2(1, "Dahua2"),
+    /**
+     * Dahua3
+     */
+    EM_CUSTOM_DEV_PROTOCOL_TYPE_DAHUA3(2, "Dahua3"),
+    /**
+     * 以URL形式添加的设备
+     */
+    EM_CUSTOM_DEV_PROTOCOL_TYPE_GENERAL(3, "以URL形式添加的设备"),
+    /**
+     * Onvif接入
+     */
+    EM_CUSTOM_DEV_PROTOCOL_TYPE_ONVIF(4, "Onvif接入"),
+    /**
+     * Onvif加密形式接入
+     */
+    EM_CUSTOM_DEV_PROTOCOL_TYPE_ONVIFS(5, "Onvif加密形式接入"),
+    /**
+     * 国标28181接入
+     */
+    EM_CUSTOM_DEV_PROTOCOL_TYPE_GB28181(6, "国标28181接入"),
+    /**
+     * 海康Ehome协议
+     */
+    EM_CUSTOM_DEV_PROTOCOL_TYPE_EHOME(7, "海康Ehome协议"),
+    /**
+     * 主动注册
+     */
+    EM_CUSTOM_DEV_PROTOCOL_TYPE_DAHUA_REG(8, "主动注册");
+
+    private int value;
+    private String note;
+
+    private EM_CUSTOM_DEV_PROTOCOL_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_CUSTOM_DEV_PROTOCOL_TYPE enumType : EM_CUSTOM_DEV_PROTOCOL_TYPE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+    public static int getValueByNote(String givenNote) {
+        for (EM_CUSTOM_DEV_PROTOCOL_TYPE enumType : EM_CUSTOM_DEV_PROTOCOL_TYPE.values()) {
+            if (givenNote.equals(enumType.getNote()) ) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_CUSTOM_EDUCATION_VOICE_TYPE.java

@@ -0,0 +1,78 @@
+package com.zhehekeji.web.lib.enumeration;
+
+/**
+ * @author 47081
+ * @version 1.0
+ * @description 语音类型
+ * @date 2021/2/20
+ */
+public enum EM_CUSTOM_EDUCATION_VOICE_TYPE {
+  /** 未知 */
+  EM_CUSTOM_EDUCATION_VOICE_TYPE_UNKNOWN,
+  /** 超时出校 */
+  EM_CUSTOM_EDUCATION_VOICE_TYPE_LEAVE_SCHOOL_TIMEOUT,
+  /** 超时进校 */
+  EM_CUSTOM_EDUCATION_VOICE_TYPE_ENTER_SCHOOL_TIMEOUT,
+  /** 出校 */
+  EM_CUSTOM_EDUCATION_VOICE_TYPE_LEAVE_SCHOOL,
+  /** 此卡未绑定 */
+  EM_CUSTOM_EDUCATION_VOICE_TYPE_CARD_NOT_BIND,
+  /** 寄宿生 */
+  EM_CUSTOM_EDUCATION_VOICE_TYPE_BOARDER,
+  /** 家长卡已挂失 */
+  EM_CUSTOM_EDUCATION_VOICE_TYPE_PARENT_CARD_REPORT_LOST,
+  /** 进校已过期 */
+  EM_CUSTOM_EDUCATION_VOICE_TYPE_ENTER_SCHOOL_OVERDUE,
+  /** 您有包裹待领取 */
+  EM_CUSTOM_EDUCATION_VOICE_TYPE_PACKAGE_TO_PICKUP,
+  /** 请假 */
+  EM_CUSTOM_EDUCATION_VOICE_TYPE_ASKFORLEAVE,
+  /** 请假返校超时 */
+  EM_CUSTOM_EDUCATION_VOICE_TYPE_RETURN_SCHOOL_TIMEOUT_WHEN_ASKFORLEAVE,
+  /** 请假进出校时间未到 */
+  EM_CUSTOM_EDUCATION_VOICE_TYPE_INANDOUT_SCHOOL_TIMENOTUP_WHEN_ASKFORLEAVE,
+  /** 请假拒绝出校 */
+  EM_CUSTOM_EDUCATION_VOICE_TYPE_REFUSE_LEAVE_SCHOOL_WHEN_ASKFORLEAVE,
+  /** 请假拒绝进校 */
+  EM_CUSTOM_EDUCATION_VOICE_TYPE_REFUSE_ENTER_SCHOOL_WHEN_ASKFORLEAVE,
+  /** 请假审核中 */
+  EM_CUSTOM_EDUCATION_VOICE_TYPE_ASKFORLEAVE_IN_REVIEW,
+  /** 请假已过期 */
+  EM_CUSTOM_EDUCATION_VOICE_TYPE_ASKFORLEAVE_EXPIRED,
+  /** 请假已批准 */
+  EM_CUSTOM_EDUCATION_VOICE_TYPE_ASKFORLEAVE_APPROVED,
+  /** 请假已失效禁止重复出校 */
+  EM_CUSTOM_EDUCATION_VOICE_TYPE_FORBID_LEAVE_SCHOOL_WITH_LEAVE_INVALID,
+  /** 时间未到 */
+  EM_CUSTOM_EDUCATION_VOICE_TYPE_TIME_ISNOT_UP,
+  /** 未预约 */
+  EM_CUSTOM_EDUCATION_VOICE_TYPE_NOT_APPOINT,
+  /** 未在允许时段内禁止通行 */
+  EM_CUSTOM_EDUCATION_VOICE_TYPE_NO_PASSAGE_IN_NONPERMIT_TIMESECTION,
+  /** 无效卡 */
+  EM_CUSTOM_EDUCATION_VOICE_TYPE_INVALID_CARD,
+  /** 已预约 */
+  EM_CUSTOM_EDUCATION_VOICE_TYPE_ALREADY_APPOINTED,
+  /** 允许返校 */
+  EM_CUSTOM_EDUCATION_VOICE_TYPE_ALLOW_BACK_SCHOOL,
+  /** 再见 */
+  EM_CUSTOM_EDUCATION_VOICE_TYPE_GOODBYE,
+  /** 正常进校 */
+  EM_CUSTOM_EDUCATION_VOICE_TYPE_ENTER_SCHOOL_NORMALLY,
+  /** 重复出校 */
+  EM_CUSTOM_EDUCATION_VOICE_TYPE_REPEAT_LEAVE_SCHOOLL,
+  /** 重复进校 */
+  EM_CUSTOM_EDUCATION_VOICE_TYPE_REPEAT_ENTER_SCHOOLL,
+  /** 走读生 */
+  EM_CUSTOM_EDUCATION_VOICE_TYPE_DAY_STUDENT;
+
+  public static EM_CUSTOM_EDUCATION_VOICE_TYPE getEducationVoiceType(int type) {
+    for (EM_CUSTOM_EDUCATION_VOICE_TYPE educationVoiceType :
+        EM_CUSTOM_EDUCATION_VOICE_TYPE.values()) {
+      if (educationVoiceType.ordinal() == type) {
+        return educationVoiceType;
+      }
+    }
+    return EM_CUSTOM_EDUCATION_VOICE_TYPE_UNKNOWN;
+  }
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_CUSTOM_PASSWORD_ENCRYPTION_MODE.java

@@ -0,0 +1,19 @@
+package com.zhehekeji.web.lib.enumeration;
+
+/**
+ * AccessControlCustomPassword记录集中密码的保存方式
+ */
+public enum EM_CUSTOM_PASSWORD_ENCRYPTION_MODE {
+    /**
+     * 未知方式
+     */
+    EM_CUSTOM_PASSWORD_ENCRYPTION_MODE_UNKNOWN,
+    /**
+     * 明文
+     */
+    EM_CUSTOM_PASSWORD_ENCRYPTION_MODE_PLAINTEXT,
+    /**
+     * MD5加密方式
+     */
+    EM_CUSTOM_PASSWORD_ENCRYPTION_MODE_MD5,
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_DATA_SOURCE_TYPE.java

@@ -0,0 +1,50 @@
+package com.zhehekeji.web.lib.enumeration;
+
+/**
+ * @author 47081
+ * @version 1.0
+ * @description 智能分析数据源类型
+ * @date 2020/10/19
+ */
+public enum EM_DATA_SOURCE_TYPE {
+    /**
+     * {@link com.zhehekeji.web.lib.NetSDKLib.NET_REMOTE_REALTIME_STREAM_INFO}
+     */
+    EM_DATA_SOURCE_REMOTE_REALTIME_STREAM(1, "远程实时流"),
+    /**
+     * {@link com.zhehekeji.web.lib.NetSDKLib.NET_PUSH_PICFILE_INFO}
+     */
+    EM_DATA_SOURCE_PUSH_PICFILE(2, "主动推送图片文件");
+    private int type;
+    private String des;
+
+    private EM_DATA_SOURCE_TYPE(int type, String des) {
+        this.type = type;
+        this.des = des;
+    }
+
+    public int getType() {
+        return type;
+    }
+
+    public void setType(int type) {
+        this.type = type;
+    }
+
+    public String getDes() {
+        return des;
+    }
+
+    public void setDes(String des) {
+        this.des = des;
+    }
+
+    public static EM_DATA_SOURCE_TYPE getDataSourceType(int type) {
+        for (EM_DATA_SOURCE_TYPE source : EM_DATA_SOURCE_TYPE.values()) {
+            if (type == source.getType()) {
+                return source;
+            }
+        }
+        return null;
+    }
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_DELIVERY_FILE_TYPE.java

@@ -0,0 +1,48 @@
+package com.zhehekeji.web.lib.enumeration;
+
+/**
+ * @author 47081
+ * @version 1.0
+ * @description
+ * @date 2020/9/14
+ */
+public enum EM_DELIVERY_FILE_TYPE {
+    /**
+     * 未知
+     */
+    EM_DELIVERY_FILE_TYPE_UNKNOWN(0,"未知"),
+    /**
+     * 视频
+     */
+    EM_DELIVERY_FILE_TYPE_VIDEO(1,"视频"),
+    /**
+     * 图片
+     */
+    EM_DELIVERY_FILE_TYPE_IMAGE(2,"图片"),
+    /**
+     * 音频
+     */
+    EM_DELIVERY_FILE_TYPE_AUDIO(3,"音频");
+    private int type;
+    private String desc;
+    private EM_DELIVERY_FILE_TYPE(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;
+    }
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_DETECT_SENSOR_TYPE.java

@@ -0,0 +1,76 @@
+package com.zhehekeji.web.lib.enumeration;
+
+/**
+ * 探测物体的传感器类型
+ *
+ * @author ： 47040
+ * @since ： Created in 2020/12/17 13:45
+ */
+public enum EM_DETECT_SENSOR_TYPE {
+    /**
+     * 未知
+     */
+    EM_DETECT_SENSOR_TYPE_UNKNOWN(0, "未知"),
+    /**
+     * 线圈
+     */
+    EM_DETECT_SENSOR_TYPE_COIL(1, "线圈"),
+    /**
+     * 视频
+     */
+    EM_DETECT_SENSOR_TYPE_VIDEO(2, "视频"),
+    /**
+     * 雷达
+     */
+    EM_DETECT_SENSOR_TYPE_RADAR(3, "雷达"),
+    /**
+     * 5G
+     */
+    EM_DETECT_SENSOR_TYPE_5G(4, "5G"),
+    /**
+     * 融合
+     */
+    EM_DETECT_SENSOR_TYPE_FUSION(5, "融合");
+
+    private final int value;
+    private final String note;
+
+    EM_DETECT_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_DETECT_SENSOR_TYPE enumType : EM_DETECT_SENSOR_TYPE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+    public static int getValueByNote(String givenNote) {
+        for (EM_DETECT_SENSOR_TYPE enumType : EM_DETECT_SENSOR_TYPE.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+
+    public static EM_DETECT_SENSOR_TYPE getEnum(int value) {
+        for (EM_DETECT_SENSOR_TYPE e : EM_DETECT_SENSOR_TYPE.values()) {
+            if (e.getValue() == value)
+                return e;
+        }
+        return EM_DETECT_SENSOR_TYPE.EM_DETECT_SENSOR_TYPE_UNKNOWN;
+    }
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_DEV_VARIABLE_CARS_MANAGER_FUNC_TYPE.java

@@ -0,0 +1,27 @@
+package com.zhehekeji.web.lib.enumeration;
+
+/**
+ * className：EM_DEV_VARIABLE_CARS_MANAGER_FUNC_TYPE
+ * description：
+ *   枚举值,下发设置&获取设置
+ *
+ * author：251589
+ * createTime：2020/12/29 14:04
+ *
+ * @version v1.0
+ */
+public class EM_DEV_VARIABLE_CARS_MANAGER_FUNC_TYPE {
+
+    public static final int EM_DEV_VARIABLE_CARS_MANAGER_FUNC_TYPE_UNKNOWN = 0;        // 未知
+    public static final int EM_DEV_VARIABLE_CARS_MANAGER_FUNC_TYPE_FACE_DETECTION = 1;    // 人脸检测
+    public static final int EM_DEV_VARIABLE_CARS_MANAGER_FUNC_TYPE_FACE_ANALYSIS = 2;    // 人脸分析
+    public static final int EM_DEV_VARIABLE_CARS_MANAGER_FUNC_TYPE_FACE_ATTRIBUTE = 3;    // 人脸属性
+    public static final int EM_DEV_VARIABLE_CARS_MANAGER_FUNC_TYPE_FACE_COMPARE = 4;    // 人脸比对
+    public static final int EM_DEV_VARIABLE_CARS_MANAGER_FUNC_TYPE_NORMAL = 5;            // 智能通用行为分析
+    public static final int EM_DEV_VARIABLE_CARS_MANAGER_FUNC_TYPE_OBJECT_DETECT = 6;    // 智能 视频结构化
+    public static final int EM_DEV_VARIABLE_CARS_MANAGER_FUNC_TYPE_SMART_MOTION = 7;    // 动检,对应的结构体 NET_CFG_SMART_MOTION_DETECT
+    public static final int EM_DEV_VARIABLE_CARS_MANAGER_FUNC_TYPE_ENCODE_ENHANCE = 8;    // 编码增强
+    public static final int EM_DEV_VARIABLE_CARS_MANAGER_FUNC_TYPE_ONE_KEY_EXPAND = 9;    // 一键扩展
+    public static final int EM_DEV_VARIABLE_CARS_MANAGER_FUNC_TYPE_NUMBER_STAT = 10;    // 人数统计
+    public static final int EM_DEV_VARIABLE_CARS_MANAGER_FUNC_TYPE_INTELLIGENT = 11;        // 智能功能,表示所有智能功能
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_DIRECTION_AFTER_POWER_OFF.java

@@ -0,0 +1,48 @@
+package com.zhehekeji.web.lib.enumeration;
+
+/**
+ * @author 47081
+ * @version 1.0
+ * @description 闸机断电以后门摆动放向
+ * @date 2021/2/7
+ */
+public enum EM_DIRECTION_AFTER_POWER_OFF {
+  /** 未知 */
+  EM_DIRECTION_AFTER_POWER_OFF_UNKNOWN(-1, "未知"),
+  /** 进门方向 */
+  EM_DIRECTION_AFTER_POWER_OFF_IN(0, "进门方向"),
+  /** 出门方向 */
+  EM_DIRECTION_AFTER_POWER_OFF_OUT(1, "出门方向");
+  private int mode;
+  private String desc;
+
+  EM_DIRECTION_AFTER_POWER_OFF(int mode, String desc) {
+    this.mode = mode;
+    this.desc = desc;
+  }
+
+  public static EM_DIRECTION_AFTER_POWER_OFF getEmDirectionAfterPowerOff(int mode) {
+    for (EM_DIRECTION_AFTER_POWER_OFF powerOff : EM_DIRECTION_AFTER_POWER_OFF.values()) {
+      if (powerOff.mode == mode) {
+        return powerOff;
+      }
+    }
+    return EM_DIRECTION_AFTER_POWER_OFF_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;
+  }
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_DISK_STATE.java

@@ -0,0 +1,27 @@
+package com.zhehekeji.web.lib.enumeration;
+
+/**
+ * @author 47081
+ * @version 1.0
+ * @description 光盘状态
+ * @date 2021/2/22
+ */
+public enum EM_DISK_STATE {
+  /** 未知 */
+  EM_DISK_STATE_UNKNOWN,
+  /** 已放磁盘 */
+  EM_DISK_STATE_EXIST,
+  /** 未放磁盘 */
+  EM_DISK_STATE_NO_EXIST,
+  /** 需要换盘 */
+  EM_DISK_STATE_NEED_CHANGE;
+
+  public static EM_DISK_STATE getDiskState(int state) {
+    for (EM_DISK_STATE diskState : EM_DISK_STATE.values()) {
+      if (diskState.ordinal() == state) {
+        return diskState;
+      }
+    }
+    return EM_DISK_STATE_UNKNOWN;
+  }
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_DISPLAY_CAMERA_ANGLE_TYPE.java

@@ -0,0 +1,53 @@
+package com.zhehekeji.web.lib.enumeration;
+
+/**
+ * @author 251823
+ * @description 摄像头安装角度显示方式
+ * @date 2021/01/11
+ */
+public enum EM_DISPLAY_CAMERA_ANGLE_TYPE {
+
+	// 未知的显示方式
+	EM_DISPLAY_CAMERA_ANGLE_UNKNOWN(0, "未知的显示方式"),
+
+	// 按角度值配置(默认)
+	EM_DISPLAY_CAMERA_ANGLE_NUM(1, "按角度值配置"),
+
+	// 按模式配置，0~20展示为顶装,21~90展示为斜装，配置时按60下发
+	EM_DISPLAY_CAMERA_ANGLE_MODE(2, "按模式配置");
+
+	private int value;
+	private String note;
+
+	private EM_DISPLAY_CAMERA_ANGLE_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_DISPLAY_CAMERA_ANGLE_TYPE enumType : EM_DISPLAY_CAMERA_ANGLE_TYPE.values()) {
+			if (givenValue == enumType.getValue()) {
+				return enumType.getNote();
+			}
+		}
+		return null;
+	}
+
+	public static int getValueByNote(String givenNote) {
+		for (EM_DISPLAY_CAMERA_ANGLE_TYPE enumType : EM_DISPLAY_CAMERA_ANGLE_TYPE.values()) {
+			if (givenNote.equals(enumType.getNote())) {
+				return enumType.getValue();
+			}
+		}
+		return -1;
+	}
+
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_DOWNLOAD_DATA_TYPE.java

@@ -0,0 +1,56 @@
+package com.zhehekeji.web.lib.enumeration;
+
+/**
+ * 下载数据类型
+ *
+ * @author ： 47040
+ * @since ： Created in 2020/12/28 16:03
+ */
+public enum EM_DOWNLOAD_DATA_TYPE {
+
+    EM_DOWNLOAD_DATA_RECORD(0, "录像"),
+    EM_DOWNLOAD_DATA_PICTURE(1, "图片");
+
+    private final int value;
+    private final String note;
+
+    EM_DOWNLOAD_DATA_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_DOWNLOAD_DATA_TYPE enumType : EM_DOWNLOAD_DATA_TYPE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+    public static int getValueByNote(String givenNote) {
+        for (EM_DOWNLOAD_DATA_TYPE enumType : EM_DOWNLOAD_DATA_TYPE.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+
+    public static EM_DOWNLOAD_DATA_TYPE getEnum(int value) {
+        for (EM_DOWNLOAD_DATA_TYPE e : EM_DOWNLOAD_DATA_TYPE.values()) {
+            if (e.getValue() == value)
+                return e;
+        }
+        return EM_DOWNLOAD_DATA_TYPE.EM_DOWNLOAD_DATA_RECORD;
+    }
+
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_DOWNLOAD_FILE_TYPE.java

@@ -0,0 +1,56 @@
+package com.zhehekeji.web.lib.enumeration;
+
+/**
+ * 下载文件方式
+ *
+ * @author ： 47040
+ * @since ： Created in 2020/12/28 15:25
+ */
+public enum EM_DOWNLOAD_FILE_TYPE {
+
+    EM_DOWNLOAD_BY_FILENAME(0,"按文件名下载"),
+    EM_DOWNLOAD_BY_CONDITION(1,"按条件下载");
+
+    private final int value;
+    private final String note;
+
+    EM_DOWNLOAD_FILE_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_DOWNLOAD_FILE_TYPE enumType : EM_DOWNLOAD_FILE_TYPE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+    public static int getValueByNote(String givenNote) {
+        for (EM_DOWNLOAD_FILE_TYPE enumType : EM_DOWNLOAD_FILE_TYPE.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+
+    public static EM_DOWNLOAD_FILE_TYPE getEnum(int value) {
+        for (EM_DOWNLOAD_FILE_TYPE e : EM_DOWNLOAD_FILE_TYPE.values()) {
+            if (e.getValue() == value)
+                return e;
+        }
+        return EM_DOWNLOAD_FILE_TYPE.EM_DOWNLOAD_BY_FILENAME;
+    }
+
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_DOWNLOAD_TIME_TYPE.java

@@ -0,0 +1,56 @@
+package com.zhehekeji.web.lib.enumeration;
+
+/**
+ * 下载时间类型
+ *
+ * @author ： 47040
+ * @since ： Created in 2020/12/28 15:58
+ */
+public enum EM_DOWNLOAD_TIME_TYPE {
+
+    EM_DOWNLOAD_TIME_SNAP(0, "抓拍时间"),
+    EM_DOWNLOAD_TIME_STORAGE(1, "存储时间");
+
+    private final int value;
+    private final String note;
+
+    EM_DOWNLOAD_TIME_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_DOWNLOAD_TIME_TYPE enumType : EM_DOWNLOAD_TIME_TYPE.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+    public static int getValueByNote(String givenNote) {
+        for (EM_DOWNLOAD_TIME_TYPE enumType : EM_DOWNLOAD_TIME_TYPE.values()) {
+            if (givenNote.equals(enumType.getNote())) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+
+    public static EM_DOWNLOAD_TIME_TYPE getEnum(int value) {
+        for (EM_DOWNLOAD_TIME_TYPE e : EM_DOWNLOAD_TIME_TYPE.values()) {
+            if (e.getValue() == value)
+                return e;
+        }
+        return EM_DOWNLOAD_TIME_TYPE.EM_DOWNLOAD_TIME_SNAP;
+    }
+
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_DRIVING_DIRECTION.java

@@ -0,0 +1,51 @@
+package com.zhehekeji.web.lib.enumeration;
+
+public enum EM_DRIVING_DIRECTION {
+
+    /**
+     * 未知
+     */
+    EM_DRIVING_DIRECTION_UNKNOWN(0,"未知"),
+    /**
+     * 驶入
+     */
+    EM_DRIVING_DIRECTION_IN(1,"驶入"),
+    /**
+     * 驶出
+     */
+    EM_DRIVING_DIRECTION_OUT(2,"驶出");
+
+    private int value;
+    private String note;
+
+    private EM_DRIVING_DIRECTION(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_DRIVING_DIRECTION enumType : EM_DRIVING_DIRECTION.values()) {
+            if (givenValue == enumType.getValue()) {
+                return enumType.getNote();
+            }
+        }
+        return null;
+    }
+
+    public static int getValueByNote(String givenNote) {
+        for (EM_DRIVING_DIRECTION enumType : EM_DRIVING_DIRECTION.values()) {
+            if (givenNote.equals(enumType.getNote()) ) {
+                return enumType.getValue();
+            }
+        }
+        return -1;
+    }
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_EMERGENCYSTATUS_TYPE.java

@@ -0,0 +1,38 @@
+package com.zhehekeji.web.lib.enumeration;
+
+/**
+ * @author 47081
+ * @version 1.0
+ * @description 紧急报警状态
+ * @date 2021/2/22
+ */
+public enum EM_EMERGENCYSTATUS_TYPE {
+  /** 未知 */
+  EM_EMERGENCYSTATUS_UNKNOWN(-1, "未知"),
+  EM_EMERGENCYSTATUS_CLOSE(0, "关闭"),
+  EM_EMERGENCYSTATUS_OPEN(1, "开启");
+  private int type;
+  private String desc;
+
+  EM_EMERGENCYSTATUS_TYPE(int type, String desc) {
+    this.type = type;
+    this.desc = desc;
+  }
+
+  public int getType() {
+    return type;
+  }
+
+  public String getDesc() {
+    return desc;
+  }
+
+  public static EM_EMERGENCYSTATUS_TYPE getEmergencyStatusType(int type) {
+    for (EM_EMERGENCYSTATUS_TYPE emergencyStatus : EM_EMERGENCYSTATUS_TYPE.values()) {
+      if (emergencyStatus.type == type) {
+        return emergencyStatus;
+      }
+    }
+    return EM_EMERGENCYSTATUS_UNKNOWN;
+  }
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_ENTRY_DIRECTION.java

@@ -0,0 +1,63 @@
+package com.zhehekeji.web.lib.enumeration;
+
+/**
+ * @author 251823
+ * @version 1.0
+ * @description 进口方向
+ * @date 2020/11/07
+ */
+public enum EM_ENTRY_DIRECTION {
+
+	// 未知
+	EM_ENTRY_UNKNOWN(0, "未知"),
+	// 北向南
+	EM_ENTRY_NORTH_TO_SOUTH(1, "北向南"),
+	// 东北向西南
+	EM_ENTRY_EASTNORTH_TO_WESTSOUTH(2, "东北向西南"),
+	// 东向西
+	EM_ENTRY_EAST_TO_WEST(3, "东向西"),
+	// 东南向西北
+	EM_ENTRY_EASTSOUTH_TO_WESTNORTH(4, "东南向西北"),
+	// 南向北
+	EM_ENTRY_SOUTH_TO_NORTH(5, "南向北"),
+	// 西南向东北
+	EM_ENTRY_WESTSOUTH_TO_EASTSOUTH(6, "西南向东北"),
+	// 西向东
+	EM_ENTRY_WEST_TO_EAST(7, "西向东"),
+	// 西北向东南
+	EM_ENTRY_WESTNORTH_TO_EASTSOUTH(8, "西北向东南");
+
+	private int value;
+	private String note;
+
+	private EM_ENTRY_DIRECTION(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_ENTRY_DIRECTION enumType : EM_ENTRY_DIRECTION.values()) {
+			if (givenValue == enumType.getValue()) {
+				return enumType.getNote();
+			}
+		}
+		return null;
+	}
+
+	public static int getValueByNote(String givenNote) {
+		for (EM_ENTRY_DIRECTION enumType : EM_ENTRY_DIRECTION.values()) {
+			if (givenNote.equals(enumType.getNote())) {
+				return enumType.getValue();
+			}
+		}
+		return -1;
+	}
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_ENTRY_TYPE.java

@@ -0,0 +1,56 @@
+package com.zhehekeji.web.lib.enumeration;
+
+/**
+ * @author 251823
+ * @version 1.0
+ * @description 进口类型
+ * @date 2020/11/07
+ */
+public enum EM_ENTRY_TYPE {
+
+	// 未知
+	EM_ENTRY_TYPE_UNKNOWN(0, "未知"),
+	// 左转
+	EM_ENTRY_TYPE_TURN_LEFT(1, "左转"),
+	// 直行
+	EM_ENTRY_TYPE_STRAIGHT(2, "直行"),
+	// 右转
+	EM_ENTRY_TYPE_TRUN_RIGHT(3, "右转"),
+	// 掉头
+	EM_ENTRY_TYPE_TURN_ROUND(4, "掉头");
+
+	private int value;
+	private String note;
+
+	private EM_ENTRY_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_ENTRY_TYPE enumType : EM_ENTRY_TYPE.values()) {
+			if (givenValue == enumType.getValue()) {
+				return enumType.getNote();
+			}
+		}
+		return null;
+	}
+
+	public static int getValueByNote(String givenNote) {
+		for (EM_ENTRY_TYPE enumType : EM_ENTRY_TYPE.values()) {
+			if (givenNote.equals(enumType.getNote())) {
+				return enumType.getValue();
+			}
+		}
+		return -1;
+	}
+
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_EVENT_IVS.java

@@ -0,0 +1,473 @@
+package com.zhehekeji.web.lib.enumeration;
+
+/**
+ * 智能分析事件类型枚举类
+ */
+public enum EM_EVENT_IVS {
+
+    /**
+     * 订阅所有事件
+     */
+    EVENT_IVS_ALL(0x00000001),
+    /**
+     * 警戒线事件(对应 DEV_EVENT_CROSSLINE_INFO)
+     */
+    EVENT_IVS_CROSSLINEDETECTION(0x00000002),
+    /**
+     * 警戒区事件(对应 DEV_EVENT_CROSSREGION_INFO)
+     */
+    EVENT_IVS_CROSSREGIONDETECTION(0x00000003),
+    /**
+     * 物品遗留事件(对应 DEV_EVENT_LEFT_INFO)
+     */
+    EVENT_IVS_LEFTDETECTION(0x00000005),
+    /**
+     * 停留事件(对应 DEV_EVENT_STAY_INFO)
+     */
+    EVENT_IVS_STAYDETECTION(0x00000006),
+    /**
+     * 徘徊事件(对应  DEV_EVENT_WANDER_INFO)
+     */
+    EVENT_IVS_WANDERDETECTION(0x00000007),
+    /**
+     * 移动事件(对应 DEV_EVENT_MOVE_INFO)
+     */
+    EVENT_IVS_MOVEDETECTION(0x00000009),
+    /**
+     * 聚众事件(对应 DEV_EVENT_RIOTERL_INFO)
+     */
+    EVENT_IVS_RIOTERDETECTION(0x0000000B),
+    /**
+     * 斗殴事件(对应 DEV_EVENT_FIGHT_INFO)
+     */
+    EVENT_IVS_FIGHTDETECTION(0x0000000E),
+    /**
+     * 交通路口事件----老规则(对应 DEV_EVENT_TRAFFICJUNCTION_INFO)
+     */
+    EVENT_IVS_TRAFFICJUNCTION(0x00000017),
+    /**
+     * 交通卡口事件----老规则(对应 DEV_EVENT_TRAFFICGATE_INFO)
+     */
+    EVENT_IVS_TRAFFICGATE(0x00000018),
+    /**
+     * 人脸检测事件 (对应 DEV_EVENT_FACEDETECT_INFO)(智能规则对应  EVENT_IVS_FACEDETECT)
+     */
+    EVENT_IVS_FACEDETECT(0x0000001A),
+    /**
+     * 交通拥堵事件(对应 DEV_EVENT_TRAFFICJAM_INFO)
+     */
+    EVENT_IVS_TRAFFICJAM(0x0000001B),
+    /**
+     * 交通违章-闯红灯事件(对应 DEV_EVENT_TRAFFIC_RUNREDLIGHT_INFO)
+     */
+    EVENT_IVS_TRAFFIC_RUNREDLIGHT(0x00000100),
+    /**
+     * 交通违章-压车道线事件(对应 DEV_EVENT_TRAFFIC_OVERLINE_INFO)
+     */
+    EVENT_IVS_TRAFFIC_OVERLINE(0x00000101),
+    /**
+     * 交通违章-逆行事件(对应  DEV_EVENT_TRAFFIC_RETROGRADE_INFO)
+     */
+    EVENT_IVS_TRAFFIC_RETROGRADE(0x00000102),
+    /**
+     * 交通违章-违章左转(对应 DEV_EVENT_TRAFFIC_TURNLEFT_INFO)
+     */
+    EVENT_IVS_TRAFFIC_TURNLEFT(0x00000103),
+    /**
+     * 交通违章-违章右转(对应 DEV_EVENT_TRAFFIC_TURNRIGHT_INFO)
+     */
+    EVENT_IVS_TRAFFIC_TURNRIGHT(0x00000104),
+    /**
+     * 交通违章-违章掉头(对应 DEV_EVENT_TRAFFIC_UTURN_INFO)
+     */
+    EVENT_IVS_TRAFFIC_UTURN(0x00000105),
+    /**
+     * 交通违章-超速(对应 DEV_EVENT_TRAFFIC_OVERSPEED_INFO)
+     */
+    EVENT_IVS_TRAFFIC_OVERSPEED(0x00000106),
+    /**
+     * 交通违章-低速(对应 DEV_EVENT_TRAFFIC_UNDERSPEED_INFO)
+     */
+    EVENT_IVS_TRAFFIC_UNDERSPEED(0x00000107),
+    /**
+     * 交通违章-违章停车(对应 DEV_EVENT_TRAFFIC_PARKING_INFO)
+     */
+    EVENT_IVS_TRAFFIC_PARKING(0x00000108),
+    /**
+     * 交通违章-不按车道行驶(对应 DEV_EVENT_TRAFFIC_WRONGROUTE_INFO)
+     */
+    EVENT_IVS_TRAFFIC_WRONGROUTE(0x00000109),
+    /**
+     * 交通违章-违章变道(对应 DEV_EVENT_TRAFFIC_CROSSLANE_INFO)
+     */
+    EVENT_IVS_TRAFFIC_CROSSLANE(0x0000010A),
+    /**
+     * 交通违章-压黄线 (对应 DEV_EVENT_TRAFFIC_OVERYELLOWLINE_INFO)
+     */
+    EVENT_IVS_TRAFFIC_OVERYELLOWLINE(0x0000010B),
+    /**
+     * 交通违章-黄牌车占道事件(对应 DEV_EVENT_TRAFFIC_YELLOWPLATEINLANE_INFO)
+     */
+    EVENT_IVS_TRAFFIC_YELLOWPLATEINLANE(0x0000010E),
+    /**
+     * 交通违章-斑马线行人优先事件(对应 DEV_EVENT_TRAFFIC_PEDESTRAINPRIORITY_INFO)
+     */
+    EVENT_IVS_TRAFFIC_PEDESTRAINPRIORITY(0x0000010F),
+    /**
+     * 交通违章-禁止通行事件(对应 DEV_EVENT_TRAFFIC_NOPASSING_INFO)
+     */
+    EVENT_IVS_TRAFFIC_NOPASSING(0x00000111),
+    /**
+     * 异常奔跑事件(对应 DEV_EVENT_ABNORMALRUNDETECTION_INFO)
+     */
+    EVENT_IVS_ABNORMALRUNDETECTION(0x00000112),
+    /**
+     * 物品搬移事件(对应 DEV_EVENT_TAKENAWAYDETECTION_INFO)
+     */
+    EVENT_IVS_TAKENAWAYDETECTION(0x00000115),
+    /**
+     * 非法停车事件(对应 DEV_EVENT_PARKINGDETECTION_INFO)
+     */
+    EVENT_IVS_PARKINGDETECTION(0x00000116),
+    /**
+     * 人脸识别事件(对应 DEV_EVENT_FACERECOGNITION_INFO, (对应的智能规则配置  CFG_FACERECOGNITION_INFO)
+     */
+    EVENT_IVS_FACERECOGNITION(0x00000117),
+    /**
+     * 交通手动抓拍事件(对应  DEV_EVENT_TRAFFIC_MANUALSNAP_INFO)
+     */
+    EVENT_IVS_TRAFFIC_MANUALSNAP(0x00000118),
+    /**
+     * 交通流量统计事件(对应 DEV_EVENT_TRAFFIC_FLOW_STATE)
+     */
+    EVENT_IVS_TRAFFIC_FLOWSTATE(0x00000119),
+    /**
+     * 有车占道事件(对应 DEV_EVENT_TRAFFIC_VEHICLEINROUTE_INFO)
+     */
+    EVENT_IVS_TRAFFIC_VEHICLEINROUTE(0x0000011B),
+    /**
+     * 外部报警事件(对应 DEV_EVENT_ALARM_INFO)
+     */
+    EVENT_ALARM_LOCALALARM(0x0000011D),
+    /**
+     * 交通违章--卡口事件----新规则(对应 DEV_EVENT_TRAFFICJUNCTION_INFO)
+     */
+    EVENT_IVS_TRAFFIC_TOLLGATE(0x00000120),
+    /**
+     * 交通违章--占用公交车道事件(对应 DEV_EVENT_TRAFFIC_VEHICLEINBUSROUTE_INFO)
+     */
+    EVENT_IVS_TRAFFIC_VEHICLEINBUSROUTE(0x00000124),
+    /**
+     * 交通违章--违章倒车事件(对应 DEV_EVENT_IVS_TRAFFIC_BACKING_INFO)
+     */
+    EVENT_IVS_TRAFFIC_BACKING(0x00000125),
+    /**
+     * 声音异常检测(对应 DEV_EVENT_IVS_AUDIO_ABNORMALDETECTION_INFO)
+     */
+    EVENT_IVS_AUDIO_ABNORMALDETECTION(0x00000126),
+    /**
+     * 交通违章-闯黄灯事件(对应 DEV_EVENT_TRAFFIC_RUNYELLOWLIGHT_INFO)
+     */
+    EVENT_IVS_TRAFFIC_RUNYELLOWLIGHT(0x00000127),
+    /**
+     * 攀高检测事件(对应 DEV_EVENT_IVS_CLIMB_INFO)
+     */
+    EVENT_IVS_CLIMBDETECTION(0x00000128),
+    /**
+     * 离岗检测事件(对应 DEV_EVENT_IVS_LEAVE_INFO)
+     */
+    EVENT_IVS_LEAVEDETECTION(0x00000129),
+    /**
+     * 交通违章--黄网格线抓拍事件(对应 DEV_EVENT_TRAFFIC_PARKINGONYELLOWBOX_INFO)
+     */
+    EVENT_IVS_TRAFFIC_PARKINGONYELLOWBOX(0x0000012A),
+    /**
+     * 车位有车事件(对应 DEV_EVENT_TRAFFIC_PARKINGSPACEPARKING_INFO )
+     */
+    EVENT_IVS_TRAFFIC_PARKINGSPACEPARKING(0x0000012B),
+    /**
+     * 车位无车事件(对应  DEV_EVENT_TRAFFIC_PARKINGSPACENOPARKING_INFO )
+     */
+    EVENT_IVS_TRAFFIC_PARKINGSPACENOPARKING(0x0000012C),
+    /**
+     * 交通行人事件(对应 DEV_EVENT_TRAFFIC_PEDESTRAIN_INFO)
+     */
+    EVENT_IVS_TRAFFIC_PEDESTRAIN(0x0000012D),
+    /**
+     * 交通抛洒物品事件(对应 DEV_EVENT_TRAFFIC_THROW_INFO)
+     */
+    EVENT_IVS_TRAFFIC_THROW(0x0000012E),
+    /**
+     * 交通违章--压停止线事件(对应 DEV_EVENT_TRAFFIC_OVERSTOPLINE)
+     */
+    EVENT_IVS_TRAFFIC_OVERSTOPLINE(0X00000137),
+    /**
+     * 交通违章--交通未系安全带事件(对应 DEV_EVENT_TRAFFIC_WITHOUT_SAFEBELT)
+     */
+    EVENT_IVS_TRAFFIC_WITHOUT_SAFEBELT(0x00000138),
+    /**
+     * 驾驶员抽烟事件(对应 DEV_EVENT_TRAFFIC_DRIVER_SMOKING)
+     */
+    EVENT_IVS_TRAFFIC_DRIVER_SMOKING(0x00000139),
+    /**
+     * 驾驶员打电话事件(对应 DEV_EVENT_TRAFFIC_DRIVER_CALLING)
+     */
+    EVENT_IVS_TRAFFIC_DRIVER_CALLING(0x0000013A),
+    /**
+     * 交通违章--未按规定依次通行(对应 DEV_EVENT_TRAFFIC_PASSNOTINORDER_INFO)
+     */
+    EVENT_IVS_TRAFFIC_PASSNOTINORDER(0x0000013C),
+    /**
+     * 视频遮挡事件(对应 DEV_EVENT_ALARM_VIDEOBLIND)
+     */
+    EVENT_ALARM_VIDEOBLIND(0x00000153),
+    /**
+     * 交通违章--车辆拥堵禁入事件(对应 DEV_EVENT_ALARM_JAMFORBIDINTO_INFO)
+     */
+    EVENT_IVS_TRAFFIC_JAM_FORBID_INTO(0x00000163),
+    /**
+     * 加油站提枪、挂枪事件(对应  DEV_EVENT_TRAFFIC_FCC_INFO)
+     */
+    EVENT_IVS_TRAFFIC_FCC(0x0000016B),
+    /**
+     * 门禁事件 (对应 DEV_EVENT_ACCESS_CTL_INFO)
+     */
+    EVENT_IVS_ACCESS_CTL(0x00000204),
+    /**
+     * SnapManual事件(对应 DEV_EVENT_SNAPMANUAL)
+     */
+    EVENT_IVS_SNAPMANUAL(0x00000205),
+    /**
+     * 生理疲劳驾驶事件(对应 DEV_EVENT_TIREDPHYSIOLOGICAL_INFO)
+     */
+    EVENT_IVS_TRAFFIC_TIREDPHYSIOLOGICAL(0x00000207),
+    /**
+     * 人证比对事件(对应  DEV_EVENT_CITIZEN_PICTURE_COMPARE_INFO )
+     */
+    EVENT_IVS_CITIZEN_PICTURE_COMPARE(0x00000209),
+    /**
+     * 人体特征事件(对应 DEV_EVENT_HUMANTRAIT_INFO)
+     */
+    EVENT_IVS_HUMANTRAIT(0x00000215),
+    /**
+     * 开车低头报警事件(对应DEV_EVENT_TIREDLOWERHEAD_INFO)
+     */
+    EVENT_IVS_TRAFFIC_TIREDLOWERHEAD(0x0000020A),
+    /**
+     * 开车左顾右盼报警事件(对应DEV_EVENT_DRIVERLOOKAROUND_INFO)
+     */
+    EVENT_IVS_TRAFFIC_DRIVERLOOKAROUND(0x0000020B),
+    /**
+     * 开车离岗报警事件(对应DEV_EVENT_DRIVERLEAVEPOST_INFO)
+     */
+    EVENT_IVS_TRAFFIC_DRIVERLEAVEPOST(0x0000020C),
+    /**
+     * 开车打哈欠事件(对应DEV_EVENT_DRIVERYAWN_INFO)
+     */
+    EVENT_IVS_TRAFFIC_DRIVERYAWN(0x00000210),
+    /**
+     * 人脸分析事件 (暂未有具体事件)
+     */
+    EVENT_IVS_FACEANALYSIS(0x00000217),
+    /**
+     * 车辆超速报警事件(对应 DEV_EVENT_HIGHSPEED_INFO)
+     */
+    EVENT_IVS_HIGHSPEED(0x0000022B),
+    /**
+     * 车牌对比事件(中石化智慧加油站项目)(对应 DEV_EVENT_VEHICLE_RECOGNITION_INFO)
+     */
+    EVENT_IVS_VEHICLE_RECOGNITION(0x00000231),
+
+    /**
+     * 人群密度检测事件(对应结构体 DEV_EVENT_CROWD_DETECTION_INFO)
+     */
+    EVENT_IVS_CROWDDETECTION(0x0000022C),
+    /**
+     * 立体视觉区域内人数统计事件(对应DEV_EVENT_MANNUM_DETECTION_INFO)
+     */
+    EVENT_IVS_MAN_NUM_DETECTION(0x0000020E),
+    /**
+     * 电动扶梯运行异常事件 (对应DEV_EVENT_ELEVATOR_ABNORMAL_INFO)
+     */
+    EVENT_IVS_ELEVATOR_ABNORMAL(0x0000023D),
+    /**
+     * IVSS人脸检测事件 (暂未有具体事件)
+     */
+    EVENT_IVSS_FACEATTRIBUTE(0x00000243),
+    /**
+     * IVSS人脸识别事件 (暂未有具体事件)
+     */
+    EVENT_IVSS_FACECOMPARE(0x00000244),
+    /**
+     * 火警事件(对应 DEV_EVENT_FIREWARNING_INFO)
+     */
+    EVENT_IVS_FIREWARNING(0x00000245),
+    /**
+     * 车道偏移预警(对应 DEV_EVENT_LANEDEPARTURE_WARNNING_INFO)
+     */
+    EVENT_IVS_LANEDEPARTURE_WARNNING(0X00000251),
+    /**
+     * 前向碰撞预警(对应 DEV_EVENT_FORWARDCOLLISION_WARNNING_INFO)
+     */
+    EVENT_IVS_FORWARDCOLLISION_WARNNING(0x00000252),
+    /**
+     * 漂浮物检测事件 (对应 DEV_EVENT_FLOATINGOBJECT_DETECTION_INFO)
+     */
+    EVENT_IVS_FLOATINGOBJECT_DETECTION(0x00000257),
+    /**
+     * 打电话检测事件(对应 DEV_EVENT_PHONECALL_DETECT_INFO)
+     */
+    EVENT_IVS_PHONECALL_DETECT(0x0000025A),
+    /**
+     * 吸烟检测事件(对应 DEV_EVENT_SMOKING_DETECT_INFO)
+     */
+    EVENT_IVS_SMOKING_DETECT(0x0000025B),
+    /**
+     * 雷达限速报警事件(对应 DEV_EVENT_RADAR_SPEED_LIMIT_ALARM_INFO)
+     */
+    EVENT_IVS_RADAR_SPEED_LIMIT_ALARM(0x0000025C),
+    /**
+     * 水位检测事件 (对应 DEV_EVENT_WATER_LEVEL_DETECTION_INFO)
+     */
+    EVENT_IVS_WATER_LEVEL_DETECTION(0x0000025D),
+    /**
+     * 城市机动车违停事件 (对应 DEV_EVENT_CITY_MOTORPARKING_INFO)
+     */
+    EVENT_IVS_CITY_MOTORPARKING(0x0000024F),
+    /**
+     * 城市机非动车违停事件 (对应 DEV_EVENT_CITY_NONMOTORPARKING_INFO)
+     */
+    EVENT_IVS_CITY_NONMOTORPARKING(0x00000250),
+    /**
+     * 违规撑伞检测事件 (对应 DEV_EVENT_HOLD_UMBRELLA_INFO)
+     */
+    EVENT_IVS_HOLD_UMBRELLA(0x0000025E),
+    /**
+     * 垃圾暴露检测事件 (对应 DEV_EVENT_GARBAGE_EXPOSURE_INFO)
+     */
+    EVENT_IVS_GARBAGE_EXPOSURE(0x0000025F),
+    /**
+     * 垃圾桶满溢检测事件 (对应 DEV_EVENT_DUSTBIN_OVER_FLOW_INFO)
+     */
+    EVENT_IVS_DUSTBIN_OVER_FLOW(0x00000260),
+    /**
+     * 门前脏乱检测事件 (对应 DEV_EVENT_DOOR_FRONT_DIRTY_INFO)
+     */
+    EVENT_IVS_DOOR_FRONT_DIRTY(0x00000261),
+    /**
+     * 排队滞留时间报警事件 (对应 DEV_EVENT_QUEUESTAY_DETECTION_INFO)
+     */
+    EVENT_IVS_QUEUESTAY_DETECTION(0X00000262),
+    /**
+     * 排队人数异常报警事件（对应 DEV_EVENT_QUEUENUM_DETECTION_INFO）
+     */
+    EVENT_IVS_QUEUENUM_DETECTION(0X00000263),
+    /**
+     * 生成图规则事件（对应 DEV_EVENT_GENERATEGRAPH_DETECTION_INFO）
+     */
+    EVENT_IVS_GENERATEGRAPH_DETECTION(0X00000264),
+    /**
+     * 交通违章-手动取证(对应  DEV_EVENT_TRAFFIC_PARKING_MANUAL_INFO)
+     */
+    EVENT_IVS_TRAFFIC_PARKING_MANUAL(0x00000265),
+    /**
+     * 安全帽检测事件(对应 DEV_EVENT_HELMET_DETECTION_INFO)
+     */
+    EVENT_IVS_HELMET_DETECTION(0x00000266),
+    /**
+     * 包裹堆积程度检测事件(对应 DEV_EVENT_DEPOSIT_DETECTION_INFO)
+     */
+    EVENT_IVS_DEPOSIT_DETECTION(0x00000267),
+    /**
+     * 热点异常报警事件(对应 DEV_EVENT_HOTSPOT_WARNING_INFO)
+     */
+    EVENT_IVS_HOTSPOT_WARNING(0x00000268),
+    /**
+     * 称重平台检测事件(对应 DEV_EVENT_WEIGHING_PLATFORM_DETECTION_INFO)
+     */
+    EVENT_IVS_WEIGHING_PLATFORM_DETECTION(0x00000269),
+    /**
+     * 课堂行为分析事件(对应 DEV_EVENT_CLASSROOM_BEHAVIOR_INFO)
+     */
+    EVENT_IVS_CLASSROOM_BEHAVIOR(0x0000026A),
+    /**
+     * 工装(安全帽/工作服等)检测事件(对应 DEV_EVENT_WORKCLOTHES_DETECT_INFO)
+     */
+    EVENT_IVS_WORKCLOTHES_DETECT(0x0000026E),
+    /**
+     * 立体视觉站立事件(对应DEV_EVENT_MANSTAND_DETECTION_INFO)
+     */
+    EVENT_IVS_MAN_STAND_DETECTION(0x0000020D),
+    /**
+     * 加油站车辆检测事件 (对应 DEV_EVENT_GASSTATION_VEHICLE_DETECT_INFO)
+     */
+    EVENT_IVS_GASSTATION_VEHICLE_DETECT(0x00000283),
+    /**
+     * 商铺占道经营事件(对应 DEV_EVENT_SHOPPRESENCE_INFO)
+     */
+    EVENT_IVS_SHOPPRESENCE(0x00000246),
+    /**
+     * 流动摊贩事件 (对应 DEV_EVENT_FLOWBUSINESS_INFO)
+     */
+    EVENT_IVS_FLOWBUSINESS(0x0000024E),
+    /**
+     * 行人卡口事件(对应 DEV_EVENT_PEDESTRIAN_JUNCTION_INFO)
+     */
+    EVENT_IVS_PEDESTRIAN_JUNCTION(0x00000230),
+    /**
+     * 拉横幅事件(对应 DEV_EVENT_BANNER_DETECTION_INFO)
+     */
+    EVENT_IVS_BANNER_DETECTION(0x0000023B),
+    /**
+     * 智慧厨房穿着检测事件（对不戴口罩、厨师帽以及颜色不符合规定的厨师服进行报警）（对应 DEV_EVENT_SMART_KITCHEN_CLOTHES_DETECTION_INFO）
+     */
+    EVENT_IVS_SMART_KITCHEN_CLOTHES_DETECTION(0x0000029D),
+    /**
+     * 水位监测事件
+     */
+    EVENT_IVS_WATER_STAGE_MONITOR(0x0000030A),
+    /**
+     * 暴力抛物检测(对应 DEV_EVENT_VIOLENT_THROW_DETECTION_INFO)
+     */
+    EVENT_IVS_VIOLENT_THROW_DETECTION(0x0000027D),
+    /**
+     * 人体温智能检测事件(对应 DEV_EVENT_ANATOMY_TEMP_DETECT_INFO)
+     */
+    EVENT_IVS_ANATOMY_TEMP_DETECT(0x00000303),
+    /**
+     * 起雾检测事件(对应 DEV_EVENT_FOG_DETECTION)
+     */
+    EVENT_IVS_FOG_DETECTION(0x00000308),
+    /**
+     * 视频异常事件(对应 DEV_EVENT_VIDEOABNORMALDETECTION_INFO)
+     */
+    EVENT_IVS_VIDEOABNORMALDETECTION(0x00000013),
+    /**
+     * 单人独处事件(对应 DEV_EVENT_STAY_ALONE_DETECTION_INFO)
+     */
+    EVENT_IVS_STAY_ALONE_DETECTION(0x00000270),
+    /**
+     * 看守所囚犯起身事件(对应 DEV_EVENT_PRISONERRISEDETECTION_INFO)
+     */
+    EVENT_IVS_PRISONERRISEDETECTION(0x0000011E),
+    /**
+     * 高空抛物检测(对应DEV_EVENT_HIGH_TOSS_DETECT_INFO)
+     */
+    EVENT_IVS_HIGH_TOSS_DETECT(0x0000028D),
+
+    /**
+     * 特征提取事件(对应 DEV_EVENT_FEATURE_ABSTRACT_INFO)
+     */
+    EVENT_IVS_FEATURE_ABSTRACT(0x00000276);
+
+    private final int id;
+
+    private EM_EVENT_IVS(int id) {
+        this.id = id;
+    }
+
+    public int getId() {
+        return id;
+    }
+
+}

web/src/main/java/com/zhehekeji/web/lib/enumeration/EM_EVENT_IVS_TYPE.java

@@ -0,0 +1,789 @@
+package com.zhehekeji.web.lib.enumeration;
+
+import com.zhehekeji.web.lib.NetSDKLib;
+import com.sun.jna.Callback;
+import com.sun.jna.Pointer;
+
+/**
+ * @author 47081
+ * @version 1.0
+ * @description 智能分析事件类型
+ * 对应接口{@link com.zhehekeji.web.lib.NetSDKLib#CLIENT_RealLoadPictureEx(NetSDKLib.LLong, int, int, int, Callback, Pointer, Pointer)}
+ * @date 2020/10/14
+ */
+public enum EM_EVENT_IVS_TYPE {
+    /**
+     * 订阅所有事件
+     */
+    EVENT_IVS_ALL(0x00000001, "所有事件"),
+    /**
+     * 警戒线事件
+     * 对应结构体{@link NetSDKLib.DEV_EVENT_CROSSLINE_INFO}
+     */
+    EVENT_IVS_CROSSLINEDETECTION(0x00000002, "警戒线事件"),
+    /**
+     * 警戒区事件
+     * 对应 {@link NetSDKLib.DEV_EVENT_CROSSREGION_INFO}
+     */
+    EVENT_IVS_CROSSREGIONDETECTION(0x00000003, "警戒区事件"),
+    /**
+     * 贴条事件
+     * 对应 {@see DEV_EVENT_PASTE_INFO}
+     */
+    EVENT_IVS_PASTEDETECTION(0x00000004, "贴条事件"),
+    /**
+     * 物品遗留事件
+     * (对应 {@link NetSDKLib.DEV_EVENT_LEFT_INFO})
+     */
+    EVENT_IVS_LEFTDETECTION(0x00000005, "物品遗留事件"),
+    /**
+     * 停留事件
+     * (对应 {@link NetSDKLib.DEV_EVENT_STAY_INFO})
+     */
+    EVENT_IVS_STAYDETECTION(0x00000006, "停留事件"),
+    /**
+     * 徘徊事件
+     * (对应 {@link NetSDKLib.DEV_EVENT_WANDER_INFO})
+     */
+    EVENT_IVS_WANDERDETECTION(0x00000007, "徘徊事件"),
+    /**
+     * 物品保全事件
+     * (对应 {@see DEV_EVENT_PRESERVATION_INFO})
+     */
+    EVENT_IVS_PRESERVATION(0x00000008, "物品保全事件"),
+    /**
+     * (对应 {@link NetSDKLib.DEV_EVENT_MOVE_INFO})
+     */
+    EVENT_IVS_MOVEDETECTION(0x00000009, "移动事件"),
+    /**
+     * {@see DEV_EVENT_TAIL_INFO}
+     */
+    EVENT_IVS_TAILDETECTION(0x0000000A, "尾随事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_RIOTERL_INFO}
+     */
+    EVENT_IVS_RIOTERDETECTION(0x0000000B, "聚众事件"),
+    /**
+     * {@see DEV_EVENT_FIRE_INFO}
+     */
+    EVENT_IVS_FIREDETECTION(0x0000000C, "火警事件"),
+    /**
+     * {@see DEV_EVENT_SMOKE_INFO}
+     */
+    EVENT_IVS_SMOKEDETECTION(0x0000000D, "烟雾报警事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_FIGHT_INFO}
+     */
+    EVENT_IVS_FIGHTDETECTION(0x0000000E, "斗殴事件"),
+    /**
+     * {@see DEV_EVENT_FLOWSTAT_INFO}
+     */
+    EVENT_IVS_FLOWSTAT(0x0000000F, "流量统计事件"),
+    /**
+     * {@see DEV_EVENT_NUMBERSTAT_INFO}
+     */
+    EVENT_IVS_NUMBERSTAT(0x00000010, "数量统计事件"),
+    EVENT_IVS_CAMERACOVERDDETECTION(0x00000011, "摄像头覆盖事件(保留)"),
+    EVENT_IVS_CAMERAMOVEDDETECTION(0x00000012, "摄像头移动事件(保留)"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_VIDEOABNORMALDETECTION_INFO}
+     */
+    EVENT_IVS_VIDEOABNORMALDETECTION(0x00000013, "视频异常事件"),
+    EVENT_IVS_VIDEOBADDETECTION(0x00000014, "视频损坏事件(保留)"),
+    /**
+     * {@see DEV_EVENT_TRAFFICCONTROL_INFO}
+     * <p>
+     * {@see }
+     */
+    EVENT_IVS_TRAFFICCONTROL(0x00000015, "交通管制事件"),
+    /**
+     * {@see DEV_EVENT_TRAFFICACCIDENT_INFO}
+     */
+    EVENT_IVS_TRAFFICACCIDENT(0x00000016, "交通事故事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_TRAFFICJUNCTION_INFO}
+     */
+    EVENT_IVS_TRAFFICJUNCTION(0x00000017, "交通路口事件----老规则"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_TRAFFICGATE_INFO}
+     */
+    EVENT_IVS_TRAFFICGATE(0x00000018, "交通卡口事件----老规则"),
+    /**
+     * {@see DEV_EVENT_TRAFFICSNAPSHOT_INFO}
+     */
+    EVENT_TRAFFICSNAPSHOT(0x00000019, "交通抓拍事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_FACEDETECT_INFO}
+     */
+    EVENT_IVS_FACEDETECT(0x0000001A, "人脸检测事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_TRAFFICJAM_INFO}
+     */
+    EVENT_IVS_TRAFFICJAM(0x0000001B, "交通拥堵事件"),
+    /**
+     * {@see DEV_EVENT_TRAFFIC_NONMOTORINMOTORROUTE_INFO}
+     */
+    EVENT_IVS_TRAFFIC_NONMOTORINMOTORROUTE(0x0000001C, "非机动车占机动车车道事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_TRAFFIC_RUNREDLIGHT_INFO}
+     */
+    EVENT_IVS_TRAFFIC_RUNREDLIGHT(0x00000100, "交通违章-闯红灯事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_TRAFFIC_OVERLINE_INFO}
+     */
+    EVENT_IVS_TRAFFIC_OVERLINE(0x00000101, "交通违章-压车道线事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_TRAFFIC_RETROGRADE_INFO}
+     */
+    EVENT_IVS_TRAFFIC_RETROGRADE(0x00000102, "交通违章-逆行事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_TRAFFIC_TURNLEFT_INFO}
+     */
+    EVENT_IVS_TRAFFIC_TURNLEFT(0x00000103, "交通违章-违章左转"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_TRAFFIC_TURNRIGHT_INFO}
+     */
+    EVENT_IVS_TRAFFIC_TURNRIGHT(0x00000104, "交通违章-违章右转"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_TRAFFIC_UTURN_INFO}
+     */
+    EVENT_IVS_TRAFFIC_UTURN(0x00000105, "交通违章-违章掉头"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_TRAFFIC_OVERSPEED_INFO}
+     */
+    EVENT_IVS_TRAFFIC_OVERSPEED(0x00000106, "交通违章-超速"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_TRAFFIC_UNDERSPEED_INFO}
+     */
+    EVENT_IVS_TRAFFIC_UNDERSPEED(0x00000107, "交通违章-低速"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_TRAFFIC_PARKING_INFO}
+     */
+    EVENT_IVS_TRAFFIC_PARKING(0x00000108, "交通违章-违章停车"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_TRAFFIC_WRONGROUTE_INFO}
+     */
+    EVENT_IVS_TRAFFIC_WRONGROUTE(0x00000109, "交通违章-不按车道行驶"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_TRAFFIC_CROSSLANE_INFO}
+     */
+    EVENT_IVS_TRAFFIC_CROSSLANE(0x0000010A, "交通违章-违章变道"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_TRAFFIC_OVERYELLOWLINE_INFO}
+     */
+    EVENT_IVS_TRAFFIC_OVERYELLOWLINE(0x0000010B, "交通违章-压黄线"),
+    /**
+     * {@see DEV_EVENT_TRAFFIC_DRIVINGONSHOULDER_INFO}
+     */
+    EVENT_IVS_TRAFFIC_DRIVINGONSHOULDER(0x0000010C, "交通违章-路肩行驶事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_TRAFFIC_YELLOWPLATEINLANE_INFO}
+     */
+    EVENT_IVS_TRAFFIC_YELLOWPLATEINLANE(0x0000010E, "交通违章-黄牌车占道事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_TRAFFIC_PEDESTRAINPRIORITY_INFO}
+     */
+    EVENT_IVS_TRAFFIC_PEDESTRAINPRIORITY(0x0000010F, "交通违章-礼让行人/斑马线行人优先事件"),
+    /**
+     * {@see DEV_EVENT_CROSSFENCEDETECTION_INFO}
+     */
+    EVENT_IVS_CROSSFENCEDETECTION(0x0000011F, "翻越围栏事件"),
+    /**
+     * {@see DEV_EVENT_ELECTROSPARK_INFO}
+     */
+    EVENT_IVS_ELECTROSPARKDETECTION(0x00000110, "电火花事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_TRAFFIC_NOPASSING_INFO}
+     */
+    EVENT_IVS_TRAFFIC_NOPASSING(0x00000111, "交通违章-禁止通行事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_ABNORMALRUNDETECTION_INFO}
+     */
+    EVENT_IVS_ABNORMALRUNDETECTION(0x00000112, "异常奔跑事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_RETROGRADEDETECTION_INFO}
+     */
+    EVENT_IVS_RETROGRADEDETECTION(0x00000113, "人员逆行事件"),
+    /**
+     * {@see DEV_EVENT_INREGIONDETECTION_INFO}
+     */
+    EVENT_IVS_INREGIONDETECTION(0x00000114, "区域内检测事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_TAKENAWAYDETECTION_INFO}
+     */
+    EVENT_IVS_TAKENAWAYDETECTION(0x00000115, "物品搬移事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_PARKINGDETECTION_INFO}
+     */
+    EVENT_IVS_PARKINGDETECTION(0x00000116, "非法停车事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_FACERECOGNITION_INFO}
+     */
+    EVENT_IVS_FACERECOGNITION(0x00000117, "人脸识别事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_TRAFFIC_MANUALSNAP_INFO}
+     */
+    EVENT_IVS_TRAFFIC_MANUALSNAP(0x00000118, "交通手动抓拍事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_TRAFFIC_FLOW_STATE}
+     */
+    EVENT_IVS_TRAFFIC_FLOWSTATE(0x00000119, "交通流量统计事件"),
+    /**
+     * {@see DEV_EVENT_TRAFFIC_STAY_INFO}
+     */
+    EVENT_IVS_TRAFFIC_STAY(0x0000011A, "交通滞留事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_TRAFFIC_VEHICLEINROUTE_INFO}
+     */
+    EVENT_IVS_TRAFFIC_VEHICLEINROUTE(0x0000011B, "有车占道事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_ALARM_INFO}
+     */
+    EVENT_ALARM_MOTIONDETECT(0x0000011C, "视频移动侦测事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_ALARM_INFO}
+     */
+    EVENT_ALARM_LOCALALARM(0x0000011D, "外部报警事件"),
+
+    /**
+     * {@link NetSDKLib.DEV_EVENT_PRISONERRISEDETECTION_INFO}
+     */
+    EVENT_IVS_PRISONERRISEDETECTION(0x0000011E, "看守所囚犯起身事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_TRAFFICJUNCTION_INFO}
+     */
+    EVENT_IVS_TRAFFIC_TOLLGATE(0x00000120, "交通违章-卡口事件----新规则"),
+    /**
+     * {@see DEV_EVENT_DENSITYDETECTION_INFO}
+     */
+    EVENT_IVS_DENSITYDETECTION(0x00000121, "人员密集度检测"),
+    /**
+     * {@link NetSDKLib.NET_VIDEODIAGNOSIS_COMMON_INFO}
+     * {@link NetSDKLib.NET_REAL_DIAGNOSIS_RESULT}
+     */
+    EVENT_IVS_VIDEODIAGNOSIS(0x00000122, "视频诊断结果事件"),
+    /**
+     * {@see DEV_EVENT_QUEUEDETECTION_INFO}
+     */
+    EVENT_IVS_QUEUEDETECTION(0x00000123, "排队检测报警事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_TRAFFIC_VEHICLEINBUSROUTE_INFO}
+     */
+    EVENT_IVS_TRAFFIC_VEHICLEINBUSROUTE(0x00000124, "占用公交车道事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_IVS_TRAFFIC_BACKING_INFO}
+     */
+    EVENT_IVS_TRAFFIC_BACKING(0x00000125, "违章倒车事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_IVS_AUDIO_ABNORMALDETECTION_INFO}
+     */
+    EVENT_IVS_AUDIO_ABNORMALDETECTION(0x00000126, "声音异常检测"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_TRAFFIC_RUNYELLOWLIGHT_INFO}
+     */
+    EVENT_IVS_TRAFFIC_RUNYELLOWLIGHT(0x00000127, "交通违章-闯黄灯事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_IVS_CLIMB_INFO}
+     */
+    EVENT_IVS_CLIMBDETECTION(0x00000128, "攀高检测事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_IVS_LEAVE_INFO}
+     */
+    EVENT_IVS_LEAVEDETECTION(0x00000129, "离岗检测事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_TRAFFIC_PARKINGONYELLOWBOX_INFO}
+     */
+    EVENT_IVS_TRAFFIC_PARKINGONYELLOWBOX(0x0000012A, "黄网格线抓拍事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_TRAFFIC_PARKINGSPACEPARKING_INFO}
+     */
+    EVENT_IVS_TRAFFIC_PARKINGSPACEPARKING(0x0000012B, "车位有车事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_TRAFFIC_PARKINGSPACENOPARKING_INFO}
+     */
+    EVENT_IVS_TRAFFIC_PARKINGSPACENOPARKING(0x0000012C, "车位无车事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_TRAFFIC_PEDESTRAIN_INFO}
+     */
+    EVENT_IVS_TRAFFIC_PEDESTRAIN(0x0000012D, "交通行人事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_TRAFFIC_THROW_INFO}
+     */
+    EVENT_IVS_TRAFFIC_THROW(0x0000012E, "交通抛洒物品事件"),
+    /**
+     * {@see DEV_EVENT_TRAFFIC_IDLE_INFO}
+     */
+    EVENT_IVS_TRAFFIC_IDLE(0x0000012F, "交通空闲事件"),
+    /**
+     * {@see DEV_EVENT_ALARM_VEHICLEACC_INFO}
+     */
+    EVENT_ALARM_VEHICLEACC(0x00000130, "车载ACC断电报警事件"),
+    /**
+     * {@see DEV_EVENT_VEHICEL_ALARM_INFO}
+     */
+    EVENT_ALARM_VEHICLE_TURNOVER(0x00000131, "车辆侧翻报警事件"),
+    /**
+     * {@see DEV_EVENT_VEHICEL_ALARM_INFO}
+     */
+    EVENT_ALARM_VEHICLE_COLLISION(0x00000132, "车辆撞车报警事件"),
+    EVENT_ALARM_VEHICLE_LARGE_ANGLE(0x00000133, "车载摄像头大角度扭转事件"),
+    /**
+     * {@see DEV_EVENT_TRAFFIC_PARKINGSPACEOVERLINE_INFO}
+     */
+    EVENT_IVS_TRAFFIC_PARKINGSPACEOVERLINE(0x00000134, "车位压线事件"),
+    /**
+     * {@see DEV_EVENT_IVS_MULTI_SCENE_SWICH_INFO}
+     */
+    EVENT_IVS_MULTISCENESWITCH(0x00000135, "多场景切换事件"),
+    /**
+     * {@see DEV_EVENT_TRAFFIC_RESTRICTED_PLATE}
+     */
+    EVENT_IVS_TRAFFIC_RESTRICTED_PLATE(0x00000136, "受限车牌事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_TRAFFIC_OVERSTOPLINE}
+     */
+    EVENT_IVS_TRAFFIC_OVERSTOPLINE(0x00000137, "压停止线事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_TRAFFIC_WITHOUT_SAFEBELT}
+     */
+    EVENT_IVS_TRAFFIC_WITHOUT_SAFEBELT(0x00000138, "交通未系安全带事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_TRAFFIC_DRIVER_SMOKING}
+     */
+    EVENT_IVS_TRAFFIC_DRIVER_SMOKING(0x00000139, "驾驶员抽烟事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_TRAFFIC_DRIVER_CALLING}
+     */
+    EVENT_IVS_TRAFFIC_DRIVER_CALLING(0x0000013A, "驾驶员打电话事件"),
+    /**
+     * {@link com.zhehekeji.web.lib.structure.DEV_EVENT_TRAFFIC_PEDESTRAINRUNREDLIGHT_INFO}
+     */
+    EVENT_IVS_TRAFFIC_PEDESTRAINRUNREDLIGHT(0x0000013B, "行人闯红灯事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_TRAFFIC_PASSNOTINORDER_INFO}
+     */
+    EVENT_IVS_TRAFFIC_PASSNOTINORDER(0x0000013C, "未按规定依次通行"),
+    EVENT_IVS_OBJECT_DETECTION(0x00000141, "物体特征检测事件"),
+    /**
+     * {@see DEV_EVENT_ALARM_ANALOGALRM_INFO}
+     */
+    EVENT_ALARM_ANALOGALARM(0x00000150, "模拟量报警通道的报警事件"),
+    EVENT_IVS_CROSSLINEDETECTION_EX(0x00000151, "警戒线扩展事件"),
+    EVENT_ALARM_COMMON(0x00000152, "普通录像"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_ALARM_VIDEOBLIND}
+     */
+    EVENT_ALARM_VIDEOBLIND(0x00000153, "视频遮挡事件"),
+    EVENT_ALARM_VIDEOLOSS(0x00000154, "视频丢失事件"),
+    /**
+     * {@see DEV_EVENT_GETOUTBED_INFO}
+     */
+    EVENT_IVS_GETOUTBEDDETECTION(0x00000155, "看守所下床事件"),
+    /**
+     * {@see DEV_EVENT_PATROL_INFO}
+     */
+    EVENT_IVS_PATROLDETECTION(0x00000156, "巡逻检测事件"),
+    /**
+     * {@see DEV_EVENT_ONDUTY_INFO}
+     */
+    EVENT_IVS_ONDUTYDETECTION(0x00000157, "站岗检测事件"),
+    EVENT_IVS_NOANSWERCALL(0x00000158, "门口机呼叫未响应事件"),
+    EVENT_IVS_STORAGENOTEXIST(0x00000159, "存储组不存在事件"),
+    EVENT_IVS_STORAGELOWSPACE(0x0000015A, "硬盘空间低报警事件"),
+    EVENT_IVS_STORAGEFAILURE(0x0000015B, "存储错误事件"),
+    /**
+     * {@see DEV_EVENT_PROFILE_ALARM_TRANSMIT_INFO}
+     */
+    EVENT_IVS_PROFILEALARMTRANSMIT(0x0000015C, "报警传输事件"),
+    /**
+     * {@see DEV_EVENT_ALARM_VIDEOSTATIC_INFO}
+     */
+    EVENT_IVS_VIDEOSTATIC(0x0000015D, "视频静态检测事件"),
+    /**
+     * {@see DEV_EVENT_ALARM_VIDEOTIMING_INFO}
+     */
+    EVENT_IVS_VIDEOTIMING(0x0000015E, "视频定时检测事件"),
+    /**
+     * {@see CFG_IVS_HEATMAP_INFO}
+     */
+    EVENT_IVS_HEATMAP(0x0000015F, "热度图"),
+    /**
+     * {@see DEV_EVENT_ALARM_CITIZENIDCARD_INFO}
+     */
+    EVENT_IVS_CITIZENIDCARD(0x00000160, "身份证信息读取事件"),
+    /**
+     * {@see DEV_EVENT_ALARM_PIC_INFO}
+     */
+    EVENT_IVS_PICINFO(0x00000161, "图片信息事件"),
+    /**
+     * {@see DEV_EVENT_ALARM_NETPLAYCHECK_INFO}
+     */
+    EVENT_IVS_NETPLAYCHECK(0x00000162, "上网登记事件"),
+    /**
+     * {@see DEV_EVENT_ALARM_JAMFORBIDINTO_INFO}
+     */
+    EVENT_IVS_TRAFFIC_JAM_FORBID_INTO(0x00000163, "车辆拥堵禁入事件"),
+    /**
+     * {@see EV_EVENT_SNAPBYTIME}
+     */
+    EVENT_IVS_SNAPBYTIME(0x00000164, "定时抓图事件"),
+    EVENT_IVS_PTZ_PRESET(0x00000165, "云台转动到预置点事件"),        // (对应 DEV_EVENT_ALARM_PTZ_PRESET_INFO)
+    EVENT_IVS_RFID_INFO(0x00000166, "红外线检测信息事件"),        // (对应 DEV_EVENT_ALARM_RFID_INFO)
+    EVENT_IVS_STANDUPDETECTION(0x00000167, "人起立检测事件"),        //
+    EVENT_IVS_QSYTRAFFICCARWEIGHT(0x00000168, "交通卡口称重事件"),        // (对应 DEV_EVENT_QSYTRAFFICCARWEIGHT_INFO)
+    EVENT_IVS_TRAFFIC_COMPAREPLATE(0x00000169, "卡口前后车牌合成事件"),        // (对应DEV_EVENT_TRAFFIC_COMPAREPLATE_INFO)
+    EVENT_IVS_SHOOTINGSCORERECOGNITION(0x0000016A, "打靶像机事件"),        // (对应 DEV_EVENT_SHOOTING_SCORE_RECOGNITION_INFO,CFG_IVS_SHOOTINGSCORERECOGNITION_INFO)
+    EVENT_IVS_TRAFFIC_FCC(0x0000016B, "加油站提枪、挂枪事件"),        // (对应 DEV_EVENT_TRAFFIC_FCC_INFO)
+    EVENT_IVS_TRAFFIC_TRANSFINITE(0x0000016C, "违章超限抓图上报事件"),        // ,绍兴科技治超(对应 DEV_EVENT_TRAFFIC_TRANSFINITE_INFO)
+    EVENT_IVS_SCENE_CHANGE(0x0000016D, "场景变更事件"),        // (对应 DEV_ALRAM_SCENECHANGE_INFO,CFG_VIDEOABNORMALDETECTION_INFO)
+    EVENT_IVS_LETRACK(0x0000016E, "简单跟踪事件(暂未有具体事件)"),        //
+    EVENT_IVS_OBJECT_ACTION(0x0000016F, "物体检测事件(暂未有具体事件)"),        //
+    EVENT_IVS_TRAFFIC_ANALYSE_PRESNAP(0x00000170, "预分析抓拍图片事件"),        // (对应 DEV_EVENT_TRAFFIC_ANALYSE_PRESNAP_INFO)
+    EVENT_ALARM_EQSTATE(0x00000171, "智能插座电量状态上报(暂未有具体事件)"),        //
+    EVENT_IVS_ALARM_IPC(0x00000172, "DVR/NVR设备上的IPC报警"),        // (对应 DEV_EVENT_ALARM_IPC_INFO)
+    EVENT_IVS_POS_RECORD(0x00000173, "POS录像查询事件(暂未有具体事件)"),        //
+    EVENT_IVS_NEAR_DISTANCE_DETECTION(0x00000174, "近距离接触事件"),        // (对应 DEV_EVENT_NEAR_DISTANCE_DETECTION_INFO)
+    EVENT_IVS_OBJECTSTRUCTLIZE_PERSON(0x00000175, "行人特征检测事件"),        // (对应 DEV_EVENT_OBJECTSTRUCTLIZE_PERSON_INFO)
+    EVENT_IVS_OBJECTSTRUCTLIZE_NONMOTOR(0x00000176, "非机动车特征检测事件"),        // (对应 DEV_EVENT_OBJECTSTRUCTLIZE_NONMOTOR_INFO)
+    EVENT_IVS_TUMBLE_DETECTION(0x00000177, "倒地报警事件"),        // (对应 DEV_EVENT_TUMBLE_DETECTION_INFO)
+    /**
+     * 所有以traffic开头的事件
+     * 目前指的是
+     * EVENT_IVS_TRAFFICCONTROL -> EVENT_TRAFFICSNAPSHOT
+     * EVENT_IVS_TRAFFIC_RUNREDLIGHT -> EVENT_IVS_TRAFFIC_UNDERSPEED
+     */
+    EVENT_IVS_TRAFFIC_ALL(0x000001FF, "所有以traffic开头的事件"),
+    EVENT_IVS_VIDEOANALYSE(0x00000200, "所有智能分析事件"),
+    EVENT_IVS_LINKSD(0x00000201, "LinkSD事件"),      // (对应 DEV_EVENT_LINK_SD)
+    EVENT_IVS_VEHICLEANALYSE(0x00000202, "车辆特征检测分析"),      // (对应DEV_EVENT_VEHICLEANALYSE)
+    EVENT_IVS_FLOWRATE(0x00000203, "流量使用情况事件"),      // (对应 DEV_EVENT_FLOWRATE_INFO)
+    /**
+     * {@link NetSDKLib.DEV_EVENT_ACCESS_CTL_INFO}
+     */
+    EVENT_IVS_ACCESS_CTL(0x00000204, "门禁事件"),
+    /**
+     * {@link NetSDKLib.DEV_EVENT_SNAPMANUAL}
+     */
+    EVENT_IVS_SNAPMANUAL(0x00000205, "SnapManual事件"),
+    EVENT_IVS_TRAFFIC_ELETAGINFO(0x00000206, "RFID电子车牌标签事件"),      // (对应 DEV_EVENT_TRAFFIC_ELETAGINFO_INFO)
+    EVENT_IVS_TRAFFIC_TIREDPHYSIOLOGICAL(0x00000207, "生理疲劳驾驶事件"),      // (对应 DEV_EVENT_TIREDPHYSIOLOGICAL_INFO)
+    EVENT_IVS_TRAFFIC_BUSSHARPTURN(0x00000208, "车辆急转报警事件"),      // (对应DEV_EVENT_BUSSHARPTURN_INFO)
+    EVENT_IVS_CITIZEN_PICTURE_COMPARE(0x00000209, "人证比对事件"),      // (对应 DEV_EVENT_CITIZEN_PICTURE_COMPARE_INFO)
+    EVENT_IVS_TRAFFIC_TIREDLOWERHEAD(0x0000020A, "开车低头报警事件"),      // (对应DEV_EVENT_TIREDLOWERHEAD_INFO)
+    EVENT_IVS_TRAFFIC_DRIVERLOOKAROUND(0x0000020B, "开车左顾右盼报警事件"),      // (对应DEV_EVENT_DRIVERLOOKAROUND_INFO)
+    EVENT_IVS_TRAFFIC_DRIVERLEAVEPOST(0x0000020C, "开车离岗报警事件"),      // (对应DEV_EVENT_DRIVERLEAVEPOST_INFO)
+    EVENT_IVS_MAN_STAND_DETECTION(0x0000020D, "立体视觉站立事件"),      // (对应DEV_EVENT_MANSTAND_DETECTION_INFO)
+    EVENT_IVS_MAN_NUM_DETECTION(0x0000020E, "立体视觉区域内人数统计事件"),      // (对应DEV_EVENT_MANNUM_DETECTION_INFO)
+    EVENT_IVS_STEREO_NUMBERSTAT(0x0000020F, "客流量统计事件"),      // (暂未有具体事件)
+    EVENT_IVS_TRAFFIC_DRIVERYAWN(0x00000210, "开车打哈欠事件"),      // (对应DEV_EVENT_DRIVERYAWN_INFO)
+    EVENT_IVS_NUMBERSTAT_PLAN(0x00000211, "客流量统计计划"),      // (暂未有具体事件,球机使用,对应规则配置结构体 CFG_NUMBERSTAT_INFO)
+    EVENT_IVS_HEATMAP_PLAN(0x00000212, "热度图计划"),      // (暂未有具体事件,球机使用,对应规则配置结构体 CFG_IVS_HEATMAP_INFO)
+    EVENT_IVS_CALLNOANSWERED(0x00000213, "呼叫无答应事件"),      //
+    EVENT_IVS_IGNOREINVITE(0x00000214, "无视邀请事件"),      //
+    EVENT_IVS_HUMANTRAIT(0x00000215, "人体特征事件"),      // (对应 DEV_EVENT_HUMANTRAIT_INFO)
+    EVENT_ALARM_LE_HEADDETECTION(0x00000216, "乐橙人头检测事件"),      // (对应 DEV_EVENT_LE_HEADDETECTION_INFO)
+    EVENT_IVS_FACEANALYSIS(0x00000217, "人脸分析事件"),      //  (暂未有具体事件)
+    EVENT_IVS_TRAFFIC_TURNLEFTAFTERSTRAIGHT(0x00000218, "左转不礼让直行事件"),      // (对应 DEV_EVENT_TURNLEFTAFTERSTRAIGHT_INFO)
+    EVENT_IVS_TRAFFIC_BIGBENDSMALLTURN(0x00000219, "大弯小转事件"),      // (对应 DEV_EVENT_BIGBENDSMALLTURN_INFO)
+    EVENT_IVS_ROAD_CONSTRUCTION(0x0000021A, "道路施工监测事件"),      // (对应DEV_EVENT_ROAD_CONSTRUCTION_INFO)
+    EVENT_IVS_ROAD_BLOCK(0x0000021B, "路障检测事件"),      // (对应DEV_EVENT_ROAD_BLOCK_INFO)
+    EVENT_IVS_TRAFFIC_QUEUEJUMP(0x0000021C, "车辆加塞事件"),      // (对应 DEV_EVENT_TRAFFIC_QUEUEJUMP_INFO)
+    EVENT_IVS_VEHICLE_SUSPICIOUSCAR(0x0000021D, "嫌疑车辆事件"),      // (对应 DEV_EVENT_VEHICLE_SUSPICIOUSCAR_INFO)
+    EVENT_IVS_TRAFFIC_TURNRIGHTAFTERSTRAIGHT(0x0000021E, "右转不礼让直行事件"),    // (对应 DEV_EVENT_TURNRIGHTAFTERSTRAIGHT_INFO)
+    EVENT_IVS_TRAFFIC_TURNRIGHTAFTERPEOPLE(0x0000021F, "右转不礼让直行行人"),    // (对应 DEV_EVENT_TURNRIGHTAFTERPEOPLE_INFO)
+    EVENT_IVS_INSTALL_CARDREADER(0x00000220, "安装读卡器事件"),      // (对应 DEV_EVENT_INSTALL_CARDREADER_INFO)
+    EVENT_ALARM_YALE_DROPBOX_BADTOKEN(0x00000221, " Yale token失效事件，只用于订阅手机推送"),      //
+    EVENT_IVS_ACC_OFF_SNAP(0x00000222, "车载设备断电前抓拍上传事件"),      // (对应 DEV_EVENT_ACC_OFF_SNAP_INFO)
+    EVENI_IVS_XRAY_DETECTION(0x00000223, "X光检测事件"),        //  (对应 DEV_EVENT_XRAY_DETECTION_INFO)
+    EVENT_IVS_NOTCLEARCAR(0x00000224, "未清车告警"),        // (对应 DEV_EVENT_NOTCLEARCAR_INFO)
+    EVENT_IVS_SOSALEART(0x00000225, "sos求救报警"),        // (对应 DEV_EVENT_SOSALEART_INFO)
+    EVENT_IVS_OVERLOAD(0x00000226, "超载抓图"),        // (对应 DEV_EVENT_OVERLOAD_INFO)
+    EVENT_IVS_NONWORKINGTIME(0x00000227, "非工作时间告警"),        // (对应 DEV_EVENT_NONWORKINGTIME_INFO)
+    EVENT_IVS_TRAFFIC_HIGH_BEAM(0x00000228, "远光灯违章事件"),        // (对应 DEV_EVENT_TRAFFIC_HIGH_BEAM_INFO)
+    EVENT_IVS_TRAFFIC_TRUCKFORBID(0x00000229, "禁止货车事件"),        // (对应 DEV_EVENT_TRAFFICTRUCKFORBID_INFO)
+    EVENT_IVS_DRIVINGWITHOUTCARD(0x0000022A, "无卡驾驶报警事件"),        // (对应 DEV_EVENT_DRIVINGWITHOUTCARD_INFO)
+    EVENT_IVS_HIGHSPEED(0x0000022B, "车辆超速报警事件"),        // (对应 DEV_EVENT_HIGHSPEED_INFO)
+    EVENT_IVS_CROWDDETECTION(0x0000022C, "人群密度检测事件"),        // (对应结构体 DEV_EVENT_CROWD_DETECTION_INFO)
+    EVENT_IVS_TRAFFIC_CARDISTANCESHORT(0x0000022D, "车间距过小报警事件"),        // (对应 DEV_EVENT_TRAFFIC_CARDISTANCESHORT_INFO)
+    /**
+     * {@link NetSDKLib.DEV_EVENT_PEDESTRIAN_JUNCTION_INFO}
+     */
+    EVENT_IVS_PEDESTRIAN_JUNCTION(0x00000230, "行人卡口事件"),
+    EVENT_IVS_VEHICLE_RECOGNITION(0x00000231, "车牌对比事件"),      // (中石化智慧加油站项目)(对应 DEV_EVENT_VEHICLE_RECOGNITION_INFO)
+    EVENT_IVS_PASS_CHANGE(0x00000232, "预置点图片变化事件"),        //  (对应 DEV_EVENT_PASS_CHANGE_INFO)
+    EVENT_IVS_TRAFFIC_PARKING_SPACEDETECTION(0x00000233, "违停相机定制单球车位检测规则事件"),        //
+    EVENT_IVS_TRAFFIC_WAITINGAREA(0x00000234, "违章进入待行区事件"),        // (对应 DEV_EVENT_TRAFFIC_WAITINGAREA_INFO)
+    EVENT_IVS_TRAFFIC_BAN(0x00000235, "机动车违法禁令标识事件"),        // (对应 DEV_EVENT_TRAFFIC_BAN_INFO)
+    EVENT_IVS_POS_EXCHANGE(0x00000236, "POS机交易事件"),        // (对应 DEV_EVENT_POS_EXCHANGE_INFO)
+    EVENT_IVS_STEREO_FIGHTDETECTION(0x00000237, "立体行为分析打架/剧烈运动检测规则"),      // (仅用于规则配置，对应事件 EVENT_IVS_FIGHTDETECTION)
+    EVENT_IVS_STEREO_DISTANCE_DETECTION(0x00000238, "立体行为分析间距异常/人员靠近检测"),        // (仅用于规则配置，对应事件)
+    EVENT_IVS_STEREO_STEREOFALLDETECTION(0x00000239, "立体行为分析跌倒检测规则"),      // (仅用于规则配置，对应事件 EVENT_IVS_TUMBLE_DETECTION)
+    EVENT_IVS_STEREO_STAYDETECTION(0x0000023A, "立体行为分析人员滞留检测规则"),      // (仅用于规则配置，对应事件 EVENT_IVS_STAYDETECTION)
+    EVENT_IVS_BANNER_DETECTION(0x0000023B, "拉横幅事件"),        // (对应 DEV_EVENT_BANNER_DETECTION_INFO)
+    EVENT_IVS_NORMAL_FIGHTDETECTION(0x0000023C, "普通打架事件"),      // (只用于普通打架规则, 事件采用EVENT_IVS_FIGHTDETECTION)
+    EVENT_IVS_ELEVATOR_ABNORMAL(0x0000023D, "电动扶梯运行异常事件"),        //  (对应DEV_EVENT_ELEVATOR_ABNORMAL_INFO)
+    EVENT_IVS_NONMOTORDETECT(0x0000023E, "非机动车检测"),      //  (对应结构体 DEV_EVENT_NONMOTORDETECT_INFO)
+    EVENT_IVS_VEHICLEDETECT(0x0000023F, "机动车检测"),      //  (只用于规则配置，事件采用EVENT_IVS_TRAFFICJUNCTION)
+    EVENT_IVS_TRAFFIC_PARKING_B(0x00000240, "交通违章-B类违章停车"),      // (对应 DEV_EVENT_TRAFFIC_PARKING_B_INFO)
+    EVENT_IVS_TRAFFIC_PARKING_C(0x00000241, "交通违章-C类违章停车"),      // (对应 DEV_EVENT_TRAFFIC_PARKING_C_INFO)
+    EVENT_IVS_TRAFFIC_PARKING_D(0x00000242, "交通违章-D类违章停车"),      // (对应 DEV_EVENT_TRAFFIC_PARKING_D_INFO)
+    EVENT_IVSS_FACEATTRIBUTE(0x00000243, "IVSS人脸检测事件 (暂未有具体事件)"),      //
+    EVENT_IVSS_FACECOMPARE(0x00000244, "IVSS人脸识别事件 (暂未有具体事件)"),      //
+    EVENT_IVS_FIREWARNING(0x00000245, "火警事件"),        // (对应 DEV_EVENT_FIREWARNING_INFO)
+    EVENT_IVS_SHOPPRESENCE(0x00000246, "商铺占道经营事件"),      // (对应 DEV_EVENT_SHOPPRESENCE_INFO)
+    EVENT_IVS_WASTEDUMPED(0x00000247, "垃圾违章倾倒事件"),      // (对应 DEV_EVENT_WASTEDUMPED_INFO)
+    EVENT_IVS_SPILLEDMATERIAL_DETECTION(0x00000248, "抛洒物检测事件"),      // (对应 DEV_EVENT_SPILLEDMATERIAL_DETECTION_INFO)
+    EVENT_IVS_STEREO_MANNUM_DETECTION(0x00000249, "立体行为分析人数异常检测"),        //  (仅用于规则配置，对应事件 EVENT_IVS_MAN_NUM_DETECTION)
+    EVENT_IVS_DISTANCE_DETECTION(0x0000024A, "异常间距事件 "),        // (对应 DEV_EVENT_DISTANCE_DETECTION_INFO)
+    EVENT_IVS_TRAFFIC_NONMOTOR_OVERLOAD(0x0000024B, "非机动车超载事件"),        //  (对应 DEV_EVENT_TRAFFIC_NONMOTOR_OVERLOAD_INFO)
+    EVENT_IVS_TRAFFIC_NONMOTOR_WITHOUTSAFEHAT(0x0000024C, "非机动车未戴安全帽事件"),    //  (对应 DEV_EVENT_TRAFFIC_NONMOTOR_WITHOUTSAFEHAT_INFO)
+    EVENT_IVS_TRAFFIC_JAM_STOP_ON_ZEBRACROSSING(0x0000024D, "拥堵滞留斑马线事件"),        //  (对应 DEV_EVENT_TRAFFIC_JAM_STOP_ON_ZEBRACROSSING_INFO)
+
+    EVENT_IVS_FLOWBUSINESS(0x0000024E, "流动摊贩事件"),        //  (对应 DEV_EVENT_FLOWBUSINESS_INFO)
+
+    EVENT_IVS_CITY_MOTORPARKING(0x0000024F, "城市机动车违停事件"),        //  (对应 DEV_EVENT_CITY_MOTORPARKING_INFO)
+
+    EVENT_IVS_CITY_NONMOTORPARKING(0x00000250, "城市机非动车违停事件"),        //  (对应 DEV_EVENT_CITY_NONMOTORPARKING_INFO)
+
+    EVENT_IVS_LANEDEPARTURE_WARNNING(0X00000251, "车道偏移预警"),        // (对应 DEV_EVENT_LANEDEPARTURE_WARNNING_INFO)
+
+    EVENT_IVS_FORWARDCOLLISION_WARNNING(0x00000252, "前向碰撞预警"),        // (对应 DEV_EVENT_FORWARDCOLLISION_WARNNING_INFO)
+
+    EVENT_IVS_MATERIALSSTAY(0x00000253, "物料堆放事件"),        // (对应 DEV_EVENT_MATERIALSSTAY_INFO)
+
+    EVENT_IVS_TRAFFIC_NONMOTOR_HOLDUMBRELLA(0x00000254, "非机动车装载伞具"),        // (对应 DEV_EVENT_TRAFFIC_NONMOTOR_HOLDUMBRELLA_INFO)
+
+    EVENT_IVS_JABLOTRON_ALARM(0x00000255, "客户报警产品"),        //
+
+    EVENT_IVS_VIDEOUNFOCUS_ALARM(0x00000256, "视频虚焦事件"),        // (对应DEV_EVENT_VIDEOUNFOCUS_INFO)
+
+    EVENT_IVS_FLOATINGOBJECT_DETECTION(0x00000257, "漂浮物检测事件"),        //  (对应 DEV_EVENT_FLOATINGOBJECT_DETECTION_INFO)
+
+    EVENT_IVS_SHIP_DETECTION(0x00000258, "船舶检测事件"),        //  (对应 DEV_EVENT_SHIP_DETECTION_INFO)
+
+    EVENT_IVS_AIRPLANE_DETECTION(0x00000259, "飞机行为检测事件"),        // (对应 DEV_EVENT_AIRPLANE_DETECTION_INFO)
+
+    EVENT_IVS_PHONECALL_DETECT(0x0000025A, "打电话检测事件"),        // (对应 DEV_EVENT_PHONECALL_DETECT_INFO)
+
+    EVENT_IVS_SMOKING_DETECT(0x0000025B, "吸烟检测事件"),        // (对应 DEV_EVENT_SMOKING_DETECT_INFO)
+
+    EVENT_IVS_RADAR_SPEED_LIMIT_ALARM(0x0000025C, "雷达限速报警事件"),      // (对应 DEV_EVENT_RADAR_SPEED_LIMIT_ALARM_INFO)
+
+    EVENT_IVS_WATER_LEVEL_DETECTION(0x0000025D, "水位检测事件"),        //  (对应 DEV_EVENT_WATER_LEVEL_DETECTION_INFO)
+
+    EVENT_IVS_HOLD_UMBRELLA(0x0000025E, "违规撑伞检测事件"),        //  (对应 DEV_EVENT_HOLD_UMBRELLA_INFO)
+
+    EVENT_IVS_GARBAGE_EXPOSURE(0x0000025F, "垃圾暴露检测事件"),        //  (对应 DEV_EVENT_GARBAGE_EXPOSURE_INFO)
+
+    EVENT_IVS_DUSTBIN_OVER_FLOW(0x00000260, "垃圾桶满溢检测事件"),        //  (对应 DEV_EVENT_DUSTBIN_OVER_FLOW_INFO)
+
+    EVENT_IVS_DOOR_FRONT_DIRTY(0x00000261, "门前脏乱检测事件"),        //  (对应 DEV_EVENT_DOOR_FRONT_DIRTY_INFO)
+
+    EVENT_IVS_QUEUESTAY_DETECTION(0X00000262, "排队滞留时间报警事件"),        //  (对应 DEV_EVENT_QUEUESTAY_DETECTION_INFO)
+
+    EVENT_IVS_QUEUENUM_DETECTION(0X00000263, "排队人数异常报警事件"),        // （对应 DEV_EVENT_QUEUENUM_DETECTION_INFO）
+
+    EVENT_IVS_GENERATEGRAPH_DETECTION(0X00000264, "生成图规则事件"),        // （对应 DEV_EVENT_GENERATEGRAPH_DETECTION_INFO）
+
+    EVENT_IVS_TRAFFIC_PARKING_MANUAL(0x00000265, "交通违章-手动取证"),        // (对应 DEV_EVENT_TRAFFIC_PARKING_MANUAL_INFO)
+
+    EVENT_IVS_HELMET_DETECTION(0x00000266, "安全帽检测事件"),        // (对应 DEV_EVENT_HELMET_DETECTION_INFO)
+
+    EVENT_IVS_DEPOSIT_DETECTION(0x00000267, "包裹堆积程度检测事件"),        // (对应 DEV_EVENT_DEPOSIT_DETECTION_INFO)
+
+    EVENT_IVS_HOTSPOT_WARNING(0x00000268, "热点异常报警事件"),        // (对应 DEV_EVENT_HOTSPOT_WARNING_INFO)
+
+    EVENT_IVS_WEIGHING_PLATFORM_DETECTION(0x00000269, "称重平台检测事件"),        // (对应 DEV_EVENT_WEIGHING_PLATFORM_DETECTION_INFO)
+
+    EVENT_IVS_CLASSROOM_BEHAVIOR(0x0000026A, "课堂行为分析事件"),        // (对应 DEV_EVENT_CLASSROOM_BEHAVIOR_INFO)
+
+    EVENT_IVS_VEHICLE_DISTANCE_NEAR(0x0000026B, "安全驾驶车距过近报警事件"),        // (对应 DEV_EVENT_VEHICLE_DISTANCE_NEAR_INFO)
+
+    EVENT_IVS_TRAFFIC_DRIVER_ABNORMAL(0x0000026C, "驾驶员异常报警事件"),        // (对应 DEV_EVENT_TRAFFIC_DRIVER_ABNORMAL_INFO)
+
+    EVENT_IVS_TRAFFIC_DRIVER_CHANGE(0x0000026D, "驾驶员变更报警事件"),        // (对应 DEV_EVENT_TRAFFIC_DRIVER_CHANGE_INFO)
+
+    EVENT_IVS_WORKCLOTHES_DETECT(0x0000026E, "工装(安全帽/工作服等)检测事件"),        // (对应 DEV_EVENT_WORKCLOTHES_DETECT_INFO)
+
+    EVENT_IVS_SECURITYGATE_PERSONALARM(0x0000026F, "安检门人员报警事件"),      // (对应 DEV_EVENT_SECURITYGATE_PERSONALARM_INFO)
+
+    EVENT_IVS_STAY_ALONE_DETECTION(0x00000270, "单人独处事件"),        // (对应 DEV_EVENT_STAY_ALONE_DETECTION_INFO)
+
+    EVENT_IVS_TRAFFIC_ROAD_BLOCK(0x00000271, "交通路障检测事件"),        // (对应 DEV_EVENT_TRAFFIC_ROAD_BLOCK_INFO)
+
+    EVENT_IVS_TRAFFIC_ROAD_CONSTRUCTION(0x00000272, "交通道路施工检测事件"),        // (对应 DEV_EVENT_TRAFFIC_ROAD_CONSTRUCTION_INFO)
+
+    EVENT_IVS_XRAY_DETECT_BYOBJECT(0x00000273, "X光按物体检测规则配置"),        // , 对应事件 EVENI_IVS_XRAY_DETECTION
+
+    EVENT_IVS_WORKSTATDETECTION(0x00000274, "作业统计事件"),        // (对应 DEV_EVENT_WORKSTATDETECTION_INFO)
+
+    EVENT_IVS_INFRAREDBLOCK(0x00000275, "红外阻断事件"),        // (对应 DEV_EVENT_INFRAREDBLOCK_INFO)
+
+    EVENT_IVS_FEATURE_ABSTRACT(0x00000276, "特征提取事件"),        // (对应 DEV_EVENT_FEATURE_ABSTRACT_INFO)
+
+    EVENT_IVS_INTELLI_SHELF(0x00000277, "智能补货事件"),        // (对应 DEV_EVENT_INTELLI_SHELF_INFO)
+
+    EVENT_IVS_PANORAMA_SHOT(0x00000278, "全景抓拍事件"),        // (对应 DEV_EVENT_PANORAMA_SHOT_INFO)
+
+    EVENT_ALARM_SMARTMOTION_HUMAN(0x00000279, "智能视频移动侦测事件(人)"),      // ，目前只用于订阅手机推送, 无具体事件
+
+    EVENT_ALARM_SMARTMOTION_VEHICLE(0x0000027A, "智能视频移动侦测事件(车)"),      // ,目前只用于订阅手机推送, 无具体事件
+
+    EVENT_IVS_CAR_DRIVING_IN_OUT(0x0000027B, "车辆驶入驶出状态事件"),        // (对应 DEV_EVENT_CAR_DRIVING_IN_OUT_INFO)
+
+    EVENT_IVS_PARKINGSPACE_STATUS(0x0000027C, "停车位状态事件"),        // (对应 DEV_EVENT_PARKINGSPACE_STATUS_INFO)
+
+    EVENT_IVS_VIOLENT_THROW_DETECTION(0x0000027D, "暴力抛物检测"),        // (对应 DEV_EVENT_VIOLENT_THROW_DETECTION_INFO)
+
+    EVENT_IVS_TRAMCARSECTIONS_DETECTION(0x0000027E, "矿车超挂报警事件"),        // (对应 DEV_EVENT_TRAMCARSECTIONS_DETECTION_INFO)
+
+    EVENT_IVS_ALARM_BOX_ALARM(0x0000027F, "报警盒通道的触发报警事件"),      // , 目前只用于订阅手机推送
+
+    EVENT_IVS_FACE_COMPARISION(0x00000280, "人脸比对事件"),      // , 专用于手机推送的人脸识别事件, 目前只用于订阅手机推送
+
+    EVENT_IVS_FACEBODY_DETECT(0x00000281, "人像检测事件"),        // （对应 DEV_EVENT_FACEBODY_DETECT_INFO）
+
+    EVENT_IVS_FACEBODY_ANALYSE(0x00000282, "人像识别事件"),        // （对应 DEV_EVENT_FACEBODY_ANALYSE_INFO）
+
+    EVENT_IVS_GASSTATION_VEHICLE_DETECT(0x00000283, "加油站车辆检测事件"),      //  (对应 DEV_EVENT_GASSTATION_VEHICLE_DETECT_INFO)
+
+    EVENT_IVS_CONGESTION_DETECTION(0x00000284, "道路场景车辆拥堵报警事件"),        // （对应 DEV_EVENT_CONGESTION_DETECTION_INFO）
+
+    EVENT_IVS_VEHICLELIMIT_DETECTION(0x00000285, "停车场场景下停车车辆上限报警"),        // （对应 DEV_EVENT_VEHICLELIMIT_DETECTION_INFO）
+
+    EVENT_IVS_ANIMAL_DETECTION(0x00000286, "动物检测事件"),      // ,(对应 DEV_EVENT_ANIMAL_DETECTION_INFO)
+    /**
+     * {@link com.zhehekeji.web.lib.structure.DEV_EVENT_SHOP_WINDOW_POST_INFO}
+     */
+
+    EVENT_IVS_SHOP_WINDOW_POST(0x00000287, "橱窗张贴事件"),
+    /**
+     * (对应 DEV_EVENT_SHOP_SIGN_ABNORMAL_INFO)
+     * {@link com.zhehekeji.web.lib.structure.DEV_EVENT_SHOP_SIGN_ABNORMAL_INFO}
+     */
+    EVENT_IVS_SHOP_SIGN_ABNORMAL(0x00000288, "店招异常事件"),
+
+    EVENT_IVS_BREED_DETECTION(0x00000289, "智慧养殖检测事件"),      //  (对应 DEV_EVENT_BREED_DETECTION_INFO)
+
+    EVENT_IVS_AIRPORT_VEHICLE_DETECT(0x0000028A, "机场智能保障车辆检测事件"),        //  (对应 DEV_EVENT_AIRPORT_VEHICLE_DETECT_INFO)
+
+    EVENT_IVS_PIG_TEMPERATURE_DETECT(0x0000028B, "智慧养殖猪体温检测"),      //  (只用于规则配置)
+
+    EVENT_IVS_MAN_CAR_COEXISTANCE(0x0000028C, "人车共存事件"),      //  (对应 DEV_EVENT_MAN_CAR_COEXISTANCE_INFO)
+
+    EVENT_IVS_HIGH_TOSS_DETECT(0x0000028D, "高空抛物检测"),      // (对应DEV_EVENT_HIGH_TOSS_DETECT_INFO)
+
+    EVENT_IVS_ELECTRIC_GLOVE_DETECT(0x0000028E, "电力检测手套检测事件"),      // (对应DEV_EVENT_ELECTRIC_GLOVE_DETECT_INFO)
+
+    EVENT_IVS_ELECTRIC_LADDER_DETECT(0x0000028F, "电力检测梯子检测事件"),      // (对应DEV_EVENT_ELECTRIC_LADDER_DETECT_INFO)
+
+    EVENT_IVS_ELECTRIC_CURTAIN_DETECT(0x00000290, "电力检测布幔检测事件"),      // (对应DEV_EVENT_ELECTRIC_CURTAIN_DETECT_INFO)
+
+    EVENT_IVS_ELECTRIC_FENCE_DETECT(0x00000291, "电力检测围栏检测事件"),      // (对应DEV_EVENT_ELECTRIC_FENCE_DETECT_INFO)
+
+    EVENT_IVS_ELECTRIC_SIGNBOARD_DETECT(0x00000292, "电力检测标识牌检测事件"),      // (对应DEV_EVENT_ELECTRIC_SIGNBOARD_DETECT_INFO)
+
+    EVENT_IVS_ELECTRIC_BELT_DETECT(0x00000293, "电力检测安全带检测事件"),      // (对应DEV_EVENT_ELECTRIC_BELT_DETECT_INFO)
+
+    EVENT_IVS_RADAR_LINE_DETECTION(0x00000294, "雷达警戒线/绊线检测"),      // (对应DEV_EVENT_RADAR_LINE_DETECTION_INFO)
+
+    EVENT_IVS_RADAR_REGION_DETECTION(0x00000295, "雷达警戒区检测事件"),      // (对应DEV_EVENT_RADAR_REGION_DETECTION_INFO)
+
+    EVENT_IVS_AUDIO_INTENSITY(0x00000296, "异常音事件"),        // (对应 DEV_EVENT_AUDIO_INTENSITY_INFO)
+
+    EVENT_IVS_PARKING_LOT_STATUS_DETECTION(0x00000297, "室外停车位状态检测"),      //  (对应 DEV_EVENT_PARKING_LOT_STATUS_DETECTION_INFO)
+
+    EVENT_IVS_VEHICLE_COMPARE(0x00000298, ""),      // (只用于规则配置)
+
+    EVENT_IVS_DREGS_UNCOVERED(0x00000299, "渣土车未遮盖载货检测事件"),      // (对应 DEV_EVENT_DREGS_UNCOVERED_INFO)
+
+    EVENT_IVS_WALK_DETECTION(0x0000029A, "走动检测事件"),      // (对应 DEV_EVENT_WALK_DETECTION_INFO)
+
+    EVENT_IVS_BACK_TO_DETECTION(0x0000029B, "背对检测事件"),      // (对应 DEV_EVENT_BACK_TO_DETECTION_INFO)
+
+    EVENT_IVS_WRITE_ON_THE_BOARD_DETECTION(0x0000029C, "板书检测事件"),      // (对应 DEV_EVENT_WRITE_ON_THE_BOARD_DETECTION_INFO)
+
+    EVENT_IVS_SMART_KITCHEN_CLOTHES_DETECTION(0x0000029D, "智慧厨房穿着检测事件"),    // （对不戴口罩、厨师帽以及颜色不符合规定的厨师服进行报警）（对应 DEV_EVENT_SMART_KITCHEN_CLOTHES_DETECTION_INFO）
+
+    EVENT_IVS_SLEEP_DETECT(0x0000029E, "睡觉检测事件"),        // (对应 DEV_EVENT_SLEEP_DETECT_INFO)
+
+    EVENT_IVS_WALK_AROUND_DETECT(0x0000029F, "随意走动检测事件"),        // (对应 DEV_EVENT_WALK_AROUND_DETECT_INFO)
+
+    EVENT_IVS_PLAY_MOBILEPHONE(0x00000300, "玩手机事件"),        // (对应 DEV_EVENT_PLAY_MOBILEPHONE_INFO)
+
+    EVENT_IVS_FINANCE_CONTRABAND_DETECT(0x00000301, "智慧金融违规物品检测事件"),        // (对应 DEV_EVENT_FINANCE_CONTRABAND_DETECT_INFO)
+
+    EVENT_IVS_FINANCE_CASH_TRANSACTION(0x00000302, "智慧金融现金交易检测事件"),        // (对应 DEV_EVENT_FINANCE_CASH_TRANSACTION_INFO)
+
+    /**
+     * (对应 DEV_EVENT_ANATOMY_TEMP_DETECT_INFO)
+     */
+    EVENT_IVS_ANATOMY_TEMP_DETECT(0x00000303, "人体温智能检测事件"),
+
+    EVENT_IVS_ACTIVITY_ANALYSE(0x00000304, "活跃度统计规则"),      //  (只用于规则配置)
+
+    EVENT_IVS_DOOR_STATUS(0x00000305, "门状态事件"),      // (对应 DEV_EVENT_DOOR_STATUS_INFO)
+
+    EVENT_IVS_DHOP_CUSTOM(0x00000306, "Dhop自定义事件"),        // (start/stop, 对应 DEV_EVENT_DHOP_CUSTOM_INFO)
+
+    EVENT_IVS_DHOP_CUSTOM_ONCE(0x00000307, "Dhop自定义事件"),        // (Pulse, 对应 DEV_EVENT_DHOP_CUSTOM_INFO)
+
+    EVENT_IVS_FOG_DETECTION(0x00000308, "起雾检测事件"),        // (对应 DEV_EVENT_FOG_DETECTION)
+
+    EVENT_IVS_TRAFFIC_VEHICLE_RACE(0x00000309, "飙车事件"),        // （对应 DEV_EVENT_TRAFFIC_VEHICLE_RACE ）
+
+    EVENT_IVS_TRAFFIC_MOTOR_OVERLOAD(0x0000030A, "机动车超载"),      // (对应 DEV_EVENT_TRAFFIC_MOTOR_OVERLOAD_INFO)
+
+    EVENT_IVS_TRAFFIC_PLATE_OCCLUSION(0x0000030B, "车牌污损"),      // (对应 DEV_EVENT_TRAFFIC_PLATE_OCCLUSION_INFO)
+
+    EVENT_IVS_NONMOTOR_ENTRYING(0x0000030C, "非机动车进入电梯"),      // (对应 DEV_EVENT_NONMOTOR_ENTRYING_INFO)
+
+    EVENT_IVS_WATER_STAGE_MONITOR(0x0000030D, "水位监测事件"),      // , 目前仅用于任务型智能分析 (对应 DEV_EVENT_WATER_STAGE_MONITOR_INFO)
+
+    EVENT_IVS_TRAFFIC_ROAD_ALERT(0x0000030E, "道路安全预警"),      // (对应 DEV_EVENT_TRAFFIC_ROAD_ALERT_INFO)
+
+    EVENT_IVS_BREAK_RULE_BUILDING_DETECTION(0x0000030F, "违章建筑检测事件"),        // (对应 DEV_EVENT_BREAK_RULE_BUILDIING_DETECTION_INFO)
+
+    EVENT_IVS_TRAFFIC_NONMOTOR_RUN_REDLIGHT(0x00000310, "非机动车闯红灯"),       //  (对应 DEV_EVENT_TRAFFIC_NONMOTOR_RUN_REDLIGHT_INFO )
+
+	EVENT_IVS_STREET_SUNCURE(0x00000347,"沿街晾晒事件"),  //对应DEV_EVENT_STREET_SUNCURE_INFO
+
+	EVENT_IVS_OUTDOOR_ADVERTISEMENT(0x00000348,"户外广告事件"),  //对应DEV_EVENT_OUTDOOR_ADVERTISEMENT_INFO
+
+	EVENT_IVS_HUDDLE_MATERIAL(0x00000349,"乱堆物料检测事件"),  //对应DEV_EVENT_HUDDLE_MATERIAL_INFO
+
+	EVENT_IVS_FOLLOW_CAR_ALARM(0x0000034F,"跟车报警事件");  //对应DEV_EVENT_FOLLOW_CAR_ALARM_INFO
+
+    private int type;
+    private String description;
+
+    private EM_EVENT_IVS_TYPE(int type, String description) {
+        this.type = type;
+        this.description = description;
+    }
+
+    public static EM_EVENT_IVS_TYPE getEventType(int type) {
+        for (EM_EVENT_IVS_TYPE event : EM_EVENT_IVS_TYPE.values()) {
+            if (type == event.getType()) {
+                return event;
+            }
+        }
+        return null;
+    }
+
+    public int getType() {
+        return type;
+    }
+
+    public void setType(int type) {
+        this.type = type;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+}