build: 增加大华sdk

dev
huangfeng 3 months ago
parent 0807ca3441
commit 13dacfc2b9

@ -200,6 +200,12 @@
<artifactId>jSerialComm</artifactId>
<version>2.11.0</version>
</dependency>
<dependency>
<groupId>net.java.dev.jna</groupId>
<artifactId>jna</artifactId>
<version>5.4.0</version>
</dependency>
</dependencies>
<build>

@ -0,0 +1,23 @@
package com.netsdk;
import com.netsdk.lib.NetSDKLib;
import com.netsdk.lib.callback.impl.DefaultDisconnectCallback;
import com.netsdk.lib.callback.impl.DefaultHaveReconnectCallBack;
import com.netsdk.module.BaseModule;
import com.netsdk.module.entity.DeviceInfo;
/**
* @author 47081
* @version 1.0
* @description
* @date 2021/3/17
*/
public class SDKTest {
public static void main(String[] args) {
BaseModule baseModule=new BaseModule();
baseModule.init(DefaultDisconnectCallback.getINSTANCE(), DefaultHaveReconnectCallBack.getINSTANCE(),true);
DeviceInfo info=baseModule.login("172.23.12.14",37777,"admin","admin123");
baseModule.logout(info.getLoginHandler());
baseModule.clean();
}
}

@ -0,0 +1,51 @@
package com.netsdk.lib;
import com.netsdk.lib.NetSDKLib.SdkStructure;
import com.sun.jna.Library;
import com.sun.jna.Native;
import com.sun.jna.Pointer;
/** 热度图转换库 JNA接口封装 */
public interface HeatMapLib extends Library {
HeatMapLib HEATMAP_INSTANCE =
Native.load(LibraryLoad.getLoadLibrary("HeatMap"), HeatMapLib.class);
// Bmp位图信息
public static class BMPIMAGE_INFO extends SdkStructure {
public Pointer pBuffer; // Bmp图片数据指针(不包含图片头)
public int nWidth; // 图片宽度
public int nHeight; // 图片高度
public int nBitCount; // 图片位数,支持8位24位32位
public int nDirection; // 数据存储方向 0从上到下从左到右 1从下到上从左到右
}
// 输入数据信息
public static class HEATMAP_IMAGE_IN extends SdkStructure {
public BMPIMAGE_INFO stuGrayBmpInfo; // 8位Bmp灰度热度图数据不包含图片头数据存储方向从上到下
public BMPIMAGE_INFO stuBkBmpInfo; // 背景图Bmp位图数据包含图片头存储方向从下到上
}
// 输出数据信息
public static class HEATMAP_IMAGE_Out extends SdkStructure {
public Pointer pBuffer; // 输出的彩色热度图数据(包含图片头),宽高、位数和背景图相同
public int nPicSize; // 图片内存大小(包含头) :宽*高*nBitCount/8 + 54
public float fOpacity; // 透明度,范围0-1
}
/// \brief 生成热度图数据信息
/// param [in] stuBmpInfoIn Bmp位图数据输入
/// param [in] stuBmpInfoOut Bmp位图数据输出,包含图片头
/// param [out] true or false
public boolean CreateHeatMap(HEATMAP_IMAGE_IN stuBmpInfoIn, HEATMAP_IMAGE_Out stuBmpInfoOut);
/**
*
*
* @param srcData
* @param width
* @param height
* @param resultOut
* @return true or false
*/
public boolean TransNetDataToGrayData(Pointer srcData, int width, int height, Pointer resultOut);
}

@ -0,0 +1,27 @@
package com.netsdk.lib;
import com.sun.jna.Library;
import com.sun.jna.Native;
/**
* SDK JNA
*/
public interface ImageAlgLib extends Library {
//ImageAlgLib IMAGEALG_INSTANCE = (ImageAlgLib)Native.loadLibrary(Utils.getLoadLibrary("ImageAlg"), ImageAlgLib.class);
static ImageAlgLib IMAGEALG_INSTANCE = Native.load(LibraryLoad.getLoadLibrary("ImageAlg"), ImageAlgLib.class);
/*******************************************************************************
* : drcTable
* : rawY
* : - pRaw: 14bit
* : - height:
* : - width:
* : - sel: 0
* : - lut: sel1drc0
* : pYDataY
* : 0 :
* -1:
*******************************************************************************/
int drcTable(short[] pRaw, short width, short height, int sel, byte[] pYData, short[] lut);
}

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

@ -0,0 +1,205 @@
package com.netsdk.lib;
import com.netsdk.lib.utils.DynamicParseUtil;
import org.xml.sax.SAXException;
import javax.xml.parsers.ParserConfigurationException;
import java.io.*;
/**
* @author 47081
* @version 1.0
* @description
* @date 2020/11/14
*/
public class LibraryLoad {
private static final String ARCH_WINDOWS = "win";
private static final String ARCH_LINUX = "linux";
private static final String ARCH_MAC = "mac";
private static final int PREFIX_64 = 64;
private static final int PREFIX_32 = 32;
private static final String EXTERNAL_WIN = ".dll";
private static final String EXTERNAL_LINUX = ".so";
private static final String EXTERNAL_MAC = ".dylib";
private static DynamicParseUtil dynamicParseUtil;
/** 当前读取的目录 */
private static String currentFold;
/** 动态库需要写入的目录 */
private static String EXTRACT_PATH = System.getProperty("java.io.tmpdir");
private static boolean writed = false;
/**
* ,
*
* @param path ,sdk
*/
public static void setExtractPath(String path) {
EXTRACT_PATH = path;
}
/*private static final String[] DYNAMIC_LIBS =
new String[] {
"dhplay",
"fisheye",
"ImageAlg",
"Infra",
"IvsDrawer",
"Json",
"libcurl",
"libeay32",
"NetFramework",
"ssleay32",
"Stream",
"StreamConvertor",
"StreamSvr",
"HeatMap",
"avnetsdk",
"ACDLL",
"dhconfigsdk",
"dhnetsdk"
};*/
/** 动态库路径 */
private static String INNER_PATH;
// private static final String EXTERNAL_MAC = ".so";
private static String extractNetSDKLib(String libName) {
return extractLibrary(libName);
}
public static String getLoadLibrary(String libraryName) {
currentFold = getLibraryFold();
if (dynamicParseUtil == null) {
try {
dynamicParseUtil =
new DynamicParseUtil(
LibraryLoad.class.getClassLoader().getResourceAsStream("dynamic-lib-load.xml"));
if (!writed) {
for (String libName : dynamicParseUtil.getLibsSystem(currentFold)) {
extractLibrary(libName);
}
writed = true;
}
} catch (ParserConfigurationException | IOException | SAXException e) {
e.printStackTrace();
}
}
String fullName = getLibraryName(libraryName);
String path = EXTRACT_PATH;
if (!(EXTRACT_PATH.endsWith("/") || EXTRACT_PATH.endsWith("\\"))) {
path = EXTRACT_PATH + "/";
}
System.out.println("load library " + fullName);
return path + "/" + fullName;
}
/**
* jar,使
*
* @param libName
* @return
*/
private static String extractLibrary(String libName) {
return extractLibrary("", libName);
}
/**
*
*
* @param relativePath
* @param libName
* @return
*/
private static String extractLibrary(String relativePath, String libName) {
if (libName.trim().equals("")) {
return "";
}
String libFullName = getLibraryName(libName);
String dir = getLibraryFold();
if (!(relativePath.endsWith("/") || relativePath.endsWith("\\"))) {
relativePath = relativePath + "/";
}
String fileName = relativePath + dir + "/" + libFullName;
InputStream in = LibraryLoad.class.getResourceAsStream(fileName);
BufferedInputStream reader;
FileOutputStream writer;
File extractedLibFile = null;
try {
if (in == null) {
in = new FileInputStream(fileName);
}
String nativeTempDir = EXTRACT_PATH;
if (!(nativeTempDir.endsWith("/") || nativeTempDir.endsWith("\\"))) {
nativeTempDir = nativeTempDir + "/";
}
extractedLibFile = new File(nativeTempDir + "/" + libFullName);
reader = new BufferedInputStream(in);
writer = new FileOutputStream(extractedLibFile);
byte[] buffer = new byte[1024];
while (true) {
int len = reader.read(buffer);
if (len == 0 || len == -1) break;
writer.write(buffer, 0, len);
}
reader.close();
writer.close();
in.close();
} catch (Exception e) {
System.out.println(
"dynamic file[ "
+ fileName
+ " ] not found in project.please ensure you need this library.");
}
return extractedLibFile != null ? extractedLibFile.getAbsolutePath() : "";
}
/**
*
*
* @param libName
* @return
*/
private static String getLibraryName(String libName) {
String dir = currentFold;
String libPrefix = "";
String libExtension = EXTERNAL_WIN;
if (!dir.contains("win")) {
libPrefix = "lib";
if (dir.contains("linux")) {
libExtension = EXTERNAL_LINUX;
} else {
// libExtension=".dylib";
libExtension = EXTERNAL_MAC;
}
}
libName = dynamicParseUtil.compareLibName(currentFold, libName);
// 动态库以lib开头则不添加lib前缀
// 以lib开头的库则不添加lib前缀
return (libName.startsWith("lib") ? "" : libPrefix) + libName + libExtension;
}
// 获取系统对应的动态库文件夹
private static String getLibraryFold() {
String osType;
String osName = System.getProperty("os.name");
if (osName.toLowerCase().startsWith("linux")) {
osType = ARCH_LINUX;
} else if (osName.toLowerCase().startsWith("mac")
|| osName.toLowerCase().startsWith("darwin")) {
osType = ARCH_MAC;
} else if (osName.toLowerCase().startsWith("windows")) {
osType = ARCH_WINDOWS;
} else {
osType = "";
}
String arch = System.getProperty("os.arch");
arch = arch.toLowerCase().trim();
if ("i386".equals(arch) || "i686".equals(arch) || "x86".equals(arch)) {
arch = PREFIX_32 + "";
} else if ("x86_64".equals(arch) || "amd64".equals(arch)) {
arch = PREFIX_64 + "";
}
return osType + arch;
}
}

@ -0,0 +1,124 @@
package com.netsdk.lib;
import java.io.UnsupportedEncodingException;
import java.nio.CharBuffer;
import com.sun.jna.Memory;
import com.sun.jna.Native;
import com.sun.jna.Pointer;
/** Provides a temporary allocation of an immutable C string
* (<code>const char*</code> or <code>const wchar_t*</code>) for use when
* converting a Java String into a native memory function argument.
*
* @author Todd Fast, todd.fast@sun.com
* @author twall@users.sf.net
*/
public class NativeString implements CharSequence, Comparable<Object> {
private Pointer pointer;
private boolean wide;
/** Create a native string (NUL-terminated array of <code>char</code>).<p>
* If the system property <code>jna.encoding</code> is set, its value will
* be used to encode the native string. If not set or if the encoding
* is unavailable, the default platform encoding will be used.
*/
public NativeString(String string) {
this(string, false);
}
/** Create a native string as a NUL-terminated array of <code>wchar_t</code>
* (if <code>wide</code> is true) or <code>char</code>.<p>
* If the system property <code>jna.encoding</code> is set, its value will
* be used to encode the native <code>char</code>string.
* If not set or if the encoding is unavailable, the default platform
* encoding will be used.
*
* @param string value to write to native memory
* @param wide whether to store the String as <code>wchar_t</code>
*/
public NativeString(String string, boolean wide) {
if (string == null) {
throw new NullPointerException("String must not be null");
}
// Allocate the memory to hold the string. Note, we have to
// make this 1 element longer in order to accommodate the terminating
// NUL (which is generated in Pointer.setString()).
this.wide = wide;
if (wide) {
int len = (string.length() + 1 ) * Native.WCHAR_SIZE;
pointer = new Memory(len);
pointer.setWideString(0, string);
}
else {
byte[] data = getBytes(string);
pointer = new Memory(data.length + 1);
pointer.write(0, data, 0, data.length);
pointer.setByte(data.length, (byte)0);
}
}
static byte[] getBytes(String s) {
try {
return getBytes(s, System.getProperty("jna.encoding"));
}
catch (UnsupportedEncodingException e) {
return s.getBytes();
}
}
/** Return a byte array corresponding to the given String, using the given
encoding.
*/
static byte[] getBytes(String s, String encoding) throws UnsupportedEncodingException {
if (encoding != null) {
return s.getBytes(encoding);
}
return s.getBytes();
}
public int hashCode() {
return toString().hashCode();
}
public boolean equals(Object other) {
if (other instanceof CharSequence) {
return compareTo(other) == 0;
}
return false;
}
public String toString() {
String s = wide ? "const wchar_t*" : "const char*";
s += "(" + (wide ? pointer.getWideString(0) : pointer.getString(0)) + ")";
return s;
}
public Pointer getPointer() {
return pointer;
}
public char charAt(int index) {
return toString().charAt(index);
}
public int length() {
return toString().length();
}
public CharSequence subSequence(int start, int end) {
return CharBuffer.wrap(toString()).subSequence(start, end);
}
public int compareTo(Object other) {
if (other == null)
return 1;
return toString().compareTo(other.toString());
}
}

@ -0,0 +1,24 @@
package com.netsdk.lib;
public class NetFinalVar {
// 存储设备状态
public static final int NET_STORAGE_DEV_OFFLINE = 0; // 物理硬盘脱机状态
public static final int NET_STORAGE_DEV_RUNNING = 1; // 物理硬盘运行状态
public static final int NET_STORAGE_DEV_ACTIVE = 2; // RAID活动
public static final int NET_STORAGE_DEV_SYNC = 3; // RAID同步
public static final int NET_STORAGE_DEV_SPARE = 4; // RAID热备(局部)
public static final int NET_STORAGE_DEV_FAULTY = 5; // RAID失效
public static final int NET_STORAGE_DEV_REBUILDING = 6; // RAID重建
public static final int NET_STORAGE_DEV_REMOVED = 7; // RAID移除
public static final int NET_STORAGE_DEV_WRITE_ERROR = 8; // RAID写错误
public static final int NET_STORAGE_DEV_WANT_REPLACEMENT = 9; // RAID需要被替换
public static final int NET_STORAGE_DEV_REPLACEMENT = 10; // RAID是替代设备
public static final int NET_STORAGE_DEV_GLOBAL_SPARE = 11; // 全局热备
public static final int NET_STORAGE_DEV_ERROR = 12; // 错误, 部分分区可用
public static final int NET_STORAGE_DEV_RAIDSUB = 13; // 该盘目前是单盘, 原先是块Raid子盘, 有可能在重启后自动加入Raid
public static final int NET_STORAGE_DEV_FATAL = 14; // 严重错误,全部分区坏(DVR新增错误类型)
public static final int NET_STORAGE_DEV_SNAPSHOT_PARENT = 15; // 快照母盘
public static final int NET_STORAGE_DEV_SNAPSHOT_CHILD = 16; // 快照子盘
public static final int NET_STORAGE_DEV_VOLUMECLONE_PARENT = 17; // 卷克隆母盘
public static final int NET_STORAGE_DEV_VOLUMECLONE_CHILD = 18; // 卷克隆子盘
}

File diff suppressed because it is too large Load Diff

@ -0,0 +1,293 @@
package com.netsdk.lib;
import com.netsdk.lib.NetSDKLib.SdkStructure;
import com.sun.jna.*;
import com.sun.jna.ptr.IntByReference;
/**
* PlaySDK JNA
*/
public interface PlaySDKLib extends Library {
PlaySDKLib PLAYSDK_INSTANCE = Native.load(LibraryLoad.getLoadLibrary("play"), PlaySDKLib.class);
/**
*
*
* @author 29779
*/
public class PlaySDKLastError {
public static final int DH_PLAY_NOERROR = 0; //没有错误
public static final int DH_PLAY_PARA_OVER = 1; //输入参数非法
public static final int DH_PLAY_ORDER_ERROR = 2; //调用顺序不对
public static final int DH_PLAY_TIMER_ERROR = 3; //多媒体时钟设置失败
public static final int DH_PLAY_DEC_VIDEO_ERROR = 4; //视频解码失败
public static final int DH_PLAY_DEC_AUDIO_ERROR = 5; //音频解码失败
public static final int DH_PLAY_ALLOC_MEMORY_ERROR = 6; //分配内存失败
public static final int DH_PLAY_OPEN_FILE_ERROR = 7; //文件操作失败
public static final int DH_PLAY_CREATE_OBJ_ERROR = 8; //创建线程事件等失败
public static final int DH_PLAY_CREATE_DDRAW_ERROR = 9; //创建directDraw失败
public static final int DH_PLAY_CREATE_OFFSCREEN_ERROR = 10; //创建后端缓存失败
public static final int DH_PLAY_BUF_OVER = 11; //缓冲区满,输入流失败
public static final int DH_PLAY_CREATE_SOUND_ERROR = 12; //创建音频设备失败
public static final int DH_PLAY_SET_VOLUME_ERROR = 13; //设置音量失败
public static final int DH_PLAY_SUPPORT_FILE_ONLY = 14; //只能在播放文件时才能使用
public static final int DH_PLAY_SUPPORT_STREAM_ONLY = 15; //只能在播放流时才能使用
public static final int DH_PLAY_SYS_NOT_SUPPORT = 16; //系统不支持,解码器只能工作在Pentium 3以上
public static final int DH_PLAY_FILEHEADER_UNKNOWN = 17; //没有文件头
public static final int DH_PLAY_VERSION_INCORRECT = 18; //解码器和编码器版本不对应
public static final int DH_PLAY_INIT_DECODER_ERROR = 19; //初始化解码器失败
public static final int DH_PLAY_CHECK_FILE_ERROR = 20; //文件太短或码流无法识别
public static final int DH_PLAY_INIT_TIMER_ERROR = 21; //初始化多媒体时钟失败
public static final int DH_PLAY_BLT_ERROR = 22; //位拷贝失败
public static final int DH_PLAY_UPDATE_ERROR = 23; //显示overlay失败
public static final int DH_PLAY_MEMORY_TOOSMALL = 24; //缓冲太小
}
/**
*
*
* @author 29779
*/
public static class T_VIDEO extends SdkStructure {
public static final int T_UYVY = 1; //UYVY类型的YUV数据,现在不支持.
public static final int T_IYUV = 3; //IYUV(I420)类型YUV数据
public static final int T_RGB32 = 7; //RGB32类型
}
public static class RenderType extends SdkStructure {
public static final int RENDER_NOTSET = 0;
public static final int RENDER_GDI = 1;
public static final int RENDER_X11 = RENDER_GDI;
public static final int RENDER_D3D = 2;
public static final int RENDER_OPENGL = RENDER_D3D;
public static final int RENDER_DDRAW = 3;
}
public static class DecodeType extends SdkStructure {
public static final int DECODE_NOTSET = 0;
public static final int DECODE_SW = 1;
public static final int DECODE_HW = 2; //拷贝模式
public static final int DECODE_HW_FAST = 3; //直接显示模式
public static final int DECODE_MSDK = 4;
}
/**
* PLAY_GetFreePort ,501.PLAY_ReleasePort使.
*
* @param plPort plPort,,.
* @return 1, 0.
*/
public int PLAY_GetFreePort(IntByReference plPort);
/**
* PLAY_OpenStream
*
* @param nPort
* @param pFileHeadBuf 使,NULL.
* @param nSize ,0.
* @param nBufPoolSize . [SOURCE_BUF_MIN,SOURCE_BUF_MAX].900*1024
* ,,,.
* @return 1, 0.
*/
public int PLAY_OpenStream(int nPort, byte[] pFileHeadBuf, int nSize, int nBufPoolSize);
/**
*
*/
public interface IDisplayCBFun extends Callback {
/**
* IDisplsyCBFun,
*
* @param nPort
* @param pBuf
* @param nSize
* @param nWidth ,
* @param nHeight
* @param nStamp
* @param nType ,T_RGB32,T_UYVY, T_VIDEO
* @param pReserved
* @see T_VIDEO
*/
void invoke(int nPort, Pointer pBuf, int nSize, int nWidth, int nHeight, int nStamp, int nType, Pointer pReserved);
}
/**
* PLAY_SetDisplayCallBack
* .,NULL,
*
* @param nPort
* @param DisplayCBFun ,
* @param pUserData
* @return 1, 0.
*/
public int PLAY_SetDisplayCallBack(int nPort, IDisplayCBFun DisplayCBFun, Pointer pUserData);
/**
* PLAY_Play .,.
*
* @param nPort
* @param hWnd
* @return 1, 0.
*/
public int PLAY_Play(int nPort, Pointer hWnd);
/**
* PLAY_InputData ,PLAY_Play使
*
* @param nPort
* @param pBuf
* @param nSize
* @return 1, 0. ,,
*/
public int PLAY_InputData(int nPort, byte[] pBuf, int nSize);
/**
* PLAY_Stop
*
* @param nPort
* @return 1, 0.
*/
public int PLAY_Stop(int nPort);
/**
* PLAY_CloseStream
*
* @param nPort
* @return 1, 0.
*/
public int PLAY_CloseStream(int nPort);
/**
* PLAY_ReleasePort ,PLAY_RealsePort使.
*
* @param lPort
* @return 1, 0.
*/
public int PLAY_ReleasePort(int lPort);
/**
* PLAY_GetLastError
*
* @param nPort
* @return .
* @see PlaySDKLastError
*/
public int PLAY_GetLastError(int nPort);
/**
* PLAY_GetLastErrorEx
*
* @param nPort
* @return .
* @see PlaySDKLastErrorEx
*/
public int PLAY_GetLastErrorEx(int nPort);
/**
* PLAY_GetPlayedTimeEx
*
* @param nPort
* @return , .
*/
public int PLAY_GetPlayedTimeEx(int nPort);
/**
* PLAY_SetPlayedTimeEx
*
* @param nPort nTime,,.
* @return BOOL, TRUE, FALSE.
*/
public boolean PLAY_SetPlayedTimeEx(int nPort, int nTime);
/**
* PLAY_SetEngine (Windows), PLAY_Play EngineNOTSET, :PLAY_SetEngine(0, DECODE_HW, RENDER_NOTSET);
*
* @param nPort
* @param decodeType H264, Hevc)
* @param renderType
* @return true: false:
*/
public boolean PLAY_SetEngine(int nPort, int decodeType, int renderType);
/**
* PLAY_SetSecurityKey AES
*
* @param nPort
* @param szKey
* @param nKeylen
* @return true: false:
*/
public boolean PLAY_SetSecurityKey(int nPort, String szKey, int nKeylen);
public static class LOG_LEVEL extends SdkStructure {
public static final int LOG_LevelUnknown = 0; // unknown
public static final int LOG_LevelFatal = 1; // fatal, when setting this level, (fatal) will output
public static final int LOG_LevelError = 2; // error,when setting this level, (fatal,error) will output
public static final int LOG_LevelWarn = 3; // warn, when setting this level, (fatal,error,warn) will output
public static final int LOG_LevelInfo = 4; // info, when setting this level, (fatal,error,warn,info) will output
public static final int LOG_LevelTrace = 5; // Trace, when setting this level, (fatal,error,warn,info,trace) will output
public static final int LOG_LevelDebug = 6; // Debug, when setting this level, (fatal,error,warn,info,trace,debug) will output
}
;
public void PLAY_SetPrintLogLevel(int logLevel);
// 按时间回放进度回调函数原形
public interface fDecCBFun extends Callback {
// pFrameInfo FRAME_INFO
void invoke(int nPort, Pointer pBuf, int nSize, Pointer pFrameInfo, Pointer pUserData, int nReserved2);
}
/**
*
* PLAY_PlayPLAY_StopPLAY_Play
*
*
*
* @return BOOLTRUEFALSE
* @param[in] nPort
* @param[out] DecCBFun ,NULL
* @param[in] pUserData
* @note PLAY_GetLastErrorEx
*/
public boolean PLAY_SetDecCallBackEx(int nPort, fDecCBFun DecCBFun, Pointer pUserData);
/* 帧信息 */
public static class FRAME_INFO extends SdkStructure {
public int nWidth; // 画面宽单位像素。如果是音频数据则为0
public int nHeight; // 画面高如果是音频数据则为0
public int nStamp; // 时标信息,单位毫秒
public int nType; // 视频帧类型T_AUDIO16T_RGB32T_IYUV
public int nFrameRate; // 视频表示帧率,音频表示采样率
}
/**
*
*
* @param[in] nPort
* @param[in] cmdType CMD_TYPE_E
* @param[in] buf
* @param[in] buflen
* @param[out] returnlen
* @return BOOLTRUEFALSE
* @note PLAY_GetLastErrorEx
*/
public boolean PLAY_QueryInfo(int nPort, int cmdType, Pointer buf, int buflen, IntByReference returnlen);
public static class TimeInfo extends SdkStructure {
public int year;
public int month;
public int day;
public int hour;
public int minute;
public int second;
@Override
public String toString() {
return year + "/" + month + "/" + day + " " + hour + ":" + minute + ":" + second;
}
}
}

@ -0,0 +1,879 @@
package com.netsdk.lib;
import java.io.*;
import java.math.BigInteger;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.security.MessageDigest;
import com.netsdk.lib.NetSDKLib.*;
import com.sun.jna.Memory;
import com.sun.jna.Pointer;
import com.sun.jna.Structure;
import com.sun.jna.ptr.IntByReference;
public class ToolKits {
static NetSDKLib netsdkapi = NetSDKLib.NETSDK_INSTANCE;
static NetSDKLib configapi = NetSDKLib.CONFIG_INSTANCE;
public ToolKits() {
}
/***************************************************************************************************
* CLIENT_GetNewDevConfig CLIENT_ParseData CLIENT_PacketData CLIENT_SetNewDevConfig *
***************************************************************************************************/
/**
*
* @param hLoginHandle
* @param nChn -1
* @param strCmd
* @param cmdObjects
* @return
*/
public static int GetDevConfig(LLong hLoginHandle, int nChn, String strCmd, Structure[] cmdObjects)
{
IntByReference error = new IntByReference(0);
int nBufferLen = 2*1024*1024;
byte[] strBuffer = new byte[nBufferLen];
if(!netsdkapi.CLIENT_GetNewDevConfig(hLoginHandle, strCmd , nChn, strBuffer, nBufferLen, error, 5000,null))
{
System.err.printf("Get %s Config Failed!Last Error = %x\n" , strCmd , netsdkapi.CLIENT_GetLastError());
return -1;
}
IntByReference retLength = new IntByReference(0);
int memorySize = cmdObjects.length * cmdObjects[0].size();
Pointer objectsPointer = new Memory(memorySize);
objectsPointer.clear(memorySize);
SetStructArrToPointerData(cmdObjects, objectsPointer);
if (!configapi.CLIENT_ParseData(strCmd, strBuffer, objectsPointer, memorySize, retLength.getPointer())) {
System.err.println("Parse " + strCmd + " Config Failed!");
return -1;
}
GetPointerDataToStructArr(objectsPointer, cmdObjects);
return (retLength.getValue() / cmdObjects[0].size());
}
/**
*
* @param hLoginHandle
* @param nChn -1
* @param strCmd
* @param cmdObject
* @return true
*/
public static boolean GetDevConfig(LLong hLoginHandle, int nChn, String strCmd, Structure cmdObject) {
boolean result = false;
IntByReference error = new IntByReference(0);
IntByReference retLen = new IntByReference(0);
int nBufferLen = 2*1024*1024;
byte[] strBuffer = new byte[nBufferLen];
if(netsdkapi.CLIENT_GetNewDevConfig( hLoginHandle, strCmd , nChn, strBuffer, nBufferLen, error, 5000,null) )
{
cmdObject.write();
if (configapi.CLIENT_ParseData(strCmd, strBuffer, cmdObject.getPointer(), cmdObject.size(), retLen.getPointer()))
{
cmdObject.read();
result = true;
}
else
{
System.err.println("Parse " + strCmd + " Config Failed!" + ToolKits.getErrorCode());
result = false;
}
}
else
{
System.err.printf("Get %s Config Failed!Last Error = %x\n" , strCmd , netsdkapi.CLIENT_GetLastError());
result = false;
}
String strOut = new String(strBuffer).trim();
System.out.println("Get:" + strOut);
return result;
}
/**
*
* @param hLoginHandle
* @param nChn -1
* @param strCmd
* @param cmdObjects
* @return true
*/
public static boolean SetDevConfig(LLong hLoginHandle, int nChn, String strCmd, Structure[] cmdObjects) {
boolean result = false;
int nBufferLen = 2*1024*1024;
byte szBuffer[] = new byte[nBufferLen];
for(int i=0; i<nBufferLen; i++)szBuffer[i]=0;
IntByReference error = new IntByReference(0);
IntByReference restart = new IntByReference(0);
int memorySize = cmdObjects.length * cmdObjects[0].size();
Pointer objectsPointer = new Memory(memorySize);
objectsPointer.clear(memorySize);
SetStructArrToPointerData(cmdObjects, objectsPointer);
if (configapi.CLIENT_PacketData(strCmd, objectsPointer, memorySize, szBuffer, nBufferLen))
{
String strOut = new String(szBuffer).trim();
System.err.println(strOut);
/*
if( netsdkapi.CLIENT_SetNewDevConfig(hLoginHandle, strCmd , nChn , szBuffer, nBufferLen, error, restart, 5000))
{
result = true;
}
else
{
System.err.printf("Set %s Config Failed! Last Error = %x\n" , strCmd , netsdkapi.CLIENT_GetLastError());
result = false;
}*/
}
else
{
System.err.println("Packet " + strCmd + " Config Failed!");
result = false;
}
return result;
}
/**
*
* @param hLoginHandle
* @param nChn -1
* @param strCmd
* @param cmdObject
* @return true
*/
public static boolean SetDevConfig(LLong hLoginHandle, int nChn, String strCmd, Structure cmdObject) {
boolean result = false;
int nBufferLen = 2*1024*1024;
byte szBuffer[] = new byte[nBufferLen];
for(int i=0; i<nBufferLen; i++)szBuffer[i]=0;
IntByReference error = new IntByReference(0);
IntByReference restart = new IntByReference(0);
cmdObject.write();
if (configapi.CLIENT_PacketData(strCmd, cmdObject.getPointer(), cmdObject.size(),
szBuffer, nBufferLen))
{
cmdObject.read();
String buffer = new String(szBuffer).trim();
System.out.println(buffer);
if( netsdkapi.CLIENT_SetNewDevConfig(hLoginHandle, strCmd , nChn , szBuffer, nBufferLen, error, restart, 5000))
{
result = true;
}
else
{
System.err.printf("Set %s Config Failed! Last Error = %x\n" , strCmd , netsdkapi.CLIENT_GetLastError());
result = false;
}
}
else
{
System.err.println("Packet " + strCmd + " Config Failed!");
result = false;
}
return result;
}
public static void GetPointerData(Pointer pNativeData, Structure pJavaStu)
{
GetPointerDataToStruct(pNativeData, 0, pJavaStu);
}
public static void GetPointerDataToStruct(Pointer pNativeData, long OffsetOfpNativeData, Structure pJavaStu) {
pJavaStu.write();
Pointer pJavaMem = pJavaStu.getPointer();
pJavaMem.write(0, pNativeData.getByteArray(OffsetOfpNativeData, pJavaStu.size()), 0,
pJavaStu.size());
pJavaStu.read();
}
public static void GetPointerDataToStructArr(Pointer pNativeData, Structure []pJavaStuArr) {
long offset = 0;
for (int i=0; i<pJavaStuArr.length; ++i)
{
GetPointerDataToStruct(pNativeData, offset, pJavaStuArr[i]);
offset += pJavaStuArr[i].size();
}
}
/**
*
* @param pNativeData
* @param pJavaStuArr
*/
public static void SetStructArrToPointerData(Structure []pJavaStuArr, Pointer pNativeData) {
long offset = 0;
for (int i = 0; i < pJavaStuArr.length; ++i) {
SetStructDataToPointer(pJavaStuArr[i], pNativeData, offset);
offset += pJavaStuArr[i].size();
}
}
public static void SetStructDataToPointer(Structure pJavaStu, Pointer pNativeData, long OffsetOfpNativeData){
pJavaStu.write();
Pointer pJavaMem = pJavaStu.getPointer();
pNativeData.write(OffsetOfpNativeData, pJavaMem.getByteArray(0, pJavaStu.size()), 0, pJavaStu.size());
}
public static void ByteArrToStructure(byte[] pNativeData, Structure pJavaStu) {
pJavaStu.write();
Pointer pJavaMem = pJavaStu.getPointer();
pJavaMem.write(0, pNativeData, 0, pJavaStu.size());
pJavaStu.read();
}
public static void ByteArrZero(byte[] dst) {
// 清零
for (int i = 0; i < dst.length; ++i) {
dst[i] = 0;
}
}
//byte转换为byte[2]数组
public static byte[] getByteArray(byte b){
byte[] array = new byte[8];
for (int i = 0; i < 8; i++) {
array[i] = (byte) ((b & (1 << i)) > 0 ? 1:0);
}
return array;
}
public static byte[] getByteArrayEx(byte b){
byte[] array = new byte[8];
for(int i = 7; i >= 0; i--) {
array[i] = (byte)(b & 1);
b = (byte)(b >> 1);
}
return array;
}
public static void StringToByteArr(String src, byte[] dst) {
try {
byte[] GBKBytes = src.getBytes("GBK");
for (int i = 0; i < GBKBytes.length; i++) {
dst[i] = (byte) GBKBytes[i];
}
} catch (Exception e1) {
e1.printStackTrace();
}
}
public static long GetFileSize(String filePath)
{
File f = new File(filePath);
if (f.exists() && f.isFile()) {
return f.length();
}
else
{
return 0;
}
}
public static boolean ReadAllFileToMemory(String file, Memory mem)
{
if (mem != Memory.NULL)
{
long fileLen = GetFileSize(file);
if (fileLen <= 0)
{
return false;
}
try {
File infile = new File(file);
if (infile.canRead())
{
FileInputStream in = new FileInputStream(infile);
int buffLen = 1024;
byte[] buffer = new byte[buffLen];
long currFileLen = 0;
int readLen = 0;
while (currFileLen < fileLen)
{
readLen = in.read(buffer);
mem.write(currFileLen, buffer, 0, readLen);
currFileLen += readLen;
}
in.close();
return true;
}
else
{
System.err.println("Failed to open file %s for read!!!\n");
return false;
}
}catch (Exception e)
{
System.err.println("Failed to open file %s for read!!!\n");
e.printStackTrace();
}
}
return false;
}
public static void savePicture(byte[] pBuf, String sDstFile)
{
try
{
FileOutputStream fos = new FileOutputStream(sDstFile);
fos.write(pBuf);
fos.close();
} catch (Exception e){
e.printStackTrace();
}
}
public static void savePicture(Pointer pBuf, int dwBufSize, String sDstFile)
{
try
{
DataOutputStream out = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(sDstFile)));
out.write(pBuf.getByteArray(0, dwBufSize), 0, dwBufSize);
out.close();
} catch (Exception e){
e.printStackTrace();
}
}
public static void savePicture(Pointer pBuf, int dwBufOffset, int dwBufSize, String sDstFile)
{
try
{
DataOutputStream out = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(sDstFile)));
out.write(pBuf.getByteArray(dwBufOffset, dwBufSize), 0, dwBufSize);
out.close();
} catch (Exception e){
e.printStackTrace();
}
}
// 读取本地图片到byte[]
public static byte[] readPictureToByteArray(String filename) {
File file = new File(filename);
if(!file.exists()) {
System.err.println("picture is not exist!");
return null;
}
ByteArrayOutputStream byteOutStream = new ByteArrayOutputStream((int)file.length());
BufferedInputStream byteInStream = null;
try {
byteInStream = new BufferedInputStream(new FileInputStream(file));
byte[] buf = new byte[1024];
int len = 0;
while((len = byteInStream.read(buf)) != -1) {
byteOutStream.write(buf, 0, len);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
byteInStream.close();
byteOutStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return byteOutStream.toByteArray();
}
// 将一位数组转为二维数组
public static byte[][] ByteArrToByteArrArr(byte[] byteArr, int count, int length) {
if(count * length != byteArr.length) {
System.err.println(count * length + " != " + byteArr.length);
return null ;
}
byte[][] byteArrArr = new byte[count][length];
for(int i = 0; i < count; i++) {
System.arraycopy(byteArr, i * length, byteArrArr[i], 0, length);
}
return byteArrArr;
}
/**
*
* @return
*/
public static String getErrorCode() {
return " { error code: ( 0x80000000|" + (netsdkapi.CLIENT_GetLastError() & 0x7fffffff) +" ). 参考 LastError.java }";
}
/**
*
* @param lLoginID
* @param szPath
* @param stOut
* @return /
*/
public static SDK_REMOTE_FILE_INFO[] ListRemoteFile(LLong lLoginID, String szPath, NET_OUT_LIST_REMOTE_FILE stOut) {
NET_IN_LIST_REMOTE_FILE stIn = new NET_IN_LIST_REMOTE_FILE();
stIn.pszPath = "/mnt/sdcard/" + szPath;
stIn.bFileNameOnly = 1; // 只获取文件名称, 不返回文件夹信息, 文件信息中只有文件名有效
stIn.emCondition = NET_REMOTE_FILE_COND.NET_REMOTE_FILE_COND_NONE;
int maxFileCount = 50; // 每次查询的文件个数
SDK_REMOTE_FILE_INFO[] remoteFileArr;
while(true) {
remoteFileArr = new SDK_REMOTE_FILE_INFO[maxFileCount];
for(int i = 0; i < maxFileCount; i++) {
remoteFileArr[i] = new SDK_REMOTE_FILE_INFO();
}
stOut.nMaxFileCount = maxFileCount;
stOut.pstuFiles = new Memory(remoteFileArr[0].size() * maxFileCount); // Pointer初始化
stOut.pstuFiles.clear(remoteFileArr[0].size() * maxFileCount);
ToolKits.SetStructArrToPointerData(remoteFileArr, stOut.pstuFiles); // 将数组内存拷贝给Pointer
if(netsdkapi.CLIENT_ListRemoteFile(lLoginID, stIn, stOut, 3000)) {
if(maxFileCount > stOut.nRetFileCount) {
ToolKits.GetPointerDataToStructArr(stOut.pstuFiles, remoteFileArr); // 将Pointer的信息输出到结构体
break;
} else {
maxFileCount += 50;
}
} else {
return null;
}
}
return remoteFileArr;
}
/**
*
* @param lLoginID
* @param szPath
* @param stOut
* @return /
*/
public static SDK_REMOTE_FILE_INFO[] ListAudioFile(LLong lLoginID, String szPath, NET_OUT_LIST_REMOTE_FILE stOut) {
NET_IN_LIST_REMOTE_FILE stIn = new NET_IN_LIST_REMOTE_FILE();
stIn.pszPath =szPath;
stIn.bFileNameOnly = 1; // 只获取文件名称, 不返回文件夹信息, 文件信息中只有文件名有效
stIn.emCondition = NET_REMOTE_FILE_COND.NET_REMOTE_FILE_COND_NONE;
int maxFileCount = 50; // 每次查询的文件个数
SDK_REMOTE_FILE_INFO[] remoteFileArr;
while(true) {
remoteFileArr = new SDK_REMOTE_FILE_INFO[maxFileCount];
for(int i = 0; i < maxFileCount; i++) {
remoteFileArr[i] = new SDK_REMOTE_FILE_INFO();
}
stOut.nMaxFileCount = maxFileCount;
stOut.pstuFiles = new Memory(remoteFileArr[0].size() * maxFileCount); // Pointer初始化
stOut.pstuFiles.clear(remoteFileArr[0].size() * maxFileCount);
ToolKits.SetStructArrToPointerData(remoteFileArr, stOut.pstuFiles); // 将数组内存拷贝给Pointer
if(netsdkapi.CLIENT_ListRemoteFile(lLoginID, stIn, stOut, 3000)) {
if(maxFileCount > stOut.nRetFileCount) {
ToolKits.GetPointerDataToStructArr(stOut.pstuFiles, remoteFileArr); // 将Pointer的信息输出到结构体
break;
} else {
maxFileCount += 50;
}
} else {
return null;
}
}
return remoteFileArr;
}
/**
* ,
* @param lLoginID
* @param szPath
*/
public static boolean RemoveRemoteFilesEx(LLong lLoginID, String szPath) {
boolean bRet = false;
if(szPath.indexOf("*") != -1) { // 删除一类文件
String[] szPathStr = szPath.split("[*]");
String szFindPath = szPathStr[0]; // 查询文件路径
String szFileType = szPathStr[1].substring(1); // 文件类型
// 查询当前路径下的文件
NET_OUT_LIST_REMOTE_FILE stOut = new NET_OUT_LIST_REMOTE_FILE();
SDK_REMOTE_FILE_INFO[] remoteFile = ToolKits.ListRemoteFile(lLoginID, szFindPath, stOut);
if(remoteFile != null) {
for(int i = 0; i < stOut.nRetFileCount; i++) {
// 过滤并删除
if(new String(remoteFile[i].szPath).trim().indexOf(szFileType) != -1) {
bRet = RemoveRemoteFiles(lLoginID, szFindPath + new String(remoteFile[i].szPath).trim());
}
}
}
} else { // 删除具体的文件
bRet = RemoveRemoteFiles(lLoginID, szPath);
}
return bRet;
}
/**
*
* @param lLoginID
* @param szPath
* @return true ; false
*/
public static boolean RemoveRemoteFilesArr(LLong lLoginID, String[] szPath) {
FILE_PATH[] filePath = new FILE_PATH[szPath.length];
for(int i = 0; i < szPath.length; i++) {
filePath[i] = new FILE_PATH();
}
for(int i = 0; i < szPath.length; i++) {
filePath[i].pszPath = "/mnt/sdcard/" + szPath[i];
System.out.println("/mnt/sdcard/" + szPath[i]);
}
// 入参
NET_IN_REMOVE_REMOTE_FILES stIn = new NET_IN_REMOVE_REMOTE_FILES();
stIn.nFileCount = szPath.length;
stIn.pszPathPointer = new Memory(filePath[0].size() * szPath.length);
stIn.pszPathPointer.clear(filePath[0].size() * szPath.length);
ToolKits.SetStructArrToPointerData(filePath, stIn.pszPathPointer);
// 出参
NET_OUT_REMOVE_REMOTE_FILES stOut = new NET_OUT_REMOVE_REMOTE_FILES();
boolean bRet = netsdkapi.CLIENT_RemoveRemoteFiles(lLoginID, stIn, stOut, 3000);
return bRet;
}
/**
*
* @param lLoginID
* @param szPath
* @return true ; false
*/
public static boolean RemoveAudioFiles(LLong lLoginID, String szPath) {
FILE_PATH filePath = new FILE_PATH();
filePath.pszPath = szPath;
// 入参
NET_IN_REMOVE_REMOTE_FILES stIn = new NET_IN_REMOVE_REMOTE_FILES();
stIn.nFileCount = 1;
stIn.pszPathPointer = filePath.getPointer();
// 出参
NET_OUT_REMOVE_REMOTE_FILES stOut = new NET_OUT_REMOVE_REMOTE_FILES();
filePath.write();
boolean bRet = netsdkapi.CLIENT_RemoveRemoteFiles(lLoginID, stIn, stOut, 3000);
filePath.read();
return bRet;
}
/**
*
* @param lLoginID
* @param szPath
* @return true ; false
*/
public static boolean RemoveRemoteFiles(LLong lLoginID, String szPath) {
FILE_PATH filePath = new FILE_PATH();
filePath.pszPath = "/mnt/sdcard/" + szPath;
// 入参
NET_IN_REMOVE_REMOTE_FILES stIn = new NET_IN_REMOVE_REMOTE_FILES();
stIn.nFileCount = 1;
stIn.pszPathPointer = filePath.getPointer();
// 出参
NET_OUT_REMOVE_REMOTE_FILES stOut = new NET_OUT_REMOVE_REMOTE_FILES();
filePath.write();
boolean bRet = netsdkapi.CLIENT_RemoveRemoteFiles(lLoginID, stIn, stOut, 3000);
filePath.read();
return bRet;
}
/**
*
* @param lLoginID d
* @param stOut
* @return
*/
public static NET_PROGRAM_ON_PLAYBOX[] GetAllProgramOnPlayBox(LLong lLoginID, NET_OUT_GET_ALL_PLAYBOX_PROGRAM stOut) {
// 入参
NET_IN_GET_ALL_PLAYBOX_PROGRAM stIn = new NET_IN_GET_ALL_PLAYBOX_PROGRAM();
NET_PROGRAM_ON_PLAYBOX[] playboxArr;
int maxProgramCount = 10; // 每次查询的节目信息个数
while(true) {
playboxArr = new NET_PROGRAM_ON_PLAYBOX[maxProgramCount];
for(int i = 0; i < maxProgramCount; i++) {
playboxArr[i] = new NET_PROGRAM_ON_PLAYBOX();
for(int j = 0; j < NetSDKLib.MAX_WINDOWS_COUNT; j++) {
// 申请一块内存,自己设置,设置大点
playboxArr[i].stuOrdinaryInfo.stuWindowsInfo[j].pstElementsBuf = new Memory(100 * 1024);
playboxArr[i].stuOrdinaryInfo.stuWindowsInfo[j].pstElementsBuf.clear(100 * 1024);
playboxArr[i].stuOrdinaryInfo.stuWindowsInfo[j].nBufLen = 100 * 1024;
}
}
// 出参
stOut.nMaxProgramCount = maxProgramCount;
stOut.pstProgramInfo = new Memory(playboxArr[0].size() * maxProgramCount);
stOut.pstProgramInfo.clear(playboxArr[0].size() * maxProgramCount);
ToolKits.SetStructArrToPointerData(playboxArr, stOut.pstProgramInfo); // 将数组内存拷贝给Pointer
if(netsdkapi.CLIENT_GetAllProgramOnPlayBox(lLoginID, stIn, stOut, 3000)) {
if(maxProgramCount > stOut.nRetProgramCount) {
ToolKits.GetPointerDataToStructArr(stOut.pstProgramInfo, playboxArr); // 将Pointer的信息输出到结构体
break;
} else {
maxProgramCount += 10;
}
} else {
return null;
}
}
return playboxArr;
}
/**
*
* @param lLoginID
* @param szProGrammeIdList ID
* @return true ; false
*/
public static boolean DelMultiProgrammesById(LLong lLoginID, String[] szProGrammeIdList) {
// 入参
NET_IN_DEL_PROGRAMMES stIn = new NET_IN_DEL_PROGRAMMES();
stIn.nProgrammeID = szProGrammeIdList.length; // 需要删除的节目ID个数
for(int i = 0; i < szProGrammeIdList.length; i++) {
System.arraycopy(szProGrammeIdList[i].getBytes(), 0, stIn.szProGrammeIdListArr[i].szProGrammeIdList, 0, szProGrammeIdList[i].getBytes().length);
}
// 出参
NET_OUT_DEL_PROGRAMMES stOut = new NET_OUT_DEL_PROGRAMMES();
return netsdkapi.CLIENT_DelMultiProgrammesById(lLoginID, stIn, stOut, 5000);
}
/**
*
* @param lLoginID
* @param szPlanID ID
* @return true ; false
*/
public static boolean DelMultiProgrammePlans(LLong lLoginID, String[] szPlanID) {
// 入参
NET_IN_DEL_PROGRAMMEPLANS stIn = new NET_IN_DEL_PROGRAMMEPLANS();
stIn.nPlanID = szPlanID.length; // 节目计划ID个数
for(int i = 0; i < szPlanID.length; i++) {
System.arraycopy(szPlanID[i].getBytes(), 0, stIn.szPlanIDArr[i].szPlanID, 0, szPlanID[i].getBytes().length);
}
// 出参
NET_OUT_DEL_PROGRAMMEPLANS stOut = new NET_OUT_DEL_PROGRAMMEPLANS();
return netsdkapi.CLIENT_DelMultiProgrammePlans(lLoginID, stIn, stOut, 5000);
}
/**
*
* @param lLoginID
* @param stOut
* @return NET_PROGRAMME_PLANS_INFO
*/
public static NET_PROGRAMME_PLANS_INFO GetAllProgrammePlans(LLong lLoginID, NET_OUT_GET_ALL_PROGRAMMEPLANS stOut) {
// 入参
NET_IN_GET_ALL_PROGRAMMEPLANS stIn = new NET_IN_GET_ALL_PROGRAMMEPLANS();
NET_PROGRAMME_PLANS_INFO planInfo;
int maxPlanCnt = 10; // 每次查询的计划个数
while(true) {
planInfo = new NET_PROGRAMME_PLANS_INFO(maxPlanCnt);
// 出参
stOut.nMaxPlanCnt = maxPlanCnt;
stOut.pstImmePlan = new Memory(stOut.nMaxPlanCnt * planInfo.szImmePlan[0].size());
stOut.pstImmePlan.clear(stOut.nMaxPlanCnt * planInfo.szImmePlan[0].size());
stOut.pstTimerPlan = new Memory(stOut.nMaxPlanCnt * planInfo.szTimerPlan[0].size());
stOut.pstTimerPlan.clear(stOut.nMaxPlanCnt * planInfo.szTimerPlan[0].size());
ToolKits.SetStructArrToPointerData(planInfo.szImmePlan, stOut.pstImmePlan); // 将数组内存拷贝给Pointer
ToolKits.SetStructArrToPointerData(planInfo.szTimerPlan, stOut.pstTimerPlan); // 将数组内存拷贝给Pointer
if(netsdkapi.CLIENT_GetAllProgrammePlans(lLoginID, stIn, stOut, 3000)) {
if(maxPlanCnt > stOut.nRetImmCnt && maxPlanCnt > stOut.nRetTimerCnt) {
ToolKits.GetPointerDataToStructArr(stOut.pstImmePlan, planInfo.szImmePlan); // 将Pointer的值输出到数组
ToolKits.GetPointerDataToStructArr(stOut.pstTimerPlan, planInfo.szTimerPlan); // 将Pointer的值输出到数组
break;
} else {
maxPlanCnt += 10;
}
} else {
return null;
}
}
return planInfo;
}
// Win下将GBK String类型的转为Pointer
public static Pointer GetGBKStringToPointer(String src) {
Pointer pointer = null;
try {
byte[] b = src.getBytes("GBK");
pointer = new Memory(b.length+1);
pointer.clear(b.length+1);
pointer.write(0, b, 0, b.length);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
return pointer;
}
// win下将Pointer值转为 GBK String
public static String GetPointerDataToGBKString(Pointer pointer) {
String str = "";
if(pointer == null) {
return str;
}
int length = 0;
byte[] bufferPlace = new byte[1];
for(int i = 0; i < 2048; i++) {
pointer.read(i, bufferPlace, 0, 1);
if(bufferPlace[0] == '\0') {
length = i;
break;
}
}
if(length > 0) {
byte[] buffer = new byte[length];
pointer.read(0, buffer, 0, length);
try {
str = new String(buffer, "GBK").trim();
} catch (UnsupportedEncodingException e) {
return str;
}
}
return str;
}
// win下将Pointer值转为 GBK String
public static String GetPointerDataToGBKString(Pointer pointer, int length) {
String str = "";
if(pointer == null) {
return str;
}
if(length > 0) {
byte[] buffer = new byte[length];
pointer.read(0, buffer, 0, length);
try {
str = new String(buffer, "GBK").trim();
} catch (UnsupportedEncodingException e) {
return str;
}
}
return str;
}
public static void StringToByteArray(String src, byte[] dst) {
for(int i = 0; i < dst.length; i++) {
dst[i] = 0;
}
System.arraycopy(src.getBytes(), 0, dst, 0, src.getBytes().length);
}
/**
* MD5
* @param path
* @return MD5
* @throws FileNotFoundException
*/
public static String GetStringMD5(String path) {
File file = new File(path);
String value = "";
FileInputStream inputStream = null;
try {
inputStream = new FileInputStream(file);
MappedByteBuffer byteBuffer = inputStream.getChannel().map(FileChannel.MapMode.READ_ONLY, 0, file.length());
MessageDigest md5 = MessageDigest.getInstance("MD5");
md5.update(byteBuffer);
BigInteger bi = new BigInteger(1, md5.digest());
value = bi.toString(16);
} catch (Exception e) {
e.printStackTrace();
} finally {
if(null != inputStream) {
try {
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return value;
}
/**
*
* @param stream
* @return
*/
public static Pointer setStreamToPointer(InputStream stream){
Pointer pointer=null;
try {
int size=stream.available();
pointer=new Memory(size);
byte[] data=new byte[size];
stream.read(data);
pointer.write(0,data,0,size);
} catch (IOException e) {
e.printStackTrace();
}finally {
return pointer;
}
}
}

@ -0,0 +1,197 @@
package com.netsdk.lib;
import com.sun.jna.IntegerType;
import com.sun.jna.Native;
import com.sun.jna.Platform;
import com.sun.jna.Structure;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
public class Utils {
public Utils() {}
/** 获取系统对应的编码 */
public static String getPlatformEncode() {
String encode = "";
String osPrefix = getOsPrefix();
if (osPrefix.toLowerCase().startsWith("win32")) {
encode = "GBK";
} else if (osPrefix.toLowerCase().startsWith("linux")) {
encode = "UTF-8";
}
if (encode.isEmpty()) {
encode = "UTF-8";
}
return encode;
}
// 获取操作平台信息
public static String getOsPrefix() {
String arch = System.getProperty("os.arch").toLowerCase();
final String name = System.getProperty("os.name");
String osPrefix;
switch (Platform.getOSType()) {
case Platform.WINDOWS:
{
if ("i386".equals(arch)) arch = "x86";
osPrefix = "win32-" + arch;
}
break;
case Platform.LINUX:
{
if ("x86".equals(arch)) {
arch = "i386";
} else if ("x86_64".equals(arch)) {
arch = "amd64";
}
osPrefix = "linux-" + arch;
}
break;
case Platform.MAC:
{
// mac系统的os.arch都是ppc(老版本的mac是powerpc已经基本不用)看不出系统位数,使用下面的参数表示
arch = System.getProperty("sun.arch.data.model");
osPrefix = "mac-" + arch;
}
break;
default:
{
osPrefix = name.toLowerCase();
if ("x86".equals(arch)) {
arch = "i386";
}
if ("x86_64".equals(arch)) {
arch = "amd64";
}
int space = osPrefix.indexOf(" ");
if (space != -1) {
osPrefix = osPrefix.substring(0, space);
}
osPrefix += "-" + arch;
}
break;
}
return osPrefix;
}
public static String getOsName() {
String osName = "";
String osPrefix = getOsPrefix();
if (osPrefix.toLowerCase().startsWith("win32-x86")
|| osPrefix.toLowerCase().startsWith("win32-amd64")) {
osName = "win";
} else if (osPrefix.toLowerCase().startsWith("linux-i386")
|| osPrefix.toLowerCase().startsWith("linux-amd64")) {
osName = "linux";
} else if (osPrefix.toLowerCase().startsWith("mac-64")
|| osPrefix.toLowerCase().startsWith("mac-32")) {
osName = "mac";
}
return osName;
}
// 获取加载库
public static String getLoadLibrary(String library) {
if (isChecking()) {
return null;
}
String loadLibrary = "";
String osPrefix = getOsPrefix();
if (osPrefix.toLowerCase().startsWith("win32-x86")) {
loadLibrary = "./libs/win32/";
} else if (osPrefix.toLowerCase().startsWith("win32-amd64")) {
loadLibrary = "./libs/win64/";
} else if (osPrefix.toLowerCase().startsWith("linux-i386")) {
loadLibrary = "";
} else if (osPrefix.toLowerCase().startsWith("linux-amd64")) {
loadLibrary = "";
} else if (osPrefix.toLowerCase().startsWith("mac-64")) {
loadLibrary = "";
}
// else if(osPrefix.toLowerCase().startsWith("mac-32")) {
// loadLibrary = "";
// } 32位mac版本基本没人用了暂时不用
System.out.printf("加载库[%s]\n", loadLibrary + library);
return loadLibrary + library;
}
private static boolean checking = false;
public static void setChecking() {
checking = true;
}
public static void clearChecking() {
checking = false;
}
public static boolean isChecking() {
return checking;
}
public static class LLong extends IntegerType {
private static final long serialVersionUID = 1L;
/** Size of a native long, in bytes. */
public static int size;
static {
size = Native.LONG_SIZE;
if (Utils.getOsPrefix().toLowerCase().equals("linux-amd64")
|| Utils.getOsPrefix().toLowerCase().equals("win32-amd64")
|| Utils.getOsPrefix().toLowerCase().equals("mac-64")) {
size = 8;
} else if (Utils.getOsPrefix().toLowerCase().equals("linux-i386")
|| Utils.getOsPrefix().toLowerCase().equals("win32-x86")) {
size = 4;
}
}
/** Create a zero-valued LLong. */
public LLong() {
this(0);
}
/** Create a LLong with the given value. */
public LLong(long value) {
super(size, value);
}
}
public static class SdkStructure extends Structure {
@Override
protected List<String> getFieldOrder() {
List<String> fieldOrderList = new ArrayList<String>();
for (Class<?> cls = getClass();
!cls.equals(NetSDKLib.SdkStructure.class);
cls = cls.getSuperclass()) {
Field[] fields = cls.getDeclaredFields();
int modifiers;
for (Field field : fields) {
modifiers = field.getModifiers();
if (Modifier.isStatic(modifiers) || !Modifier.isPublic(modifiers)) {
continue;
}
fieldOrderList.add(field.getName());
}
}
// System.out.println(fieldOrderList);
return fieldOrderList;
}
}
// 获取当前时间
public static String getDate() {
SimpleDateFormat simpleDate = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
return simpleDate.format(new java.util.Date()).replace(" ", "_").replace(":", "-");
}
}

@ -0,0 +1,36 @@
package com.netsdk.lib.callback;
import com.netsdk.lib.NetSDKLib;
import com.netsdk.lib.ToolKits;
import com.netsdk.lib.enumeration.EM_HEATMAP_TYPE;
import com.netsdk.lib.structure.NET_CB_VIDEOSTAT_HEATMAP;
import com.sun.jna.Pointer;
/**
* @author 47081
* @version 1.0
* @description
* @date 2020/9/24
*/
public abstract class BasicVideoStatHeatMapCallBack implements fVideoStatHeatMapCallBack {
@Override
public void invoke(
NetSDKLib.LLong lAttachHandle,
Pointer pBuf,
Pointer pBinData,
int dwBinDataLen,
Pointer dwUser) {
/** 获取热度图数据 */
NET_CB_VIDEOSTAT_HEATMAP heatmap = new NET_CB_VIDEOSTAT_HEATMAP();
ToolKits.GetPointerData(pBuf, heatmap);
byte[] bytes = new byte[dwBinDataLen];
pBinData.read(0, bytes, 0, dwBinDataLen);
/** 处理热度图数据 */
parseData(
lAttachHandle.longValue(),
heatmap.nToken,
EM_HEATMAP_TYPE.getEmHeatMap(heatmap.emHeatMapType),
bytes);
}
public abstract void parseData(long attachHandle, int nToken, EM_HEATMAP_TYPE type, byte[] binData);
}

@ -0,0 +1,40 @@
package com.netsdk.lib.callback;
import com.netsdk.lib.NetSDKLib;
import com.netsdk.lib.ToolKits;
import com.netsdk.lib.structure.NET_CB_REDIRECT_SERVER_CALLBACK_INFO;
import com.netsdk.lib.structure.NET_IN_START_REDIRECT_SERVICE;
import com.sun.jna.Callback;
import com.sun.jna.Pointer;
/**
* @author 47081
* @version 1.0
* @description
* @date 2021/3/13
*/
public interface fRedirectServerCallBackEx extends Callback {
/**
* @param lDevHandle
* @param pInParam ,{@link NET_CB_REDIRECT_SERVER_CALLBACK_INFO}
* @param dwUserData ,{@link
* NET_IN_START_REDIRECT_SERVICE#dwUserData},dwUserjvm,
* dwUser
* @return
*/
default int callback(NetSDKLib.LLong lDevHandle, Pointer pInParam, Pointer dwUserData) {
NET_CB_REDIRECT_SERVER_CALLBACK_INFO info = new NET_CB_REDIRECT_SERVER_CALLBACK_INFO();
ToolKits.GetPointerDataToStruct(pInParam, 0, info);
dealWithData(lDevHandle.longValue(), info, dwUserData);
return 0;
}
/**
*
*
* @param devHandler
* @param info
* @param userData
*/
void dealWithData(long devHandler, NET_CB_REDIRECT_SERVER_CALLBACK_INFO info, Pointer userData);
}

@ -0,0 +1,30 @@
package com.netsdk.lib.callback;
import com.netsdk.lib.NetSDKLib;
import com.netsdk.lib.ToolKits;
import com.netsdk.lib.enumeration.EM_HEATMAP_TYPE;
import com.netsdk.lib.structure.NET_CB_VIDEOSTAT_HEATMAP;
import com.sun.jna.Callback;
import com.sun.jna.Pointer;
/**
* @author 47081
* @version 1.0
* @description
* @date 2020/9/21
*/
public interface fVideoStatHeatMapCallBack extends Callback {
/**
* @param lAttachHandle
* @param pBuf {@link com.netsdk.lib.structure.NET_CB_VIDEOSTAT_HEATMAP}
* @param pBinData
* @param dwBinDataLen
* @param dwUser
*/
void invoke(
NetSDKLib.LLong lAttachHandle,
Pointer pBuf,
Pointer pBinData,
int dwBinDataLen,
Pointer dwUser);
}

@ -0,0 +1,445 @@
package com.netsdk.lib.callback.impl;
import java.io.File;
import java.nio.charset.Charset;
import java.util.Objects;
import com.netsdk.lib.Utils;
import com.netsdk.lib.enumeration.EM_EVENT_IVS_TYPE;
import com.netsdk.lib.structure.DEV_EVENT_HUDDLE_MATERIAL_INFO;
import com.netsdk.lib.structure.DEV_EVENT_OUTDOOR_ADVERTISEMENT_INFO;
import com.netsdk.lib.structure.DEV_EVENT_SHOP_SIGN_ABNORMAL_INFO;
import com.netsdk.lib.structure.DEV_EVENT_SHOP_WINDOW_POST_INFO;
import com.netsdk.lib.structure.DEV_EVENT_STREET_SUNCURE_INFO;
import com.netsdk.lib.structure.DEV_EVENT_TRAFFIC_PEDESTRAINRUNREDLIGHT_INFO;
import com.sun.jna.Pointer;
import com.netsdk.lib.NetSDKLib;
import com.netsdk.lib.ToolKits;
/**
*
*/
public class AnalyzerDataCB implements NetSDKLib.fAnalyzerDataCallBack {
private final File picturePath;
private static AnalyzerDataCB instance;
private AnalyzerDataCB() {
picturePath = new File("./AnalyzerPicture/");
if (!picturePath.exists()) {
picturePath.mkdirs();
}
}
public static AnalyzerDataCB getInstance() {
if (instance == null) {
instance = new AnalyzerDataCB();
}
return instance;
}
// 回调
public int invoke(NetSDKLib.LLong lAnalyzerHandle, int dwAlarmType, Pointer pAlarmInfo,
Pointer pBuffer, int dwBufSize, Pointer dwUser, int nSequence, Pointer reserved) {
if (lAnalyzerHandle == null || lAnalyzerHandle.longValue() == 0) {
return -1;
}
NetSDKLib.NET_EVENT_FILE_INFO stuFileInfo = null;
NetSDKLib.NET_PIC_INFO stPicInfo = null;
switch (Objects.requireNonNull(EM_EVENT_IVS_TYPE.getEventType(dwAlarmType))) {
case EVENT_IVS_PARKINGDETECTION: // 非法停车事件
{
NetSDKLib.DEV_EVENT_PARKINGDETECTION_INFO msg = new NetSDKLib.DEV_EVENT_PARKINGDETECTION_INFO();
ToolKits.GetPointerData(pAlarmInfo, msg);
stuFileInfo = msg.stuFileInfo;
stPicInfo = msg.stuObject.stPicInfo;
System.out.printf("【非法停车事件】 时间(UTC):%s 通道号:%d 开始时间:%s 结束时间:%s 事件触发累计次数:%d 事件源设备唯一标识:%s \n",
msg.UTC, msg.nChannelID, msg.stuObject.stuStartTime, msg.stuObject.stuEndTime,
msg.nOccurrenceCount, new String(msg.szSourceDevice));
break;
}
case EVENT_IVS_FIGHTDETECTION: // 斗殴事件
{
NetSDKLib.DEV_EVENT_FIGHT_INFO msg = new NetSDKLib.DEV_EVENT_FIGHT_INFO();
ToolKits.GetPointerData(pAlarmInfo, msg);
String Picture = picturePath + "\\" + System.currentTimeMillis() + ".jpg";
ToolKits.savePicture(pBuffer, 0, dwBufSize, Picture);
System.out.println(" 斗殴事件 时间(UTC)" + msg.UTC + " 通道号:" + msg.nChannelID);
break;
}
case EVENT_IVS_LEAVEDETECTION: // 离岗检测事件
{
NetSDKLib.DEV_EVENT_IVS_LEAVE_INFO msg = new NetSDKLib.DEV_EVENT_IVS_LEAVE_INFO();
ToolKits.GetPointerData(pAlarmInfo, msg);
stuFileInfo = msg.stuFileInfo;
stPicInfo = msg.stuObject.stPicInfo;
System.out.printf("【离岗检测事件】 时间(UTC):%s 通道号:%d 开始时间:%s 结束时间:%s \n",
msg.UTC, msg.nChannelID, msg.stuObject.stuStartTime, msg.stuObject.stuEndTime);
break;
}
case EVENT_IVS_CROSSLINEDETECTION: // 拌线入侵事件
{
NetSDKLib.DEV_EVENT_CROSSLINE_INFO msg = new NetSDKLib.DEV_EVENT_CROSSLINE_INFO();
ToolKits.GetPointerData(pAlarmInfo, msg);
stuFileInfo = msg.stuFileInfo;
stPicInfo = msg.stuObject.stPicInfo;
System.out.printf("【拌线入侵事件】 时间(UTC):%s 通道号:%d 开始时间:%s 结束时间:%s 事件触发累计次数:%d 事件源设备唯一标识:%s \n",
msg.UTC, msg.nChannelID, msg.stuObject.stuStartTime, msg.stuObject.stuEndTime,
msg.nOccurrenceCount, new String(msg.szSourceDevice));
break;
}
case EVENT_IVS_RIOTERDETECTION: // 聚众事件
{
NetSDKLib.DEV_EVENT_RIOTERL_INFO msg = new NetSDKLib.DEV_EVENT_RIOTERL_INFO();
ToolKits.GetPointerData(pAlarmInfo, msg);
stuFileInfo = msg.stuFileInfo;
stPicInfo = msg.stuObjectIDs[0].stPicInfo; // 取第一个
System.out.printf("【聚众事件】 时间(UTC):%s 通道号:%d 检测到的物体个数:%d 事件触发累计次数:%d 事件源设备唯一标识:%s \n",
msg.UTC, msg.nChannelID, msg.nObjectNum,
msg.nOccurrenceCount, new String(msg.szSourceDevice));
break;
}
case EVENT_IVS_LEFTDETECTION: // 物品遗留事件
{
NetSDKLib.DEV_EVENT_LEFT_INFO msg = new NetSDKLib.DEV_EVENT_LEFT_INFO();
ToolKits.GetPointerData(pAlarmInfo, msg);
stuFileInfo = msg.stuFileInfo;
stPicInfo = msg.stuObject.stPicInfo;
System.out.printf("【物品遗留事件】 时间(UTC):%s 通道号:%d 开始时间:%s 结束时间:%s 事件触发累计次数:%d 事件源设备唯一标识:%s \n",
msg.UTC, msg.nChannelID, msg.stuObject.stuStartTime, msg.stuObject.stuEndTime,
msg.nOccurrenceCount, new String(msg.szSourceDevice));
break;
}
case EVENT_IVS_STAYDETECTION: // 停留事件
{
//System.out.printf("【停留事件】\n");
NetSDKLib.DEV_EVENT_STAY_INFO msg = new NetSDKLib.DEV_EVENT_STAY_INFO();
ToolKits.GetPointerData(pAlarmInfo, msg);
stuFileInfo = msg.stuFileInfo;
stPicInfo = msg.stuObject.stPicInfo;
System.out.printf("【停留事件】 时间(UTC):%s 通道号:%d 开始时间:%s 结束时间:%s \n",
msg.UTC, msg.nChannelID, msg.stuObject.stuStartTime, msg.stuObject.stuEndTime);
break;
}
case EVENT_IVS_WANDERDETECTION: // 徘徊事件
{
NetSDKLib.DEV_EVENT_WANDER_INFO msg = new NetSDKLib.DEV_EVENT_WANDER_INFO();
ToolKits.GetPointerData(pAlarmInfo, msg);
stuFileInfo = msg.stuFileInfo;
stPicInfo = msg.stuObjectIDs[0].stPicInfo; // 取第一个
System.out.printf("【徘徊事件】 时间(UTC):%s 通道号:%d 检测到的物体个数:%d 事件触发累计次数:%d 事件源设备唯一标识:%s \n",
msg.UTC, msg.nChannelID, msg.nObjectNum,
msg.nOccurrenceCount, new String(msg.szSourceDevice));
break;
}
case EVENT_IVS_MAN_NUM_DETECTION: ///< 立体视觉区域内人数统计事件
{
NetSDKLib.DEV_EVENT_MANNUM_DETECTION_INFO msg = new NetSDKLib.DEV_EVENT_MANNUM_DETECTION_INFO();
ToolKits.GetPointerData(pAlarmInfo, msg);
System.out.println(" 立体视觉区域内人数统计事件 时间(UTC)" + msg.UTC + " 通道号:" + msg.nChannelID +
" 区域人员列表数量:" + msg.nManListCount + " 人员身高:" + msg.stuManList[0].nStature);
break;
}
case EVENT_IVS_CROWDDETECTION: ///< 人群密度检测事件
{
NetSDKLib.DEV_EVENT_CROWD_DETECTION_INFO msg = new NetSDKLib.DEV_EVENT_CROWD_DETECTION_INFO();
ToolKits.GetPointerData(pAlarmInfo, msg);
System.out.println(" 人群密度检测事件 时间(UTC)" + msg.UTC + " 通道号:" + msg.nChannelID);
break;
}
case EVENT_IVS_WORKCLOTHES_DETECT: ///< 安全帽检测事件
{
NetSDKLib.DEV_EVENT_WORKCLOTHES_DETECT_INFO msg = new NetSDKLib.DEV_EVENT_WORKCLOTHES_DETECT_INFO();
ToolKits.GetPointerData(pAlarmInfo, msg);
if (msg.stuSceneImage != null && msg.stuSceneImage.nLength > 0) {
String bigPicture = picturePath + "\\" + System.currentTimeMillis() + ".jpg";
ToolKits.savePicture(pBuffer, msg.stuSceneImage.nOffSet, msg.stuSceneImage.nLength, bigPicture);
if (msg.stuHumanImage != null && msg.stuHumanImage.nLength > 0) {
String smallPicture = picturePath + "\\" + System.currentTimeMillis() + "small.jpg";
ToolKits.savePicture(pBuffer, msg.stuHumanImage.nOffSet, msg.stuHumanImage.nLength, smallPicture);
}
}
System.out.println(" 安全帽检测事件(UTC)" + msg.UTC + " 通道号:" + msg.nChannelID);
break;
}
case EVENT_IVS_CITY_MOTORPARKING: ///< 城市机动车违停事件
{
NetSDKLib.DEV_EVENT_CITY_MOTORPARKING_INFO msg = new NetSDKLib.DEV_EVENT_CITY_MOTORPARKING_INFO();
ToolKits.GetPointerData(pAlarmInfo, msg);
stuFileInfo = msg.stuFileInfo;
System.out.println(" 城市机动车违停事件 时间(UTC)" + msg.UTC + " 通道号:" + msg.nChannelID + "违停持续时长(单位秒)" + msg.nParkingDuration
+ "检测到的物体个数:" + msg.nObjectNum);
break;
}
case EVENT_IVS_CITY_NONMOTORPARKING: ///< 城市非机动车违停事件
{
NetSDKLib.DEV_EVENT_CITY_NONMOTORPARKING_INFO msg = new NetSDKLib.DEV_EVENT_CITY_NONMOTORPARKING_INFO();
ToolKits.GetPointerData(pAlarmInfo, msg);
stuFileInfo = msg.stuFileInfo;
System.out.println(" 城市非机动车违停事件 时间(UTC)" + msg.UTC + " 通道号:" + msg.nChannelID + "检测到的物体个数:" + msg.nObjectNum);
break;
}
case EVENT_IVS_HOLD_UMBRELLA: ///< 违规撑伞检测事件
{
NetSDKLib.DEV_EVENT_HOLD_UMBRELLA_INFO msg = new NetSDKLib.DEV_EVENT_HOLD_UMBRELLA_INFO();
ToolKits.GetPointerData(pAlarmInfo, msg);
stuFileInfo = msg.stuFileInfo;
System.out.println(" 违规撑伞检测事件 时间(UTC)" + msg.UTC + " 通道号:" + msg.nChannelID + "违法持续时长(单位秒)" + msg.nViolationDuration);
break;
}
case EVENT_IVS_PEDESTRIAN_JUNCTION: ///< 行人卡口事件
{
NetSDKLib.DEV_EVENT_PEDESTRIAN_JUNCTION_INFO msg = new NetSDKLib.DEV_EVENT_PEDESTRIAN_JUNCTION_INFO();
ToolKits.GetPointerData(pAlarmInfo, msg);
stuFileInfo = msg.stuFileInfo;
System.out.println(" 行人卡口事件 时间(UTC)" + msg.UTC + " 通道号:" + msg.nChannelID + "人行道号" + msg.nLane);
break;
}
case EVENT_IVS_DUSTBIN_OVER_FLOW: ///< 垃圾桶满溢检测事件
{
NetSDKLib.DEV_EVENT_DUSTBIN_OVER_FLOW_INFO msg = new NetSDKLib.DEV_EVENT_DUSTBIN_OVER_FLOW_INFO();
ToolKits.GetPointerData(pAlarmInfo, msg);
stuFileInfo = msg.stuFileInfo;
System.out.println(" 垃圾桶满溢检测事件 时间(UTC)" + msg.UTC + " 通道号:" + msg.nChannelID
+ "违法持续时长(单位秒)" + msg.nViolationDuration + "检测到的物体个数" + msg.nObjectNum);
break;
}
case EVENT_IVS_DOOR_FRONT_DIRTY: ///< 门前脏乱检测事件
{
NetSDKLib.DEV_EVENT_DOOR_FRONT_DIRTY_INFO msg = new NetSDKLib.DEV_EVENT_DOOR_FRONT_DIRTY_INFO();
ToolKits.GetPointerData(pAlarmInfo, msg);
stuFileInfo = msg.stuFileInfo;
System.out.println(" 门前脏乱检测事件 时间(UTC)" + msg.UTC + " 通道号:" + msg.nChannelID
+ "违法持续时长(单位秒)" + msg.nViolationDuration + "检测到的物体个数" + msg.nObjectNum);
break;
}
case EVENT_IVS_GARBAGE_EXPOSURE: ///< 垃圾暴露检测事件
{
NetSDKLib.DEV_EVENT_GARBAGE_EXPOSURE_INFO msg = new NetSDKLib.DEV_EVENT_GARBAGE_EXPOSURE_INFO();
ToolKits.GetPointerData(pAlarmInfo, msg);
stuFileInfo = msg.stuFileInfo;
System.out.println(" 垃圾暴露检测事件 时间(UTC)" + msg.UTC + " 通道号:" + msg.nChannelID
+ "违法持续时长(单位秒)" + msg.nViolationDuration + "检测到的物体个数" + msg.nObjectNum);
break;
}
case EVENT_IVS_VIOLENT_THROW_DETECTION: ///< 暴力抛物事件事件
{
NetSDKLib.DEV_EVENT_VIOLENT_THROW_DETECTION_INFO msg = new NetSDKLib.DEV_EVENT_VIOLENT_THROW_DETECTION_INFO();
ToolKits.GetPointerData(pAlarmInfo, msg);
if (msg.stuSceneImage != null && msg.stuSceneImage.nLength > 0) {
String bigPicture = picturePath + "\\" + System.currentTimeMillis() + "big.jpg";
ToolKits.savePicture(pBuffer, msg.stuSceneImage.nOffSet, msg.stuSceneImage.nLength, bigPicture);
}
stuFileInfo = msg.stuFileInfo;
System.out.println(" 暴力抛物事件事件 时间(UTC)" + msg.UTC + " 通道号:" + msg.nChannelID
+ "暴力抛物检测区域名称" + new String(msg.szRegionName, Charset.forName(Utils.getPlatformEncode())));
break;
}
case EVENT_IVS_FOG_DETECTION: ///< 起雾检测事件
{
NetSDKLib.DEV_EVENT_FOG_DETECTION msg = new NetSDKLib.DEV_EVENT_FOG_DETECTION();
ToolKits.GetPointerData(pAlarmInfo, msg);
String Picture = picturePath + "\\" + System.currentTimeMillis() + ".jpg";
ToolKits.savePicture(pBuffer, 0, dwBufSize, Picture);
System.out.println(" 起雾检测事件 时间(UTC)" + msg.UTC + " 通道号:" + msg.nChannelID
+ "事件组ID" + msg.nGroupID + "事件数据类型" + msg.emEventType + "雾等级" + msg.stuFogInfo.emFogLevel);
break;
}
case EVENT_IVS_ACCESS_CTL: ///< 门禁事件
{
NetSDKLib.DEV_EVENT_ACCESS_CTL_INFO msg = new NetSDKLib.DEV_EVENT_ACCESS_CTL_INFO();
ToolKits.GetPointerData(pAlarmInfo, msg);
String Picture = picturePath + "\\" + System.currentTimeMillis() + ".jpg";
ToolKits.savePicture(pBuffer, 0, dwBufSize, Picture);
System.out.println(" 门禁事件 时间(UTC)" + msg.UTC + " 通道号:" + msg.nChannelID
+ "事件组ID" + msg.nGroupID + "事件数据类型" + msg.emEventType + "人员温度信息是否有效" + msg.bManTemperature
+ "人员温度" + msg.stuManTemperatureInfo.fCurrentTemperature + "温度单位" + msg.stuManTemperatureInfo.emTemperatureUnit
+ "是否超温" + msg.stuManTemperatureInfo.bIsOverTemperature);
break;
}
case EVENT_IVS_AUDIO_ABNORMALDETECTION: // 声音异常检测
{
NetSDKLib.DEV_EVENT_IVS_AUDIO_ABNORMALDETECTION_INFO msg = new NetSDKLib.DEV_EVENT_IVS_AUDIO_ABNORMALDETECTION_INFO();
ToolKits.GetPointerData(pAlarmInfo, msg);
String Picture = picturePath + "\\" + System.currentTimeMillis() + ".jpg";
ToolKits.savePicture(pBuffer, 0, dwBufSize, Picture);
System.out.println(" 声音异常检测 时间(UTC)" + msg.UTC + " 通道号:" + msg.nChannelID + "声音强度" + msg.nDecibel + "声音频率" + msg.nFrequency);
break;
}
case EVENT_IVS_CLIMBDETECTION: // 攀高检测事件
{
NetSDKLib.DEV_EVENT_IVS_CLIMB_INFO msg = new NetSDKLib.DEV_EVENT_IVS_CLIMB_INFO();
ToolKits.GetPointerData(pAlarmInfo, msg);
stuFileInfo = msg.stuFileInfo;
stPicInfo = msg.stuObject.stPicInfo;
System.out.println(" 攀高检测事件 时间(UTC)" + msg.UTC + " 通道号:" + msg.nChannelID + " 开始时间:" + msg.stuObject.stuStartTime + " 结束时间:" + msg.stuObject.stuEndTime);
break;
}
case EVENT_IVS_CROSSREGIONDETECTION: ///< 区域入侵事件
{
NetSDKLib.DEV_EVENT_CROSSREGION_INFO msg = new NetSDKLib.DEV_EVENT_CROSSREGION_INFO();
ToolKits.GetPointerData(pAlarmInfo, msg);
String Picture = picturePath + "\\" + System.currentTimeMillis() + ".jpg";
ToolKits.savePicture(pBuffer, 0, dwBufSize, Picture);
System.out.println(" 区域入侵事件 时间(UTC)" + msg.UTC + " 通道号:" + msg.nChannelID + " 开始时间:" + msg.stuObject.stuStartTime + " 结束时间:" + msg.stuObject.stuEndTime);
// PrintStruct.print(msg);
break;
}
case EVENT_IVS_VIDEOABNORMALDETECTION: ///< 视频异常事件
{
NetSDKLib.DEV_EVENT_VIDEOABNORMALDETECTION_INFO msg = new NetSDKLib.DEV_EVENT_VIDEOABNORMALDETECTION_INFO();
ToolKits.GetPointerData(pAlarmInfo, msg);
String Picture = picturePath + "\\" + System.currentTimeMillis() + ".jpg";
ToolKits.savePicture(pBuffer, 0, dwBufSize, Picture);
System.out.println(" 视频异常事件 时间(UTC)" + msg.UTC + " 通道号:" + msg.nChannelID + "异常类型" + msg.bType);
break;
}
case EVENT_IVS_STAY_ALONE_DETECTION: ///< 单人独处事件
{
NetSDKLib.DEV_EVENT_STAY_ALONE_DETECTION_INFO msg = new NetSDKLib.DEV_EVENT_STAY_ALONE_DETECTION_INFO();
ToolKits.GetPointerData(pAlarmInfo, msg);
String Picture = picturePath + "\\" + System.currentTimeMillis() + ".jpg";
ToolKits.savePicture(pBuffer, 0, dwBufSize, Picture);
System.out.println(" 单人独处事件 时间(UTC)" + msg.UTC + " 通道号:" + msg.nChannelID + "物体ID" + msg.stuHuman.nObjectID);
break;
}
case EVENT_IVS_HIGH_TOSS_DETECT: ///< 高空抛物检测事件
{
NetSDKLib.DEV_EVENT_HIGH_TOSS_DETECT_INFO msg = new NetSDKLib.DEV_EVENT_HIGH_TOSS_DETECT_INFO();
ToolKits.GetPointerData(pAlarmInfo, msg);
String Picture = picturePath + "\\" + System.currentTimeMillis() + ".jpg";
ToolKits.savePicture(pBuffer, 0, dwBufSize, Picture);
System.out.println(" 高空抛物检测事件 时间(UTC)" + msg.UTC + " 通道号:" + msg.nChannelID);
break;
}
case EVENT_IVS_TRAFFIC_PEDESTRAINRUNREDLIGHT://行人闯红灯事件
{
DEV_EVENT_TRAFFIC_PEDESTRAINRUNREDLIGHT_INFO info = new DEV_EVENT_TRAFFIC_PEDESTRAINRUNREDLIGHT_INFO();
ToolKits.GetPointerData(pAlarmInfo, info);
stuFileInfo = info.stuFileInfo;
stPicInfo = info.stuObject.stPicInfo;
System.out.println(info.toString());
break;
}
case EVENT_IVS_FACEDETECT://人脸检测事件
{
NetSDKLib.DEV_EVENT_FACEDETECT_INFO info = new NetSDKLib.DEV_EVENT_FACEDETECT_INFO();
ToolKits.GetPointerData(pAlarmInfo, info);
stuFileInfo = info.stuFileInfo;
stPicInfo = info.stuObject.stPicInfo;
System.out.println("人脸检测: dwOffSet:" + stPicInfo.dwOffSet + ",dwFileLength:" + stPicInfo.dwFileLenth);
break;
}
case EVENT_IVS_SHOP_WINDOW_POST://橱窗张贴事件
{
DEV_EVENT_SHOP_WINDOW_POST_INFO info = new DEV_EVENT_SHOP_WINDOW_POST_INFO();
ToolKits.GetPointerData(pAlarmInfo, info);
stuFileInfo = info.stuFileInfo;
System.out.println(" 橱窗张贴事件 时间(UTC)" + info.UTC + " 通道号:" + info.nChannelID + " 商铺地址: " + new String(info.szShopAddress, Charset.forName(Utils.getPlatformEncode())).trim()
+ " 违法持续时间: " + info.nViolationDuration + " 检测到的物体数量: " + info.nObjectNum);
for (int i = 0; i < info.nObjectNum; i++) {
stPicInfo = info.stuObjects[i].stPicInfo;
if (stPicInfo != null && stPicInfo.dwFileLenth > 0) {
String smallPicture = picturePath + File.separator + String.format("Small_%d_%s_%d_%d_%d_%d.jpg",
dwAlarmType, stuFileInfo.stuFileTime.toStringTitle(), stuFileInfo.bCount,
stuFileInfo.bIndex, stuFileInfo.bFileType, stuFileInfo.nGroupId);
ToolKits.savePicture(pBuffer, stPicInfo.dwOffSet, stPicInfo.dwFileLenth, smallPicture);
}
}
break;
}
case EVENT_IVS_SHOP_SIGN_ABNORMAL: {//店招异常事件
DEV_EVENT_SHOP_SIGN_ABNORMAL_INFO info = new DEV_EVENT_SHOP_SIGN_ABNORMAL_INFO();
ToolKits.GetPointerData(pAlarmInfo, info);
stuFileInfo = info.stuFileInfo;
System.out.println(" 店招异常事件 时间(UTC)" + info.UTC + " 通道号:" + info.nChannelID + " 商铺地址: " + new String(info.szShopAddress, Charset.forName(Utils.getPlatformEncode())).trim()
+ " 违法持续时间: " + info.nViolationDuration + " 检测到的物体数量: " + info.nObjectNum);
String Picture = picturePath + "\\" + System.currentTimeMillis() + ".jpg";
ToolKits.savePicture(pBuffer, 0, dwBufSize, Picture);
for (int i = 0; i < info.nObjectNum; i++) {
stPicInfo = info.stuObjects[i].stPicInfo;
if (stPicInfo != null && stPicInfo.dwFileLenth > 0) {
String smallPicture = picturePath + File.separator + String.format("Small_%d_%s_%d_%d_%d_%d.jpg",
dwAlarmType, stuFileInfo.stuFileTime.toStringTitle(), stuFileInfo.bCount,
stuFileInfo.bIndex, stuFileInfo.bFileType, stuFileInfo.nGroupId);
if (stPicInfo.dwOffSet != 0 && stPicInfo.dwFileLenth != 0) {
ToolKits.savePicture(pBuffer, stPicInfo.dwOffSet, stPicInfo.dwFileLenth, smallPicture);
}
}
}
break;
}
case EVENT_IVS_STREET_SUNCURE: {//沿街晾晒事件
DEV_EVENT_STREET_SUNCURE_INFO info = new DEV_EVENT_STREET_SUNCURE_INFO();
ToolKits.GetPointerData(pAlarmInfo, info);
stuFileInfo = info.stuFileInfo;
System.out.println(" 沿街晾晒事件 时间(UTC)" + info.UTC + " 通道号:" + info.nChannelID + " 违法持续时间: " + info.nViolationDuration + " 检测到的物体数量: " + info.nObjectNum);
for (int i = 0; i < info.nObjectNum; i++) {
stPicInfo = info.stuObjects[i].stPicInfo;
if (stPicInfo != null && stPicInfo.dwFileLenth > 0) {
String smallPicture = picturePath + File.separator + String.format("Small_%d_%s_%d_%d_%d_%d.jpg",
dwAlarmType, stuFileInfo.stuFileTime.toStringTitle(), stuFileInfo.bCount,
stuFileInfo.bIndex, stuFileInfo.bFileType, stuFileInfo.nGroupId);
ToolKits.savePicture(pBuffer, stPicInfo.dwOffSet, stPicInfo.dwFileLenth, smallPicture);
}
}
break;
}
case EVENT_IVS_OUTDOOR_ADVERTISEMENT: {//户外广告事件
DEV_EVENT_OUTDOOR_ADVERTISEMENT_INFO info = new DEV_EVENT_OUTDOOR_ADVERTISEMENT_INFO();
ToolKits.GetPointerData(pAlarmInfo, info);
stuFileInfo = info.stuFileInfo;
System.out.println(" 户外广告事件 时间(UTC)" + info.UTC + " 通道号:" + info.nChannelID
+ " 违法持续时间: " + info.nViolationDuration + " 检测到的物体数量: " + info.nObjectNum);
for (int i = 0; i < info.nObjectNum; i++) {
stPicInfo = info.stuObjects[i].stPicInfo;
if (stPicInfo != null && stPicInfo.dwFileLenth > 0) {
String smallPicture = picturePath + File.separator + String.format("Small_%d_%s_%d_%d_%d_%d.jpg",
dwAlarmType, stuFileInfo.stuFileTime.toStringTitle(), stuFileInfo.bCount,
stuFileInfo.bIndex, stuFileInfo.bFileType, stuFileInfo.nGroupId);
ToolKits.savePicture(pBuffer, stPicInfo.dwOffSet, stPicInfo.dwFileLenth, smallPicture);
}
}
break;
}
case EVENT_IVS_HUDDLE_MATERIAL: {//乱堆物料检测事件
DEV_EVENT_HUDDLE_MATERIAL_INFO info = new DEV_EVENT_HUDDLE_MATERIAL_INFO();
ToolKits.GetPointerData(pAlarmInfo, info);
stuFileInfo = info.stuFileInfo;
System.out.println(" 乱堆物料检测事件 时间(UTC)" + info.UTC + " 通道号:" + info.nChannelID + " 违法持续时间: " + info.nViolationDuration + " 检测到的物体数量: " + info.nObjectNum);
for (int i = 0; i < info.nObjectNum; i++) {
stPicInfo = info.stuObjects[i].stPicInfo;
if (stPicInfo != null && stPicInfo.dwFileLenth > 0) {
String smallPicture = picturePath + File.separator + String.format("Small_%d_%s_%d_%d_%d_%d.jpg",
dwAlarmType, stuFileInfo.stuFileTime.toStringTitle(), stuFileInfo.bCount,
stuFileInfo.bIndex, stuFileInfo.bFileType, stuFileInfo.nGroupId);
ToolKits.savePicture(pBuffer, stPicInfo.dwOffSet, stPicInfo.dwFileLenth, smallPicture);
}
}
break;
}
default:
break;
}
if (stuFileInfo != null) { // 保存图片
String bigPicture = picturePath + File.separator + String.format("Big_%d_%s_%d_%d_%d_%d.jpg",
dwAlarmType, stuFileInfo.stuFileTime.toStringTitle(), stuFileInfo.bCount,
stuFileInfo.bIndex, stuFileInfo.bFileType, stuFileInfo.nGroupId);
ToolKits.savePicture(pBuffer, 0, dwBufSize, bigPicture);
if (stPicInfo != null && stPicInfo.dwFileLenth > 0) {
String smallPicture = picturePath + File.separator + String.format("Small_%d_%s_%d_%d_%d_%d.jpg",
dwAlarmType, stuFileInfo.stuFileTime.toStringTitle(), stuFileInfo.bCount,
stuFileInfo.bIndex, stuFileInfo.bFileType, stuFileInfo.nGroupId);
ToolKits.savePicture(pBuffer, stPicInfo.dwOffSet, stPicInfo.dwFileLenth, smallPicture);
}
}
return 0;
}
}

@ -0,0 +1,128 @@
package com.netsdk.lib.callback.impl;
import com.netsdk.lib.NetSDKLib;
import com.netsdk.lib.ToolKits;
import com.netsdk.lib.Utils;
import com.sun.jna.Pointer;
import java.io.File;
import java.nio.charset.Charset;
/**
* @author 47040
* @since Created in 2020/7/18 10:51
*/
public class DefaultAnalyseTaskResultCallBack implements NetSDKLib.fAnalyseTaskResultCallBack {
private static DefaultAnalyseTaskResultCallBack singleInstance;
private File picturePath;
private static NetSDKLib.DEV_EVENT_FACERECOGNITION_INFO msg=new NetSDKLib.DEV_EVENT_FACERECOGNITION_INFO();
private DefaultAnalyseTaskResultCallBack() {
picturePath = new File("./AnalyzerPicture/");
if (!picturePath.exists()) {
picturePath.mkdir();
}
}
public static DefaultAnalyseTaskResultCallBack getSingleInstance() {
if (singleInstance == null) {
singleInstance = new DefaultAnalyseTaskResultCallBack();
}
return singleInstance;
}
@Override
public int invoke(NetSDKLib.LLong lAttachHandle, Pointer pstAnalyseTaskResult, Pointer pBuf, int dwBufSize, Pointer dwUser) {
long start=System.currentTimeMillis();
NetSDKLib.NET_CB_ANALYSE_TASK_RESULT_INFO task = new NetSDKLib.NET_CB_ANALYSE_TASK_RESULT_INFO();
ToolKits.GetPointerData(pstAnalyseTaskResult, task); // 从指针获取智能事件分析信息
for (int i = 0; i < task.nTaskResultNum; i++) {
// nTaskID 和主动推送时的一一对应
System.out.println(task.stuTaskResultInfos[i].nTaskID);
// 实际的事件个数
for (int j = 0; j < task.stuTaskResultInfos[i].nEventCount; j++) {
NetSDKLib.NET_SECONDARY_ANALYSE_EVENT_INFO info = task.stuTaskResultInfos[i].stuEventInfos[j];
// 事件类型 对应 EM_ANALYSE_EVENT_TYPE
System.out.println("type:" + info.emEventType);
switch (info.emEventType) {
//特征提取
case NetSDKLib.EM_ANALYSE_EVENT_TYPE.EM_ANALYSE_EVENT_FEATURE_ABSTRACT: {
NetSDKLib.DEV_EVENT_FEATURE_ABSTRACT_INFO stInfo = new NetSDKLib.DEV_EVENT_FEATURE_ABSTRACT_INFO();
ToolKits.GetPointerDataToStruct(info.pstEventInfo, 0, stInfo);
System.out.println("nChannelID:" + stInfo.nChannelID); // 通道号
System.out.println("nAction:" + stInfo.nAction); // 0:脉冲 1:开始 2:停止
System.out.println("emClassType:" + stInfo.emClassType); // 智能事件所属大类 参考 EM_CLASS_TYPE
for (int k = 0; k < stInfo.nFeatureNum; k++) {
// 错误码、特征版本号
System.out.println("FeatureVectorList[" + k + "].FeatureErrCode:" + stInfo.stuFeatureVectorList[k].emFeatureErrCode); // 错误码
System.out.println("FeatureVectorList[" + k + "].szFeatureVersion:" + new String(stInfo.stuFeatureVectorList[k].szFeatureVersion).trim()); // 特征版本版本号
// 这里的特征是设备用于比对的二进制数据,不是图片,具体内容请咨询设备研发
System.out.println("FeatureVectorList[" + k + "].stuFeatureVector.dwOffset:" + stInfo.stuFeatureVectorList[k].stuFeatureVector.dwOffset); // 人脸小图特征值在二进制数据块中的偏移
System.out.println("FeatureVectorList[" + k + "].stuFeatureVector.dwLength:" + stInfo.stuFeatureVectorList[k].stuFeatureVector.dwLength); // 人脸小图特征值长度,单位:字节
// 人脸抓拍角度、质量数据
System.out.println("FeatureVectorList[" + k + "].stuFaceAttribute.nAngle1:" + stInfo.stuFeatureVectorList[k].stuFaceAttribute.nAngle[0]); // 人脸抓拍角度,三个角度分别是:仰俯角,偏航角,翻滚角;默认值[999,999,999]表示无此数据
System.out.println("FeatureVectorList[" + k + "].stuFaceAttribute.nAngle2:" + stInfo.stuFeatureVectorList[k].stuFaceAttribute.nAngle[1]); // 偏航角
System.out.println("FeatureVectorList[" + k + "].stuFaceAttribute.nAngle3:" + stInfo.stuFeatureVectorList[k].stuFaceAttribute.nAngle[2]); // 翻滚角
System.out.println("FeatureVectorList[" + k + "].stuFeatureVector.nFaceAlignScore:" + stInfo.stuFeatureVectorList[k].stuFaceAttribute.nFaceAlignScore); // 人脸对齐得分分数,取值范围 0~10000-1为无效值
System.out.println("FeatureVectorList[" + k + "].stuFeatureVector.nFaceQuality:" + stInfo.stuFeatureVectorList[k].stuFaceAttribute.nFaceQuality); // 人脸抓拍质量分数,取值范围 0~10000
}
break;
}
//目标识别
case NetSDKLib.EM_ANALYSE_EVENT_TYPE.EM_ANALYSE_EVENT_FACE_RECOGNITION: {
/*NetSDKLib.DEV_EVENT_FACERECOGNITION_INFO stInfo = new NetSDKLib.DEV_EVENT_FACERECOGNITION_INFO();
ToolKits.GetPointerDataToStruct(info.pstEventInfo, 0, stInfo);
System.out.println("objectType: " + new String(stInfo.stuObject.szObjectType, Charset.forName(Utils.getPlatformEncode())));
System.out.println("人脸匹配到的候选对象数量:" + stInfo.nCandidateNum + ",人员信息,相似度:" + stInfo.stuCandidates[0].bySimilarity);*/
//msg读字节
msg.getPointer().write(0,info.pstEventInfo.getByteArray(0,msg.size()),0,msg.size());
//读取nCandidateNum属性
int nCandidateNum=(int)msg.readField("nCandidateNum");
//获取stuCandidates结构体偏移量
int offset=msg.fieldOffset("stuCandidates");
//获取CANDIDATE_INFO结构体大小
int size=msg.stuCandidates[0].size();
for (int m = 0; m < nCandidateNum; m++) {
//按照偏移量写入stuCandidates数组
msg.stuCandidates[m].getPointer().write(0,info.pstEventInfo.getByteArray(offset+size*m, size),0,size);
//读取相似度
byte similarity=(byte)msg.stuCandidates[m].readField("bySimilarity");
//读取stPersonInfo结构体对象
msg.stuCandidates[m].readField("stPersonInfo");
msg.stuCandidates[m].stPersonInfo.read();
//人员唯一标示(身份证号码,工号,或其他编号)
String personId=new String(msg.stuCandidates[m].stPersonInfo.szID,Charset.forName(Utils.getPlatformEncode())).trim();
//人员唯一标识符,首次由服务端生成,区别于ID字段
String personUId=new String(msg.stuCandidates[m].stPersonInfo.szUID,Charset.forName(Utils.getPlatformEncode())).trim();
//
System.out.println("id:"+personId+",uid: "+personUId+",similarity: "+similarity);
}
msg.readField("stuObject");
//保存图片
//下发的图片
String picture = picturePath + "/my-" + System.currentTimeMillis() + ".jpg";
ToolKits.savePicture(pBuf, 0, msg.stuObject.stPicInfo.dwFileLenth, picture);
//匹配的图片
picture = picturePath + "/search-" + System.currentTimeMillis() + ".jpg";
ToolKits.savePicture(pBuf, msg.stuObject.stPicInfo.dwFileLenth, dwBufSize, picture);
break;
}
default: {
System.out.println("default");
break;
}
}
}
System.out.println(new String(task.stuTaskResultInfos[i].szFileID, Charset.forName(Utils.getPlatformEncode())).trim());
}
long end=System.currentTimeMillis();
System.out.println("cost millions: "+(end-start));
return 0;
}
}

@ -0,0 +1,32 @@
package com.netsdk.lib.callback.impl;
import com.netsdk.lib.NetSDKLib;
import com.sun.jna.Pointer;
/**
* @author 47081
* @version 1.0
* @description 线, 使
* @date 2020/6/5
*/
public class DefaultDisconnectCallback implements NetSDKLib.fDisConnect {
private static volatile DefaultDisconnectCallback INSTANCE;
private DefaultDisconnectCallback() {}
public static DefaultDisconnectCallback getINSTANCE() {
if (INSTANCE == null) {
synchronized (DefaultDisconnectCallback.class){
if (INSTANCE == null){
INSTANCE = new DefaultDisconnectCallback();
}
}
}
return INSTANCE;
}
@Override
public void invoke(NetSDKLib.LLong lLoginID, String pchDVRIP, int nDVRPort, Pointer dwUser) {
System.out.printf("Device[%s] Port[%d] DisConnected!\n", pchDVRIP, nDVRPort);
}
}

@ -0,0 +1,30 @@
package com.netsdk.lib.callback.impl;
import com.netsdk.lib.NetSDKLib;
import com.sun.jna.Pointer;
/**
* @author 47081
* @version 1.0
* @description 线, 使
* @date 2020/6/5
*/
public class DefaultHaveReconnectCallBack implements NetSDKLib.fHaveReConnect {
private static DefaultHaveReconnectCallBack INSTANCE;
private DefaultHaveReconnectCallBack() {
}
public static DefaultHaveReconnectCallBack getINSTANCE() {
if (INSTANCE == null) {
INSTANCE = new DefaultHaveReconnectCallBack();
}
return INSTANCE;
}
@Override
public void invoke(NetSDKLib.LLong lLoginID, String pchDVRIP, int nDVRPort, Pointer dwUser) {
System.out.printf("Device[%s] Port[%d] ReConnected!\n", pchDVRIP, nDVRPort);
}
}

@ -0,0 +1,49 @@
package com.netsdk.lib.callback.impl;
import com.netsdk.lib.NetSDKLib;
import com.netsdk.lib.enumeration.EM_REAL_DATA_TYPE;
import com.sun.jna.Pointer;
/**
* @author 47081
* @version 1.0
* @description
* @date 2021/3/2
*/
public class DefaultRealPlayCallback implements NetSDKLib.fRealDataCallBackEx2 {
private static DefaultRealPlayCallback instance;
private DefaultRealPlayCallback() {}
public static DefaultRealPlayCallback getInstance() {
if (instance == null) {
instance = new DefaultRealPlayCallback();
}
return instance;
}
@Override
public void invoke(
NetSDKLib.LLong lRealHandle,
int dwDataType,
Pointer pBuffer,
int dwBufSize,
NetSDKLib.LLong param,
Pointer dwUser) {
// 私有流或mp4文件
if (dwDataType == 0 || dwDataType == 1003) {
} else {
int dataType = dwDataType - 1000;
// h264流
if (dataType == 4) {
} else if (dataType == 5) {
// flv流
}
}
if(dwDataType!=0){
System.out.println("realHandler: "+lRealHandle.longValue()+",dwDataType: "+dwDataType+",bufSize: "+dwBufSize);
}
}
}

@ -0,0 +1,113 @@
package com.netsdk.lib.callback.impl;
import com.netsdk.lib.Utils;
import com.netsdk.lib.callback.fRedirectServerCallBackEx;
import com.netsdk.lib.structure.NET_CB_REDIRECT_SERVER_CALLBACK_INFO;
import com.netsdk.module.AutoRegisterModule;
import com.sun.jna.Pointer;
import java.nio.charset.Charset;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* @author 47081
* @version 1.0
* @description 使
* @date 2021/3/13
*/
public class DefaultRedirectServerCallBackEx implements fRedirectServerCallBackEx {
private static volatile DefaultRedirectServerCallBackEx instance;
private AutoRegisterModule autoRegisterModule;
private DefaultRedirectServerCallBackEx() {
this.autoRegisterModule = new AutoRegisterModule();
}
public static DefaultRedirectServerCallBackEx getInstance() {
if (instance == null) {
synchronized (DefaultRedirectServerCallBackEx.class) {
if (instance == null) {
instance = new DefaultRedirectServerCallBackEx();
}
}
}
return instance;
}
private Map<String, RedirectInfo> redirectIps = new ConcurrentHashMap<>();
/**
* IDIP
*
* @param deviceID
* @param redirectIp
* @param redirectPort
*/
public void putRedirectInfo(String deviceID, String redirectIp, short redirectPort) {
redirectIps.put(deviceID, new RedirectInfo(redirectIp, redirectPort));
}
public void putDefaultRedirectInfo(String redirectIp, short redirectPort) {
redirectIps.put("default", new RedirectInfo(redirectIp, redirectPort));
}
public void removeRedirectInfo(String deviceID) {
redirectIps.remove(deviceID);
}
@Override
public void dealWithData(
long devHandler, NET_CB_REDIRECT_SERVER_CALLBACK_INFO info, Pointer userData) {
System.out.println(
"receive device[ id: "
+ new String(info.szDeviceID, Charset.forName(Utils.getPlatformEncode())).trim()
+ ",ip: "
+ info.szIP
+ ",port: "
+ info.nPort
+ "]");
RedirectInfo redirectInfo =
redirectIps.get(
new String(info.szDeviceID, Charset.forName(Utils.getPlatformEncode())).trim());
if (redirectInfo == null) {
redirectInfo = redirectIps.get("default");
}
if (redirectInfo != null) {
RedirectInfo finalRedirectInfo = redirectInfo;
new Thread(() -> setRedirect(devHandler, finalRedirectInfo, (short) 3)).start();
}
}
private void setRedirect(long devHandler, RedirectInfo info, short ntry) {
autoRegisterModule.setRedirectServer(devHandler, info.redirectIp, info.redirectPort, ntry);
}
private class RedirectInfo {
private String redirectIp;
private short redirectPort;
public RedirectInfo() {}
public RedirectInfo(String redirectIp, short redirectPort) {
this.redirectIp = redirectIp;
this.redirectPort = redirectPort;
}
public String getRedirectIp() {
return redirectIp;
}
public void setRedirectIp(String redirectIp) {
this.redirectIp = redirectIp;
}
public int getRedirectPort() {
return redirectPort;
}
public void setRedirectPort(short redirectPort) {
this.redirectPort = redirectPort;
}
}
}

@ -0,0 +1,45 @@
package com.netsdk.lib.callback.impl;
import com.netsdk.lib.NetSDKLib;
import com.netsdk.module.BaseModule;
import com.sun.jna.Pointer;
/**
* @author 47081
* @version 1.0
* @description ,使
* @date 2021/3/13
*/
public class DefaultServiceCallBack implements NetSDKLib.fServiceCallBack {
private static volatile DefaultServiceCallBack instance;
private DefaultServiceCallBack() {
this.baseModule = new BaseModule();
}
public static DefaultServiceCallBack getInstance() {
if (instance == null) {
synchronized (DefaultServiceCallBack.class) {
if (instance == null) {
instance = new DefaultServiceCallBack();
}
}
}
return instance;
}
private BaseModule baseModule;
@Override
public int invoke(
NetSDKLib.LLong lHandle,
String pIp,
int wPort,
int lCommand,
Pointer pParam,
int dwParamLen,
Pointer dwUserData) {
System.out.println("receive device[ip: " + pIp + ",port: " + wPort + "] auto register.");
return 0;
}
}

@ -0,0 +1,166 @@
package com.netsdk.lib.callback.impl;
import com.netsdk.lib.NetSDKLib;
import com.netsdk.lib.callback.BasicVideoStatHeatMapCallBack;
import com.netsdk.lib.callback.fVideoStatHeatMapCallBack;
import com.netsdk.lib.enumeration.EM_HEATMAP_TYPE;
import com.netsdk.module.HeatMapModule;
import com.netsdk.module.entity.HeatMapData;
import com.netsdk.module.entity.HeatMapGrayData;
import com.sun.jna.Pointer;
import java.util.concurrent.ConcurrentHashMap;
/**
* @author 47081
* @version 1.0
* @description , , sdk
* @date 2020/9/24
*/
public class DefaultVideoStatHeatMapCallBack extends BasicVideoStatHeatMapCallBack {
private HeatMapModule module;
/** 由于热度图数据是分多次发送,需要判断数据接收完整再处理 */
private ConcurrentHashMap<Integer, HeatMapData> binDatas;
/** 用于外部获取灰度图数据 */
public static ConcurrentHashMap<Integer, HeatMapGrayData> grayDatas =
new ConcurrentHashMap<Integer, HeatMapGrayData>();
private static DefaultVideoStatHeatMapCallBack instance;
private DefaultVideoStatHeatMapCallBack() {
this.module = new HeatMapModule();
this.binDatas = new ConcurrentHashMap<Integer, HeatMapData>();
}
public static fVideoStatHeatMapCallBack getInstance() {
if (instance == null) {
instance = new DefaultVideoStatHeatMapCallBack();
}
return instance;
}
/**
*
*
* @param attachHandle
* @param nToken ,{@link
* com.netsdk.lib.NetSDKLib#CLIENT_GetVideoStatHeatMap(NetSDKLib.LLong, Pointer, Pointer,
* int)} nToken{@link com.netsdk.lib.structure.NET_OUT_GET_VIDEOSTAT_HEATMAP#nToken}
* @param type
* @param binData
*/
@Override
public void parseData(long attachHandle, int nToken, EM_HEATMAP_TYPE type, byte[] binData) {
System.out.println(
"receive heatmap data. attachHandle:"
+ attachHandle
+ ",nToken:"
+ nToken
+ ",type:"
+ type.getType()
+ ","
+ type.getDesc()
+ " data length:"
+ binData.length);
// 协议描述:每个getHeatMap请求的结果分多个包来发送每个包的大小在 “4~7此次数据总长度”中描述每个包的 “8~11
// 总行数总轨迹条数”相同每个包的“12~15本次行数本次轨迹条数”表示本包的数据数量最后一个包的“12~15本次行数本次轨迹条数”值为0表示数据发送完毕。
// 当总行数或者总轨迹条数和本次行数或者本次轨迹条数都为0时表示没有数据。
// 当总行数或者总轨迹条数不为0而本次行数或者本次轨迹条数为0时表示数据已经传完
// 对binData进行过滤
byte[] temp = new byte[4];
System.arraycopy(binData, 7, temp, 0, 4);
// 总行数
int totalLine = byte2Int(temp);
System.arraycopy(binData, 11, temp, 0, 4);
// 本次行数
int currentLine = byte2Int(temp);
if (totalLine == 0 && currentLine == 0) {
System.out.println("token:" + nToken + ",本次没有数据");
return;
}
// 总行数和本次行数都不为0时,说明数据有效
if (totalLine != 0 && currentLine != 0) {
HeatMapData heatMapData = binDatas.get(nToken);
// 获取宽高,宽16-17位,高18-19位
int width = ((binData[16] & 0xFF)) | ((binData[17] & 0xFF) << 8);
int height = ((binData[18] & 0xFF)) | ((binData[19] & 0xFF) << 8);
if (heatMapData == null) {
heatMapData = new HeatMapData(width, height, binData);
} else {
/** 目前设备端处理是一个完整数据包和一个结束包,以下代码基本不会被执行到, 先按协议进行多包数据拼接处理 */
// 获取已保存数据的数据行数
System.arraycopy(heatMapData.getData(), 11, temp, 0, 4);
int savedLine = byte2Int(temp);
// 合并后的本次行数
int currentTotal = savedLine + currentLine;
byte[] bytes = int2ByteArr(currentTotal);
System.arraycopy(bytes, 0, heatMapData.getData(), 11, bytes.length);
// 去掉数据头,数据头为32位
byte[] data = new byte[binData.length - 32];
System.arraycopy(binData, 32, data, 0, data.length);
// 追加到完整数据包中
heatMapData.addData(data);
}
// 将数据存到map中
binDatas.put(nToken, heatMapData);
}
// 数据接收完成
if (totalLine != 0 && currentLine == 0) {
// 将数据取出
HeatMapData heatMapData = binDatas.get(nToken);
if (heatMapData != null) {
System.out.println(
"width:"
+ heatMapData.getWidth()
+ ",height:"
+ heatMapData.getHeight()
+ ",data length:"
+ heatMapData.getData().length);
// 热度图数据转灰度图
byte[] grayData =
module.transferGray(
heatMapData.getData(), heatMapData.getWidth(), heatMapData.getHeight());
// 销毁binData数据
binDatas.remove(nToken);
// 保存灰度图数据
grayDatas.put(
nToken, new HeatMapGrayData(heatMapData.getWidth(), heatMapData.getHeight(), grayData));
}
}
}
/**
* byte[4]int
*
* @param src
* @return
*/
private int byte2Int(byte[] src) {
int value;
value =
(int)
((src[0] & 0xFF)
| ((src[1] & 0xFF) << 8)
| ((src[2] & 0xFF) << 16)
| ((src[3] & 0xFF) << 24));
return value;
}
/**
* intbyte[],4
*
* @param value
* @return
*/
private byte[] int2ByteArr(int value) {
byte[] bytes = new byte[4];
bytes[3] = (byte) (value >> 24);
bytes[2] = (byte) (value >> 16);
bytes[1] = (byte) (value >> 8);
bytes[0] = (byte) (value);
return bytes;
}
}

@ -0,0 +1,444 @@
package com.netsdk.lib.callback.impl;
import com.netsdk.lib.NetSDKLib;
import com.netsdk.lib.NetSDKLib.*;
import com.netsdk.lib.ToolKits;
import com.netsdk.lib.constant.SDK_ALARM_Ex_TYPE;
import com.netsdk.lib.enumeration.*;
import com.netsdk.lib.structure.ALARM_HEATIMG_TEMPER_INFO;
import com.netsdk.lib.structure.ALARM_NO_DISK_INFO;
import com.netsdk.lib.structure.ALARM_SOLARCELL_SYSTEM_INFO;
import com.netsdk.lib.structure.ALARM_TRAFFIC_LIGHT_STATE_INFO;
import com.sun.jna.NativeLong;
import com.sun.jna.Pointer;
import java.io.UnsupportedEncodingException;
import static com.netsdk.lib.Utils.getOsPrefix;
public class MessCallBack implements NetSDKLib.fMessCallBack {
private MessCallBack() {
}
private static class CallBackHolder {
private static final MessCallBack cb = new MessCallBack();
}
public static final MessCallBack getInstance() {
return CallBackHolder.cb;
}
public static String encode;
static {
String osPrefix = getOsPrefix();
if (osPrefix.toLowerCase().startsWith("win32-amd64")) {
encode = "GBK";
} else if (osPrefix.toLowerCase().startsWith("linux-amd64")) {
encode = "UTF-8";
}
}
@Override
public boolean invoke(int lCommand, LLong lLoginID, Pointer pStuEvent,
int dwBufLen, String strDeviceIP, NativeLong nDevicePort,
Pointer dwUser) {
switch (lCommand) {
/************************************************************
* *
*************************************************************/
case NetSDKLib.NET_ALARM_ACCESS_CTL_EVENT: // 门禁事件
{
ALARM_ACCESS_CTL_EVENT_INFO msg = new ALARM_ACCESS_CTL_EVENT_INFO();
ToolKits.GetPointerData(pStuEvent, msg);
try {
System.out.println("【门禁事件】 " + new String(msg.szQRCode, "GBK"));
} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
break;
}
case NetSDKLib.NET_ALARM_ACCESS_CTL_NOT_CLOSE: // 门禁未关事件详细信息
{
ALARM_ACCESS_CTL_NOT_CLOSE_INFO msg = new ALARM_ACCESS_CTL_NOT_CLOSE_INFO();
ToolKits.GetPointerData(pStuEvent, msg);
try {
System.out.printf("【门禁未关事件详细信息】 时间:%s 门通道号:%d 门禁名称:%s 事件动作(0:开始 1:停止):%d \n",
msg.stuTime, msg.nDoor, new String(msg.szDoorName, "GBK").trim(), msg.nAction);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
break;
}
case NetSDKLib.NET_ALARM_ACCESS_CTL_BREAK_IN: // 闯入事件详细信息
{
ALARM_ACCESS_CTL_BREAK_IN_INFO msg = new ALARM_ACCESS_CTL_BREAK_IN_INFO();
ToolKits.GetPointerData(pStuEvent, msg);
try {
System.out.printf("【闯入事件详细信息】 时间:%s 门通道号:%d 门禁名称:%s \n",
msg.stuTime, msg.nDoor, new String(msg.szDoorName, "GBK").trim());
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
break;
}
case NetSDKLib.NET_ALARM_ACCESS_CTL_REPEAT_ENTER: // 反复进入事件详细信息
{
ALARM_ACCESS_CTL_REPEAT_ENTER_INFO msg = new ALARM_ACCESS_CTL_REPEAT_ENTER_INFO();
ToolKits.GetPointerData(pStuEvent, msg);
try {
System.out.printf("【反复进入事件详细信息】 时间:%s 门通道号:%d 门禁名称:%s 卡号:%s\n",
msg.stuTime, msg.nDoor, new String(msg.szDoorName, "GBK").trim(), new String(msg.szCardNo).trim());
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
break;
}
case NetSDKLib.NET_ALARM_ACCESS_CTL_DURESS: // 胁迫卡刷卡事件详细信息
{
ALARM_ACCESS_CTL_DURESS_INFO msg = new ALARM_ACCESS_CTL_DURESS_INFO();
ToolKits.GetPointerData(pStuEvent, msg);
try {
System.out.printf("【胁迫卡刷卡事件详细信息】 时间:%s 门通道号:%d 门禁名称:%s 胁迫卡号:%s\n",
msg.stuTime, msg.nDoor, new String(msg.szDoorName, "GBK").trim(), new String(msg.szCardNo).trim());
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
break;
}
case NetSDKLib.NET_ALARM_OPENDOORGROUP: // 多人组合开门事件
{
ALARM_OPEN_DOOR_GROUP_INFO msg = new ALARM_OPEN_DOOR_GROUP_INFO();
ToolKits.GetPointerData(pStuEvent, msg);
System.out.printf("【多人组合开门事件】 时间:%s 门通道号:%d\n", msg.stuTime, msg.nChannelID);
break;
}
case NetSDKLib.NET_ALARM_ACCESS_CTL_STATUS: // 门禁状态事件
{
ALARM_ACCESS_CTL_STATUS_INFO msg = new ALARM_ACCESS_CTL_STATUS_INFO();
ToolKits.GetPointerData(pStuEvent, msg);
System.out.printf("【门禁状态事件】 时间:%s 门通道号:%d 门禁状态:%d\n", msg.stuTime, msg.nDoor, msg.emStatus);
break;
}
case NetSDKLib.NET_ALARM_FINGER_PRINT: // 获取指纹事件
{
ALARM_CAPTURE_FINGER_PRINT_INFO msg = new ALARM_CAPTURE_FINGER_PRINT_INFO();
ToolKits.GetPointerData(pStuEvent, msg);
System.out.printf("【获取指纹事件】 时间:%s 门通道号:%d 采集结果:%d\n", msg.stuTime, msg.nChannelID, msg.bCollectResult);
break;
}
case NetSDKLib.NET_ALARM_QR_CODE_CHECK: // 二维码上报事件
{
ALARM_QR_CODE_CHECK_INFO msg = new ALARM_QR_CODE_CHECK_INFO();
ToolKits.GetPointerData(pStuEvent, msg);
try {
System.out.printf("【二维码上报事件】 UTC:%s 二维码字符串:%s ",
msg.UTC, new String(msg.szQRCode, "GBK").trim());
} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
break;
}
/****************************************************************
* *
*****************************************************************/
case NetSDKLib.NET_ALARM_POWERFAULT: // 电源故障事件
{
ALARM_POWERFAULT_INFO msg = new ALARM_POWERFAULT_INFO();
ToolKits.GetPointerData(pStuEvent, msg);
System.out.printf("【电源故障事件】 时间:%s 电源类型:%d 电源故障事件:%d 事件动作(0:开始 1:停止):%d\n",
msg.stuTime, msg.emPowerType, msg.emPowerFaultEvent, msg.nAction);
break;
}
case NetSDKLib.NET_ALARM_BATTERYLOWPOWER: // 蓄电池低电压事件
{
ALARM_BATTERYLOWPOWER_INFO msg = new ALARM_BATTERYLOWPOWER_INFO();
ToolKits.GetPointerData(pStuEvent, msg);
System.out.printf("【蓄电池低电压事件】 时间:%s 通道号:%d 剩余电量百分比:%d 事件动作(0:开始 1:停止):%d\n",
msg.stTime, msg.nChannelID, msg.nBatteryLeft, msg.nAction);
break;
}
case NetSDKLib.NET_ALARM_ARMMODE_CHANGE_EVENT: // 设备布防模式变化事件
{
ALARM_ARMMODE_CHANGE_INFO msg = new ALARM_ARMMODE_CHANGE_INFO();
ToolKits.GetPointerData(pStuEvent, msg);
System.out.printf("【设备布防模式变化事件】 时间:%s 变化后的状态:%d ID号:%d 用户ID:%d\n",
msg.stuTime, msg.bArm, msg.dwID, msg.nUserCode);
break;
}
case NetSDKLib.NET_ALARM_BYPASSMODE_CHANGE_EVENT: // 防区旁路状态变化事件
{
ALARM_BYPASSMODE_CHANGE_INFO msg = new ALARM_BYPASSMODE_CHANGE_INFO();
ToolKits.GetPointerData(pStuEvent, msg);
System.out.printf("【防区旁路状态变化事件】 时间:%s 通道号:%d 变化后的模式:%d ID号:%d \n",
msg.stuTime, msg.nChannelID, msg.dwID, msg.emMode);
break;
}
case NetSDKLib.NET_ALARM_INPUT_SOURCE_SIGNAL: // 报警输入源信号事件
{
ALARM_INPUT_SOURCE_SIGNAL_INFO msg = new ALARM_INPUT_SOURCE_SIGNAL_INFO();
ToolKits.GetPointerData(pStuEvent, msg);
System.out.printf("【报警输入源信号事件】 时间:%s 通道号:%d 事件动作(0:开始 1:停止):%d \n",
msg.stuTime, msg.nChannelID, msg.nAction);
break;
}
case NetSDKLib.NET_ALARM_ALARMCLEAR: // 消警事件
{
ALARM_ALARMCLEAR_INFO msg = new ALARM_ALARMCLEAR_INFO();
ToolKits.GetPointerData(pStuEvent, msg);
System.out.printf("【消警事件】 时间:%s 通道号:%d 事件动作(0表示脉冲事件,1表示持续性事件开始,2表示持续性事件结束):%d \n",
msg.stuTime, msg.nChannelID, msg.bEventAction);
break;
}
case NetSDKLib.NET_ALARM_SUBSYSTEM_STATE_CHANGE: // 子系统状态改变事件
{
ALARM_SUBSYSTEM_STATE_CHANGE_INFO msg = new ALARM_SUBSYSTEM_STATE_CHANGE_INFO();
ToolKits.GetPointerData(pStuEvent, msg);
System.out.printf("【子系统状态改变事件】 时间:%s 子系统序号:%d 变化后的状态:%d \n", msg.stuTime, msg.nChannelID, msg.emState);
break;
}
case NetSDKLib.NET_ALARM_MODULE_LOST: // 扩展模块掉线事件
{
ALARM_MODULE_LOST_INFO msg = new ALARM_MODULE_LOST_INFO();
ToolKits.GetPointerData(pStuEvent, msg);
System.out.printf("【扩展模块掉线事件】 时间:%s 扩展模块接的总线的序号:%d 掉线的扩展模块数目:%d 设备类型:%s 在线情况(0-不在线,1-在线):%d \n",
msg.stuTime, msg.nSequence, msg.nAddr, new String(msg.szDevType).trim(), msg.bOnline);
break;
}
case NetSDKLib.NET_ALARM_PSTN_BREAK_LINE: // PSTN掉线事件
{
ALARM_PSTN_BREAK_LINE_INFO msg = new ALARM_PSTN_BREAK_LINE_INFO();
ToolKits.GetPointerData(pStuEvent, msg);
System.out.printf("【PSTN掉线事件】 时间:%s 电话线序号:%d 事件动作(0:开始 1:停止):%d \n",
msg.stuTime, msg.nChannelID, msg.nAction);
break;
}
case NetSDKLib.NET_ALARM_DEFENCE_ARMMODE_CHANGE: // 防区布撤防状态改变事件
{
ALARM_DEFENCE_ARMMODECHANGE_INFO msg = new ALARM_DEFENCE_ARMMODECHANGE_INFO();
ToolKits.GetPointerData(pStuEvent, msg);
System.out.printf("【防区布撤防状态改变事件】 时间:%s 布撤防状态:%d 防区号:%d \n",
msg.stuTime, msg.emDefenceStatus, msg.nDefenceID);
break;
}
case NetSDKLib.NET_ALARM_SUBSYSTEM_ARMMODE_CHANGE: // 子系统布撤防状态改变事件
{
ALARM_SUBSYSTEM_ARMMODECHANGE_INFO msg = new ALARM_SUBSYSTEM_ARMMODECHANGE_INFO();
ToolKits.GetPointerData(pStuEvent, msg);
System.out.printf("【子系统布撤防状态改变事件】 UTC:%s 布撤防状态:%d 子系统编号:%d \n",
msg.UTC, msg.emSubsystemMode, msg.nSubSystemID);
break;
}
case NetSDKLib.NET_ALARM_SENSOR_ABNORMAL: // 探测器异常报警
{
ALARM_SENSOR_ABNORMAL_INFO msg = new ALARM_SENSOR_ABNORMAL_INFO();
ToolKits.GetPointerData(pStuEvent, msg);
System.out.printf("【探测器异常报警】 时间:%s 通道号:%d 探测器状态:%d 事件动作(0:开始 1:停止):%d \n",
msg.stuTime, msg.nChannelID, msg.emStatus, msg.nAction);
break;
}
/************************************************************
* *
*************************************************************/
case NetSDKLib.NET_ALARM_ALARM_EX2: // 本地报警事件
{
ALARM_ALARM_INFO_EX2 msg = new ALARM_ALARM_INFO_EX2();
ToolKits.GetPointerData(pStuEvent, msg);
System.out.printf("【本地报警事件】 时间:%s 通道号:%d 事件动作(0:开始 1:停止):%d \n",
msg.stuTime, msg.nChannelID, msg.nAction);
break;
}
case NetSDKLib.NET_ALARM_CHASSISINTRUDED: // 防拆事件
{
ALARM_CHASSISINTRUDED_INFO msg = new ALARM_CHASSISINTRUDED_INFO();
ToolKits.GetPointerData(pStuEvent, msg);
System.out.printf("【防拆事件】 时间:%s 通道号:%d 事件动作(0:开始 1:停止):%d \n",
msg.stuTime, msg.nChannelID, msg.nAction);
break;
}
case NetSDKLib.NET_ALARM_RCEMERGENCY_CALL: // 紧急呼叫报警事件
{
ALARM_RCEMERGENCY_CALL_INFO msg = new ALARM_RCEMERGENCY_CALL_INFO();
ToolKits.GetPointerData(pStuEvent, msg);
System.out.printf("【紧急呼叫报警事件】 时间:%s 紧急类型:%d 报警方式:%d 事件动作(-1:未知 0:开始 1:停止):%d \n",
msg.stuTime, msg.emType, msg.emMode, msg.nAction);
break;
}
case NetSDKLib.NET_ALARM_CROWD_DETECTION: // 人群密度检测事件
{
ALARM_CROWD_DETECTION_INFO msg = new ALARM_CROWD_DETECTION_INFO();
ToolKits.GetPointerData(pStuEvent, msg);
System.out.printf("【人群密度检测事件】 UTC:%s 通道号:%d 事件动作(0表示脉冲事件,1表示持续性事件开始,2表示持续性事件结束):%d ",
msg.UTC, msg.nChannelID, msg.nEventAction);
break;
}
/************************************************************
* *
*************************************************************/
case NetSDKLib.NET_ALARM_TRAFFIC_XINKONG: // 交通态势报警事件
{
ALARM_TRAFFIC_XINKONG_INFO msg = new ALARM_TRAFFIC_XINKONG_INFO();
ToolKits.GetPointerData(pStuEvent, msg);
System.out.printf("【交通态势报警事件】 UTC:%s 通道号:%d 物理车道号:%d 车牌号:%s carID:%d carType:%d \n",
msg.UTC, msg.nChannelID, msg.stuLaneInfo[0].nLane
, new String(msg.stuLaneInfo[0].stuCoilsInfo[0].PlateNum).trim()
, msg.stuLaneInfo[0].stuCoilsInfo[0].nCarId
, msg.stuLaneInfo[0].stuCoilsInfo[0].emCarType);
break;
}
/************************************************************
* 绿 *
************************************************************/
case NetSDKLib.NET_ALARM_TRAFFIC_LIGHT_STATE: // 电警红绿灯状态事件
{
System.out.println("\n\n<Event> TRAFFIC [ ALARM TRAFFIC LIGHT STATE ]");
ALARM_TRAFFIC_LIGHT_STATE_INFO msg = new ALARM_TRAFFIC_LIGHT_STATE_INFO();
ToolKits.GetPointerData(pStuEvent, msg);
StringBuilder builder = new StringBuilder();
try {
builder.append("<<------门禁报警事件主要信息------>>").append("\n")
.append("nChannel 通道: ").append(msg.nChannelID).append("\n")
.append("nAction 事件状态(0:脉冲 1:开始 2:停止): ").append(msg.nAction).append("\n")
.append("szName 事件名称: ").append(new String(msg.szName, encode)).append("\n")
.append("PTS 时间戳: ").append(msg.PTS).append("\n")
.append("UTC 发生时间: ").append(msg.UTC).append("\n")
.append("nEventID 事件ID: ").append(msg.nEventID).append("\n")
.append("nSource 源地址: ").append(msg.nSource).append("\n")
.append("nFrameSequence 帧序号: ").append(msg.nFrameSequence).append("\n")
.append("emLightSource 红绿灯触发源: ").append(EM_TRFAFFIC_LIGHT_SOURCE.getNoteByValue(msg.emLightSource)).append("\n");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
builder.append("///->灯亮的持续时间组,共 ").append(msg.nLightPeriodsNum).append(" 组\n");
for (int i = 0; i < msg.nLightPeriodsNum; i++) {
builder.append("<<-----[").append(i).append("]----->>").append("\n")
.append("emType 交通灯类型: ").append(EM_TRFAFFIC_LIGHT_TYPE.getNoteByValue(msg.stuLightPeriods[i].emType)).append("\n")
.append("nStraight 直行灯持续时间: ").append(msg.stuLightPeriods[i].nStraight).append("\n")
.append("nTurnLeft 左转灯持续时间: ").append(msg.stuLightPeriods[i].nTurnLeft).append("\n")
.append("nTurnRight 右转灯持续时间: ").append(msg.stuLightPeriods[i].nTurnRight).append("\n")
.append("nUTurn 掉头灯持续时间: ").append(msg.stuLightPeriods[i].nUTurn).append("\n");
}
builder.append("///->交通灯状态组,共 ").append(msg.nLightStateNum).append(" 组\n");
for (int i = 0; i < msg.nLightStateNum; i++) {
builder.append("<<-----[").append(i).append("]----->>").append("\n")
.append("emStraightLightInfo 直行信号灯状态: ").append(NET_TRAFFIC_LIGHT_STATUS.getNoteByValue(msg.stuLightStates[i].emStraightLightInfo)).append("\n")
.append("emTurnLeftLightInfo 左转信号灯状态: ").append(NET_TRAFFIC_LIGHT_STATUS.getNoteByValue(msg.stuLightStates[i].emTurnLeftLightInfo)).append("\n")
.append("emTurnRightLightInfo 右转信号灯状态: ").append(NET_TRAFFIC_LIGHT_STATUS.getNoteByValue(msg.stuLightStates[i].emTurnRightLightInfo)).append("\n")
.append("emUTurnLightInfo 调头信号灯状态: ").append(NET_TRAFFIC_LIGHT_STATUS.getNoteByValue(msg.stuLightStates[i].emUTurnLightInfo)).append("\n");
}
System.out.println(builder.toString());
break;
}
/**
*
*/
case SDK_ALARM_Ex_TYPE.SDK_ALARM_SOLARCELL_SYSTEM_INFO: {
/**
*
*/
ALARM_SOLARCELL_SYSTEM_INFO info = new ALARM_SOLARCELL_SYSTEM_INFO();
ToolKits.GetPointerData(pStuEvent, info);
System.out.printf("太阳能电池信息: 脉冲:%d, 事件发生时间:%s,时间戳:%f", info.nAction, info.UTC.toStringTime(), info.PTS);
System.out.printf("蓄电池信息: 电量百分比:%d,电压:%f,温度:%f,控制温度:%f",
info.stuBatteryInfo.nElectricityQuantityPercent,
info.stuBatteryInfo.fVoltage,
info.stuBatteryInfo.fTemperature,
info.stuBatteryInfo.fControllerTemper);
System.out.printf("太阳能历史数据: 系统运行时间:%d,蓄电池总放电次数:%d,蓄电池总充满电次数:%d",
info.stuHistoryInfo.nSystemTotalRunDay,
info.stuHistoryInfo.nBatteryOverDischargeCount,
info.stuHistoryInfo.nBatteryTotalChargeCount);
System.out.printf("太阳能板信息: 电压:%f,电流:%f,充电功率:%f",
info.stuSolarPanel.fVoltage,
info.stuSolarPanel.fElectricCurrent,
info.stuSolarPanel.fChargingPower);
System.out.println("故障信息:");
for (int i = 0; i < info.nSystemFault; i++) {
System.out.println(EM_SOLARCELL_SYSTEM_FAULT_TYPE.getSolarcellFaultType(info.emSystemFault[i]).getInfo());
}
break;
}
/**
* ,110
*/
case SDK_ALARM_Ex_TYPE.SDK_DISKFULL_ALARM_EX: {
byte[] info = new byte[1];
pStuEvent.read(0, info, 0, info.length);
System.out.println(info[0] == 1 ? "硬盘满报警" : "无硬盘报警");
break;
}
/**
*
*/
case SDK_ALARM_Ex_TYPE.SDK_DISKERROR_ALARM_EX: {
byte[] info = new byte[32];
pStuEvent.read(0, info, 0, info.length);
for (int i = 0; i < info.length; i++) {
System.out.println("info[" + i + "]" + (info[i] == 1 ? "硬盘错误报警" : "无报警"));
}
break;
}
/**
*
*/
case SDK_ALARM_Ex_TYPE.SDK_ALARM_NO_DISK: {
ALARM_NO_DISK_INFO info=new ALARM_NO_DISK_INFO();
ToolKits.GetPointerData(pStuEvent,info);
System.out.println("time:"+info.stuTime.toString()+",action:"+(info.dwAction==0?"Start":(info.dwAction==1?"Stop":"UnKnown")));
break;
}
/************************************************************
* *
************************************************************/
case NetSDKLib.NET_ALARM_HEATIMG_TEMPER: // 热成像测温点报警
{
System.out.println("\n\n<Event> THERMAL [ ALARM HEATIMG TEMPER ]");
ALARM_HEATIMG_TEMPER_INFO msg = new ALARM_HEATIMG_TEMPER_INFO();
ToolKits.GetPointerData(pStuEvent, msg);
StringBuilder builder = new StringBuilder();
try {
builder.append("<<------门禁报警事件主要信息------>>").append("\n")
.append("szName 温度异常点名称: ").append(new String(msg.szName, encode)).append("\n")
.append("nAlarmId 报警项编号: ").append(msg.nAlarmId).append("\n")
.append("nResult 报警结果值: ").append(NET_RADIOMETRY_RESULT.getNoteByValue(msg.nResult)).append("\n")
.append("nAlarmContion 报警条件: ").append(NET_RADIOMETRY_ALARMCONTION.getNoteByValue(msg.nAlarmContion)).append("\n")
.append("fTemperatureValue 报警温度值: ").append(msg.fTemperatureValue).append("\n")
.append("nTemperatureUnit 温度单位: ").append(msg.nTemperatureUnit == 1 ? "摄氏度" : (msg.nTemperatureUnit == 2 ? "华氏度" : "未知")).append("\n")
.append("nPresetID 预置点: ").append(msg.nPresetID).append("\n")
.append("nChannel 通道号: ").append(msg.nChannel).append("\n")
.append("nAction 事件状态: ").append(msg.nAction == 0 ? "开始" : (msg.nAction == 1 ? "停止" : "无意义")).append("\n")
.append("stuAlarmCoordinates 报警坐标Ex: ").append("\n");
for (int i = 0; i < msg.stuAlarmCoordinates.nPointNum; i++) {
builder.append(String.format("[%2d] (%4d, %4d)", i, msg.stuAlarmCoordinates.stuPoints[i].nx, msg.stuAlarmCoordinates.stuPoints[i].ny)).append("\n");
}
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
System.out.println(builder.toString());
break;
}
default:
break;
}
return true;
}
}

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

@ -0,0 +1,26 @@
package com.netsdk.lib.callback.securityCheck;
import com.netsdk.lib.NetSDKLib;
import com.sun.jna.Callback;
import com.sun.jna.Pointer;
/**
* @author 291189
* @version 1.0
* @description
* @date 2021/6/29
*/
public interface fSecurityGateAttachAlarmStatistics extends Callback{
/**
* @param lAttachHandle
* @param pInfo {@link com.netsdk.lib.structure.NET_SECURITYGATE_ALARM_STATISTICS_INFO}
* @param dwUser
*/
void invoke(
NetSDKLib.LLong lAttachHandle,
Pointer pInfo,
Pointer dwUser);
// (LLONG lAttachHandle, NET_SECURITYGATE_ALARM_STATISTICS_INFO* pInfo, LDWORD dwUser);
}

@ -0,0 +1,23 @@
package com.netsdk.lib.callback.securityCheck;
import com.netsdk.lib.NetSDKLib;
import com.sun.jna.Callback;
import com.sun.jna.Pointer;
/**
* @author 291189
* @version 1.0
* @description
* @date 2021/7/1
*/
public interface fXRayAttachPackageStatistics extends Callback {
/**
* @param lAttachHandle
* @param pInfo {@link com.netsdk.lib.structure.NET_IN_XRAY_PACKAGE_STATISTICS_INFO}
* @param dwUser
*/
void invoke(
NetSDKLib.LLong lAttachHandle,
Pointer pInfo,
Pointer dwUser);
}

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

@ -0,0 +1,44 @@
package com.netsdk.lib.constant;
import com.netsdk.lib.structure.ALARM_SOLARCELL_SYSTEM_INFO;
import com.netsdk.lib.NetSDKLib;
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;
/**
* 110
* {@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;
/**
* 3210
* {@link NetSDKLib.fMessCallBack#invoke(int, NetSDKLib.LLong, Pointer, int, String, NativeLong, Pointer)}
* {@link NetSDKLib#CLIENT_StartListenEx(NetSDKLib.LLong)}
*/
public static final int SDK_DISKERROR_ALARM_EX = 0x2107;
/**
* ,{@link com.netsdk.lib.structure.ALARM_NO_DISK_INFO}
* {@link NetSDKLib.fMessCallBack#invoke(int, NetSDKLib.LLong, Pointer, int, String, NativeLong, Pointer)}
* {@link NetSDKLib#CLIENT_StartListenEx(NetSDKLib.LLong)}
*/
public static final int SDK_ALARM_NO_DISK = 0x2183;
}

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

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

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

@ -0,0 +1,47 @@
package com.netsdk.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;
}
}

@ -0,0 +1,92 @@
package com.netsdk.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;
}
}

@ -0,0 +1,52 @@
package com.netsdk.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;
}
}

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

@ -0,0 +1,58 @@
package com.netsdk.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_MASK(5, "口罩"),
// 表情
CFG_EM_FACE_TRAIT_EMOTION(6, "表情");
private int value;
private String note;
private CFG_EM_FACE_TRAIT(int givenValue, String note) {
this.value = givenValue;
this.note = note;
}
public String getNote() {
return note;
}
public int getValue() {
return value;
}
public static String getNoteByValue(int givenValue) {
for (CFG_EM_FACE_TRAIT enumType : CFG_EM_FACE_TRAIT.values()) {
if (givenValue == enumType.getValue()) {
return enumType.getNote();
}
}
return null;
}
public static int getValueByNote(String givenNote) {
for (CFG_EM_FACE_TRAIT enumType : CFG_EM_FACE_TRAIT.values()) {
if (givenNote.equals(enumType.getNote())) {
return enumType.getValue();
}
}
return -1;
}
}

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

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

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

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

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

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

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

@ -0,0 +1,50 @@
package com.netsdk.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;
}

@ -0,0 +1,296 @@
package com.netsdk.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 int type;
private String desc;
private EMDeviceType(int type, String desc) {
this.type = type;
this.desc = desc;
}
public int getType() {
return type;
}
public void setType(int type) {
this.type = type;
}
public String getDesc() {
return desc;
}
public void setDesc(String desc) {
this.desc = desc;
}
public static EMDeviceType getEMDeviceType(int type) {
for (EMDeviceType deviceType : EMDeviceType.values()) {
if (deviceType.getType() == type) {
return deviceType;
}
}
return null;
}
}

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

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

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

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

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

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

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

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

@ -0,0 +1,65 @@
package com.netsdk.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;
}
}

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

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

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

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

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

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

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

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

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

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

@ -0,0 +1,59 @@
package com.netsdk.lib.enumeration;
import com.netsdk.lib.NetSDKLib;
/**
*
*/
public enum EM_ALARM_TRANSMIT_DEV_SRC_TYPE
{
/**
*
*/
EM_ALARM_TRANSMIT_DEV_SRC_TYPE_UNKNOWN(0, "未知"),
/**
* Digit
*/
EM_ALARM_TRANSMIT_DEV_SRC_TYPE_DIGIT(1, "Digit 数字"),
/**
* Analog
*/
EM_ALARM_TRANSMIT_DEV_SRC_TYPE_ANALOG(2, "Analog 模拟"),
/**
* SmartLock
*/
EM_ALARM_TRANSMIT_DEV_SRC_TYPE_SMARTLOCK(3, "SmartLock 智能锁");
private int value;
private String note;
public String getNote() {
return note;
}
public int getValue() {
return value;
}
EM_ALARM_TRANSMIT_DEV_SRC_TYPE(int givenValue, String note) {
this.value = givenValue;
this.note = note;
}
public static String getNoteByValue(int givenValue) {
for (EM_ALARM_TRANSMIT_DEV_SRC_TYPE enumType : EM_ALARM_TRANSMIT_DEV_SRC_TYPE.values()) {
if (givenValue == enumType.getValue()) {
return enumType.getNote();
}
}
return null;
}
public static int getValueByNote(String givenNote) {
for (EM_ALARM_TRANSMIT_DEV_SRC_TYPE enumType : EM_ALARM_TRANSMIT_DEV_SRC_TYPE.values()) {
if (givenNote.equals(enumType.getNote())) {
return enumType.getValue();
}
}
return -1;
}
}

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

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

@ -0,0 +1,28 @@
package com.netsdk.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;
}
}

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

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

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

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

@ -0,0 +1,30 @@
package com.netsdk.lib.enumeration;
import com.netsdk.lib.NetSDKLib;
/**
*
*
* @author 260611
* @since Created in 2021/10/19 19:35
*/
public class EM_ANGLE_TYPE extends NetSDKLib.SdkStructure {
/**
*
*/
public static final int EM_ANGLE_UNKNOWN = 0;
/**
*
*/
public static final int EM_ANGLE_FRONT = 1;
/**
*
*/
public static final int EM_ANGLE_SIDE = 2;
/**
*
*/
public static final int EM_ANGLE_BACK = 3;
}

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

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

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

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

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

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

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

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

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

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

@ -0,0 +1,55 @@
package com.netsdk.lib.enumeration;
import com.netsdk.lib.NetSDKLib;
/**
*
*/
public enum EM_ASG_BATTERY_STATE
{
/**
*
*/
EM_ASG_BATTERY_STATE_UNKNOWN(0, "未知"),
/**
*
*/
EM_ASG_BATTERY_STATE_NOT_IN_PLACE(1, "不在位"),
/**
*
*/
EM_ASG_BATTERY_STATE_IN_PLACE(2, "在位");
private int value;
private String note;
public String getNote() {
return note;
}
public int getValue() {
return value;
}
EM_ASG_BATTERY_STATE(int givenValue, String note) {
this.value = givenValue;
this.note = note;
}
public static String getNoteByValue(int givenValue) {
for (EM_ASG_BATTERY_STATE enumType : EM_ASG_BATTERY_STATE.values()) {
if (givenValue == enumType.getValue()) {
return enumType.getNote();
}
}
return null;
}
public static int getValueByNote(String givenNote) {
for (EM_ASG_BATTERY_STATE enumType : EM_ASG_BATTERY_STATE.values()) {
if (givenNote.equals(enumType.getNote())) {
return enumType.getValue();
}
}
return -1;
}
}

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

@ -0,0 +1,46 @@
package com.netsdk.lib.enumeration;
import com.netsdk.lib.NetSDKLib;
/**
*
*
* @author 260611
* @since Created in 2021/10/19 19:35
*/
public class EM_ASSOCIATED_RECORD_SOURCE extends NetSDKLib.SdkStructure {
/**
*
*/
public static final int EM_ASSOCIATED_RECORD_SOURCE_UNKNOWN = -1;
/**
*
*/
public static final int EM_ASSOCIATED_RECORD_SOURCE_NONE = 0;
/**
*
*/
public static final int EM_ASSOCIATED_RECORD_SOURCE_HUMAN = 1;
/**
*
*/
public static final int EM_ASSOCIATED_RECORD_SOURCE_MOTOR_VEHICLE_PASSING = 2;
/**
*
*/
public static final int EM_ASSOCIATED_RECORD_SOURCE_MOTOR_VEHICLE_VIOLATION = 3;
/**
*
*/
public static final int EM_ASSOCIATED_RECORD_SOURCE_STRUCTURED_MOTOR_VEHICLE = 4;
/**
*
*/
public static final int EM_ASSOCIATED_RECORD_SOURCE_FACE = 5;
/**
*
*/
public static final int EM_ASSOCIATED_RECORD_SOURCE_NON_MOTOR_VEHICLE = 6;
}

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

@ -0,0 +1,52 @@
package com.netsdk.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;
}
}

@ -0,0 +1,30 @@
package com.netsdk.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;
}
}

@ -0,0 +1,50 @@
package com.netsdk.lib.enumeration;
import com.netsdk.lib.NetSDKLib;
/**
*
*/
public enum EM_AUDIO_MUTATION_ALARM_TYPE
{
AUDIO_MUTATION_UNKNOW(0, ""),
AUDIO_MUTATION_CRY(1, ""),
AUDIO_MUTATION_ALARM(2, ""),
AUDIO_MUTATION_GUNSHOT(3, ""),
AUDIO_MUTATION_EXPLOSION(4, ""),
AUDIO_MUTATION_SCREAM(5, ""),
AUDIO_MUTATION_CRASHINGGLASS(6, "");
private int value;
private String note;
public String getNote() {
return note;
}
public int getValue() {
return value;
}
EM_AUDIO_MUTATION_ALARM_TYPE(int givenValue, String note) {
this.value = givenValue;
this.note = note;
}
public static String getNoteByValue(int givenValue) {
for (EM_AUDIO_MUTATION_ALARM_TYPE enumType : EM_AUDIO_MUTATION_ALARM_TYPE.values()) {
if (givenValue == enumType.getValue()) {
return enumType.getNote();
}
}
return null;
}
public static int getValueByNote(String givenNote) {
for (EM_AUDIO_MUTATION_ALARM_TYPE enumType : EM_AUDIO_MUTATION_ALARM_TYPE.values()) {
if (givenNote.equals(enumType.getNote())) {
return enumType.getValue();
}
}
return -1;
}
}

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

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

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

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

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

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

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

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

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

Some files were not shown because too many files have changed in this diff Show More

Loading…
Cancel
Save