package com.netsdk.demo.customize;
|
|
import com.netsdk.demo.util.CaseMenu;
|
import com.netsdk.lib.NetFinalVar;
|
import com.netsdk.lib.NetSDKLib;
|
import com.netsdk.lib.NetSDKLib.*;
|
import com.netsdk.lib.ToolKits;
|
import com.netsdk.lib.enumeration.EM_STORAGE_DISK_PREDISKCHECK;
|
import com.netsdk.lib.enumeration.ENUMERROR;
|
import com.netsdk.lib.enumeration.NET_EM_CFG_OPERATE_TYPE;
|
import com.netsdk.lib.enumeration.NET_VOLUME_TYPE;
|
import com.netsdk.lib.structure.NET_CFG_FILE_HOLD_DAYS_INFO;
|
import com.netsdk.lib.structure.NET_IN_STORAGE_DEV_INFOS;
|
import com.netsdk.lib.structure.NET_OUT_STORAGE_DEV_INFOS;
|
import com.netsdk.lib.structure.NET_STORAGE_DEVICE;
|
import com.sun.jna.Memory;
|
import com.sun.jna.NativeLong;
|
import com.sun.jna.Pointer;
|
import com.sun.jna.ptr.IntByReference;
|
|
import java.io.File;
|
import java.text.ParseException;
|
import java.text.SimpleDateFormat;
|
import java.util.*;
|
|
public class DownloadRecord {
|
static NetSDKLib netsdkApi = NetSDKLib.NETSDK_INSTANCE;
|
static NetSDKLib configApi = NetSDKLib.CONFIG_INSTANCE;
|
|
// 设备信息
|
private NET_DEVICEINFO_Ex deviceinfo = new NET_DEVICEINFO_Ex();
|
|
// 登陆句柄
|
private LLong m_loginHandle = new LLong(0);
|
|
// 下载句柄
|
|
private LLong n_hDownLoadHandle = new LLong(0);
|
|
private TimeDownLoadDataCallBack m_DownLoadData = new TimeDownLoadDataCallBack(); // 录像下载数据回调
|
// 按时间下载数据回调
|
public class TimeDownLoadDataCallBack implements NetSDKLib.fDataCallBack {
|
public int invoke(LLong lRealHandle, int dwDataType, Pointer pBuffer, int dwBufSize, Pointer dwUser) {
|
// System.out.println("TimeDownLoadDataCallBack [ " + dwUser +" ]");
|
return 0;
|
}
|
}
|
|
class LockFileInfo {
|
public int nCluster; // 簇号
|
public int nDriveNo; // 磁盘号
|
|
public LockFileInfo(int nCluster, int nDriveNo) {
|
this.nCluster = nCluster;
|
this.nDriveNo = nDriveNo;
|
}
|
}
|
|
// 加锁文件列表
|
private List<LockFileInfo> lstLockFile = new ArrayList<LockFileInfo>();
|
|
// 报警监听标示
|
private boolean bListening = false;
|
|
/*************************************************************************************
|
* General function *
|
*************************************************************************************/
|
// device disconnect callback
|
// call CLIENT_Init to set it, when device reconnect, sdk will call it.
|
public static class DisConnectCallback implements NetSDKLib.fDisConnect{
|
|
private DisConnectCallback() {}
|
|
private static class CallBackHolder {
|
private static final DisConnectCallback cb = new DisConnectCallback();
|
}
|
|
public static final DisConnectCallback getInstance() {
|
return CallBackHolder.cb;
|
}
|
|
public void invoke(LLong lLoginID, String pchDVRIP, int nDVRPort, Pointer dwUser) {
|
System.out.printf("Device[%s] Port[%d] Disconnect!\n" , pchDVRIP , nDVRPort);
|
}
|
}
|
|
// device reconnect callback
|
// call CLIENT_SetAutoReconnect to set it, when device reconnect, sdk will call it.
|
public static class HaveReConnectCallback implements NetSDKLib.fHaveReConnect{
|
|
private HaveReConnectCallback() {}
|
|
private static class CallBackHolder {
|
private static final HaveReConnectCallback cb = new HaveReConnectCallback();
|
}
|
|
public static final HaveReConnectCallback getInstance() {
|
return CallBackHolder.cb;
|
}
|
|
public void invoke(LLong loginHandle, String pchDVRIP, int nDVRPort, Pointer dwUser) {
|
System.out.printf("ReConnect Device[%s] Port[%d]\n", pchDVRIP, nDVRPort);
|
}
|
}
|
|
/**
|
* Init Sdk and Login Device
|
*/
|
public void InitTest()
|
{
|
// init sdk
|
netsdkApi.CLIENT_Init(DisConnectCallback.getInstance(), null);
|
|
// Set re-connection callback function after disconnection. Internal SDK auto connect again after disconnection (Optional)
|
netsdkApi.CLIENT_SetAutoReconnect(HaveReConnectCallback.getInstance(), null);
|
|
// Set alarm listen callback
|
netsdkApi.CLIENT_SetDVRMessCallBack(MessCallback.getInstance(), null);
|
|
// Set device connection timeout value and trial times, Optional
|
int waitTime = 5000; // connection 5s timeout
|
int tryTimes = 3; // trial 3 times
|
netsdkApi.CLIENT_SetConnectTime(waitTime, tryTimes);
|
|
// Open SDK log, Optional
|
LOG_SET_PRINT_INFO setLog = new LOG_SET_PRINT_INFO();
|
|
File path = new File(".");
|
String logPath = path.getAbsoluteFile().getParent() + "\\sdk_log\\" + System.currentTimeMillis() + ".log";
|
|
setLog.bSetFilePath = 1;
|
System.arraycopy(logPath.getBytes(), 0, setLog.szLogFilePath, 0, logPath.getBytes().length);
|
|
setLog.bSetPrintStrategy = 1;
|
setLog.nPrintStrategy = 0;
|
boolean bLogopen = netsdkApi.CLIENT_LogOpen(setLog);
|
if (!bLogopen) {
|
System.err.println("Failed to open NetSDK log !!!");
|
}
|
|
// login device
|
int nSpecCap = 0;
|
Pointer pCapParam = null;
|
IntByReference nError = new IntByReference(0);
|
m_loginHandle = netsdkApi.CLIENT_LoginEx2(m_strIp, m_nPort, m_strUser ,
|
m_strPassword ,nSpecCap,pCapParam, deviceinfo,nError);
|
|
if(m_loginHandle.longValue() != 0) {
|
System.out.printf("Login Device[%s] Port[%d] Success!\n" , m_strIp , m_nPort);
|
}
|
else {
|
System.out.printf("Login Device[%s] Port[%d] Failed. %s\n" , m_strIp , m_nPort , ToolKits.getErrorCode());
|
EndTest();
|
}
|
}
|
|
/**
|
* Logout Device And Cleanup Sdk
|
*/
|
public void EndTest()
|
{
|
if( m_loginHandle.longValue() != 0)
|
{
|
netsdkApi.CLIENT_Logout(m_loginHandle);
|
}
|
|
netsdkApi.CLIENT_Cleanup();
|
System.exit(0);
|
}
|
|
/*************************************************************************************
|
* Download Record Function *
|
*************************************************************************************/
|
|
/**
|
* 设置回放时的码流类型
|
* @param m_streamType 码流类型
|
*/
|
public boolean setStreamType(int m_streamType) {
|
int emType = EM_USEDEV_MODE.NET_RECORD_STREAM_TYPE; // 回放录像枚举
|
IntByReference steamType = new IntByReference(m_streamType); // 0-主辅码流,1-主码流,2-辅码流
|
return netsdkApi.CLIENT_SetDeviceMode(m_loginHandle, emType, steamType.getPointer());
|
}
|
|
/**
|
* 下载录像
|
* @param nStreamType 码流类型
|
* @param nChannel 通道号
|
* @param stTimeStart 开始时间
|
* @param stTimeEnd 结束时间
|
* @param savedFileName 保存录像文件名
|
*/
|
public boolean downloadRecordFile(int nStreamType, int nChannel,
|
NET_TIME stTimeStart, NET_TIME stTimeEnd, String savedFileName) {
|
|
if (!setStreamType(nStreamType)) {
|
System.err.println("Set Stream Type Failed!." + ToolKits.getErrorCode());
|
return false;
|
}
|
|
int scType = 3; // scType: 码流转换类型,0-DAV码流(默认); 1-PS流,3-MP4
|
int nRecordFileType = EM_QUERY_RECORD_TYPE.EM_RECORD_TYPE_ALL; // 下载所有录像
|
|
/*m_hDownLoadHandle = netsdkApi.CLIENT_DownloadByTimeEx(m_loginHandle, nChannel, nRecordFileType,
|
stTimeStart, stTimeEnd, savedFileName,
|
DownloadPosCallback.getInstance(), null, null, null, null);*/
|
|
n_hDownLoadHandle = netsdkApi.CLIENT_DownloadByTimeEx2(m_loginHandle, nChannel, nRecordFileType,
|
stTimeStart, stTimeEnd, savedFileName,
|
DownloadPosCallback.getInstance(), null, m_DownLoadData, null, scType, null);
|
|
|
if(n_hDownLoadHandle.longValue() != 0) {
|
System.out.println("Downloading RecordFile...");
|
} else {
|
System.err.println("Download RecordFile Failed!" + ToolKits.getErrorCode() + ENUMERROR.getErrorMessage());
|
return false;
|
}
|
|
return true;
|
}
|
|
/**
|
* 停止下载录像
|
*/
|
public void stopDownLoadRecordFile() {
|
stopDownLoadRecordFile(n_hDownLoadHandle);
|
}
|
|
/**
|
* 停止下载录像
|
* @param hDownLoadHandle 下载句柄
|
*/
|
private static void stopDownLoadRecordFile(LLong hDownLoadHandle) {
|
if (hDownLoadHandle.longValue() == 0) {
|
return;
|
}
|
netsdkApi.CLIENT_StopDownload(hDownLoadHandle);
|
}
|
|
/**
|
* 下载进度回调
|
* 回调建议写成单例模式, 回调里处理数据，需要另开线程
|
*/
|
public static class DownloadPosCallback implements NetSDKLib.fDownLoadPosCallBack {
|
|
private DownloadPosCallback() {}
|
|
private static class CallBackHolder {
|
private static final DownloadPosCallback cb = new DownloadPosCallback();
|
}
|
|
public static final DownloadPosCallback getInstance() {
|
return CallBackHolder.cb;
|
}
|
|
@Override
|
public void invoke(LLong lPlayHandle, int dwTotalSize, int dwDownLoadSize, Pointer dwUser) {
|
|
System.out.println("Download pos： " + dwDownLoadSize*100 / dwTotalSize);
|
if(dwDownLoadSize == -1) { // 下载结束
|
System.out.println("Downloading Complete. ");
|
new StopDownloadTask(lPlayHandle).start();
|
}
|
System.out.println(dwDownLoadSize);
|
}
|
|
private class StopDownloadTask extends Thread {
|
private LLong lDownloadHandle;
|
|
public StopDownloadTask(LLong lDownloadHandle) {
|
this.lDownloadHandle = lDownloadHandle;
|
}
|
|
public void run() {
|
stopDownLoadRecordFile(lDownloadHandle);
|
}
|
}
|
}
|
|
/**
|
* 按时间标记录像
|
* @param nChannel 通道号
|
* @param startTime 开始时间
|
* @param endTime 结束时间
|
* @param nMark 标记动作 1:标记, 0:清除
|
*/
|
public boolean markFileByTime(int nChannel, NET_TIME_EX startTime, NET_TIME_EX endTime, int nMark) {
|
|
NET_IN_SET_MARK_FILE_BY_TIME stuIn = new NET_IN_SET_MARK_FILE_BY_TIME();
|
NET_OUT_SET_MARK_FILE_BY_TIME stuOut = new NET_OUT_SET_MARK_FILE_BY_TIME();
|
|
stuIn.nChannel = nChannel;
|
stuIn.stuStartTime = startTime;
|
stuIn.stuEndTime = endTime;
|
stuIn.bFlag = nMark;
|
|
boolean bRet = netsdkApi.CLIENT_SetMarkFileByTime(m_loginHandle, stuIn, stuOut, 10000);
|
if(bRet) {
|
System.out.println("Set Mark File By Time Success.");
|
} else {
|
System.err.println("Set Mark File By Time Failed!" + ToolKits.getErrorCode());
|
return false;
|
}
|
return bRet;
|
}
|
|
/**
|
* 查询某段时间内的录像加锁文件
|
* @param nChannel 通道号
|
* @param startTime 开始时间
|
* @param endTime 结束时间
|
*/
|
public boolean queryMarkFile(int nChannel, NET_TIME startTime, NET_TIME endTime) {
|
|
lstLockFile.clear();
|
|
// 获取标记录像信息
|
NET_IN_MEDIA_QUERY_FILE stuQueryCondition = new NET_IN_MEDIA_QUERY_FILE();
|
|
stuQueryCondition.nMediaType = 2; // 查询dav
|
stuQueryCondition.nChannelID = nChannel;
|
stuQueryCondition.nFalgCount = 1;
|
stuQueryCondition.emFalgLists[0] = EM_RECORD_SNAP_FLAG_TYPE.FLAG_TYPE_MARKED;
|
stuQueryCondition.stuStartTime = startTime;
|
stuQueryCondition.stuEndTime = endTime;
|
|
stuQueryCondition.write();
|
LLong lFindHandle = netsdkApi.CLIENT_FindFileEx(m_loginHandle,
|
EM_FILE_QUERY_TYPE.NET_FILE_QUERY_FILE, stuQueryCondition.getPointer(), null, 3000);
|
if(lFindHandle.longValue() == 0){
|
System.err.println("Find Marked File Failed!" + ToolKits.getErrorCode());
|
return false;
|
}
|
|
int nMaxQueryCount = 24;
|
NET_OUT_MEDIA_QUERY_FILE[] outfile = new NET_OUT_MEDIA_QUERY_FILE[nMaxQueryCount];
|
for (int i = 0; i < nMaxQueryCount; i++) {
|
outfile[i] = new NET_OUT_MEDIA_QUERY_FILE();
|
}
|
|
int nMemorySize = outfile[0].size() * nMaxQueryCount;
|
Pointer pMediaFileInfo = new Memory(nMemorySize);
|
pMediaFileInfo.clear(nMemorySize);
|
ToolKits.SetStructArrToPointerData(outfile, pMediaFileInfo);
|
|
int nFindCount = 0;
|
while(true) {
|
int nRetCount = netsdkApi.CLIENT_FindNextFileEx(lFindHandle, nMaxQueryCount, pMediaFileInfo, nMemorySize, null, 3000);
|
if(nRetCount < 0) {
|
System.err.println("Find Next Marked File Failed!" + ToolKits.getErrorCode());
|
netsdkApi.CLIENT_FindCloseEx(lFindHandle);
|
return false;
|
}
|
|
ToolKits.GetPointerDataToStructArr(pMediaFileInfo, outfile);
|
for (int i = 0; i < nRetCount; i++) {
|
lstLockFile.add(new LockFileInfo(outfile[i].nCluster, outfile[i].nDriveNo));
|
++nFindCount;
|
System.out.println("标记文件[" + nFindCount + "]通道 :" + outfile[i].nChannelID
|
+ " 开始时间 :" + outfile[i].stuStartTime.toStringTime()
|
+ " 结束时间 :" + outfile[i].stuEndTime.toStringTime());
|
}
|
|
if(nRetCount < nMaxQueryCount) {
|
break;
|
}
|
}
|
|
if (nFindCount == 0) {
|
System.out.println("此时间段无加锁文件");
|
}
|
|
netsdkApi.CLIENT_FindCloseEx(lFindHandle);
|
|
return true;
|
}
|
|
/**
|
* 按文件解锁录像
|
* @param stFileInfo 文件信息 (queryMarkFile获取)
|
*/
|
public boolean UnlockRecordByFile(LockFileInfo stFileInfo) {
|
|
NET_IN_SET_MARK_FILE stuIn = new NET_IN_SET_MARK_FILE();
|
stuIn.emLockMode = EM_MARKFILE_MODE.EM_MARK_FILE_BY_NAME_MODE; // 通过文件名方式对录像加锁
|
stuIn.emFileNameMadeType = EM_MARKFILE_NAMEMADE_TYPE.EM_MARKFILE_NAMEMADE_JOINT; // 拼接文件名方式
|
stuIn.nDriveNo = stFileInfo.nDriveNo;
|
stuIn.nStartCluster = stFileInfo.nCluster;
|
stuIn.byImportantRecID = (byte)0; // 清除
|
NET_OUT_SET_MARK_FILE stuOut = new NET_OUT_SET_MARK_FILE();
|
|
boolean bRet = netsdkApi.CLIENT_SetMarkFile(m_loginHandle, stuIn, stuOut, 3000);
|
if(bRet) {
|
System.out.printf("Unlock Record DriveNo[%d] Cluster[%d] Success. \n", stFileInfo.nDriveNo, stFileInfo.nCluster);
|
} else {
|
System.err.printf("Unlock Record DriveNo[%d] Cluster[%d] Failed! %s \n", stFileInfo.nDriveNo, stFileInfo.nCluster, ToolKits.getErrorCode());
|
return false;
|
}
|
return bRet;
|
}
|
|
/**
|
* 报警监听
|
*/
|
public boolean startListen() {
|
if (bListening) {
|
return true;
|
}
|
|
bListening = netsdkApi.CLIENT_StartListenEx(m_loginHandle);
|
if (!bListening) {
|
System.err.println("Start Listen Failed!" + ToolKits.getErrorCode());
|
} else {
|
System.out.println("Start Listen Success.");
|
}
|
|
return bListening;
|
}
|
|
public static class MessCallback implements NetSDKLib.fMessCallBack {
|
|
private final String[] radioStatus = {"异常", "活跃", "降级", "休眠", "同步中"};
|
private MessCallback() {}
|
|
private static class CallBackHolder {
|
private static final MessCallback cb = new MessCallback();
|
}
|
|
public static final MessCallback getInstance() {
|
return CallBackHolder.cb;
|
}
|
|
@Override
|
public boolean invoke(int lCommand, LLong lLoginID, Pointer pStuEvent,
|
int dwBufLen, String strDeviceIP, NativeLong nDevicePort,
|
Pointer dwUser) {
|
switch (lCommand) {
|
case NetSDKLib.NET_SHELTER_ALARM_EX: // 视频遮挡
|
AlarmInBytes(pStuEvent, dwBufLen, "视频遮挡");
|
break;
|
case NetSDKLib.NET_DISKFULL_ALARM_EX: // 硬盘满
|
AlarmInBytes(pStuEvent, dwBufLen, "硬盘满");
|
break;
|
case NetSDKLib.NET_DISKERROR_ALARM_EX: // 硬盘故障
|
AlarmInBytes(pStuEvent, dwBufLen, "硬盘故障");
|
break;
|
case NetSDKLib.NET_ALARM_RAID_STATE : // RAID异常报警
|
{
|
ALARM_RAID_INFO msg = new ALARM_RAID_INFO();
|
ToolKits.GetPointerData(pStuEvent, msg);
|
for (int i = 0; i < msg.nRaidNumber; ++i) {
|
if (msg.stuRaidInfo[i].byStatus >= 0 &&
|
msg.stuRaidInfo[i].byStatus < radioStatus.length) {
|
System.out.printf("[RAID异常报警] Raid名称:%s 状态:%s \n",
|
new String(msg.stuRaidInfo[i].szName).trim(), radioStatus[msg.stuRaidInfo[i].byStatus]); // 未做异常考虑
|
}else {
|
System.out.printf("[RAID异常报警] Raid名称:%s 状态:未知 \n", new String(msg.stuRaidInfo[i].szName).trim());
|
}
|
}
|
break;
|
}
|
case NetSDKLib.NET_ALARM_FRONTDISCONNECT : // 前端IPC断网报警
|
{
|
ALARM_FRONTDISCONNET_INFO msg = new ALARM_FRONTDISCONNET_INFO();
|
ToolKits.GetPointerData(pStuEvent, msg);
|
System.out.printf("[前端IPC断网报警] 时间:%s 前端IPC:%s 对应通道:%d 断网%s \n",
|
msg.stuTime.toStringTime(), new String(msg.szIpAddress).trim(),
|
msg.nChannelID, msg.nAction == 0? "开始": "已恢复");
|
break;
|
}
|
default:
|
break;
|
|
}
|
|
return true;
|
}
|
|
private void AlarmInBytes(Pointer pStuEvent, int dwBufLen, String alarmReason) {
|
byte []alarm = new byte[dwBufLen];
|
pStuEvent.read(0, alarm, 0, dwBufLen);
|
for (int i = 0; i < dwBufLen; i++) {
|
if (alarm[i] == 1) {
|
System.out.println("通道[" + i + "]" + alarmReason);
|
}else {
|
System.out.println("通道[" + i + "]" + alarmReason + "状态正常");
|
}
|
}
|
}
|
}
|
|
/**
|
* 停止报警监听
|
*/
|
public void stopListen() {
|
if (bListening) {
|
netsdkApi.CLIENT_StopListen(m_loginHandle);
|
bListening = false;
|
}
|
}
|
|
/**
|
* 查询在线状态
|
*/
|
public boolean queryOnlineState() {
|
|
IntByReference retLen = new IntByReference(0);
|
Pointer p = new Memory(Integer.SIZE);
|
p.clear(Integer.SIZE);
|
if (!netsdkApi.CLIENT_QueryDevState(m_loginHandle,
|
NetSDKLib.NET_DEVSTATE_ONLINE,
|
p,
|
Integer.SIZE,
|
retLen,
|
3000)) {
|
System.err.println("Query Online State Failed!" + ToolKits.getErrorCode());
|
return false;
|
}
|
|
int []a = new int[1];
|
p.read(0, a, 0, 1);
|
System.out.println("设备" + (a[0]==1?"在线":"断线"));
|
return true;
|
}
|
|
/**
|
* 查询硬盘状态
|
*/
|
public boolean queryHardDiskState() {
|
IntByReference intRetLen = new IntByReference();
|
NET_DEV_HARDDISK_STATE diskInfo = new NET_DEV_HARDDISK_STATE();
|
if (netsdkApi.CLIENT_QueryDevState(m_loginHandle,
|
NetSDKLib.NET_DEVSTATE_DISK,
|
diskInfo.getPointer(),
|
diskInfo.size(),
|
intRetLen,
|
5000)) {
|
diskInfo.read();
|
|
String[] diskType = {"读写驱动器", "只读驱动器", "备份驱动器或媒体驱动器", "冗余驱动器", "快照驱动器"};
|
String[] diskStatus = {"休眠", "活动", "故障"};
|
String[] diskSignal = {"本地", "远程"};
|
for (int i = 0; i < diskInfo.dwDiskNum; ++i) {
|
System.out.printf("硬盘[%d] 硬盘号:%d 分区号:%d 容量:%dMB 剩余空间:%dMB 标识:%s 类型:%s 状态:%s \n",
|
i+1, diskInfo.stDisks[i].bDiskNum, diskInfo.stDisks[i].bSubareaNum,
|
diskInfo.stDisks[i].dwVolume, diskInfo.stDisks[i].dwFreeSpace, diskSignal[diskInfo.stDisks[i].bSignal],
|
diskType[(diskInfo.stDisks[i].dwStatus&0xF0) >> 4], diskStatus[diskInfo.stDisks[i].dwStatus&0x0F]);
|
}
|
}else {
|
System.err.println("Query Hard Disk State Failed!" + ToolKits.getErrorCode());
|
return false;
|
}
|
return true;
|
}
|
|
/**
|
* 查询Raid状态
|
*/
|
public boolean queryRaidStatue() {
|
IntByReference intRetLen = new IntByReference();
|
ALARM_RAID_INFO raidInfo = new ALARM_RAID_INFO();
|
if (netsdkApi.CLIENT_QueryDevState(m_loginHandle,
|
NetSDKLib.NET_DEVSTATE_RAID_INFO,
|
raidInfo.getPointer(),
|
raidInfo.size(),
|
intRetLen,
|
5000)) {
|
raidInfo.read();
|
|
if (raidInfo.nRaidNumber == 0) {
|
System.out.println("无Raid");
|
}
|
|
final String[] radioStatus = {"异常", "活跃", "降级", "休眠", "同步中"};
|
for (int i = 0; i < raidInfo.nRaidNumber; ++i) {
|
if (raidInfo.stuRaidInfo[i].byStatus >= 0 &&
|
raidInfo.stuRaidInfo[i].byStatus < radioStatus.length) {
|
System.out.printf("Raid名称:%s 状态:%s \n",
|
new String(raidInfo.stuRaidInfo[i].szName).trim(), radioStatus[raidInfo.stuRaidInfo[i].byStatus]); // 未做异常考虑
|
}else {
|
System.out.printf("Raid名称:%s 状态:未知 \n", new String(raidInfo.stuRaidInfo[i].szName).trim());
|
}
|
}
|
}else {
|
System.err.println("Query Radio State Failed!" + ToolKits.getErrorCode());
|
return false;
|
}
|
|
return true;
|
}
|
|
/**
|
* 获取摄像机状态
|
*/
|
private boolean queryCameraState() {
|
NET_CAMERA_STATE_INFO[] arrCameraStatus = new NET_CAMERA_STATE_INFO[deviceinfo.byChanNum];
|
for(int i = 0; i < arrCameraStatus.length; i++) {
|
arrCameraStatus[i] = new NET_CAMERA_STATE_INFO();
|
}
|
|
// 入参
|
NET_IN_GET_CAMERA_STATEINFO stIn = new NET_IN_GET_CAMERA_STATEINFO();
|
stIn.bGetAllFlag = 1; // 全部
|
|
// 出参
|
NET_OUT_GET_CAMERA_STATEINFO stOut = new NET_OUT_GET_CAMERA_STATEINFO();
|
stOut.nMaxNum = deviceinfo.byChanNum;
|
stOut.pCameraStateInfo = new Memory(arrCameraStatus[0].size() * deviceinfo.byChanNum);
|
stOut.pCameraStateInfo.clear(arrCameraStatus[0].size() * deviceinfo.byChanNum);
|
ToolKits.SetStructArrToPointerData(arrCameraStatus, stOut.pCameraStateInfo); // 将数组内存拷贝到Pointer
|
|
stIn.write();
|
stOut.write();
|
|
boolean bRet = netsdkApi.CLIENT_QueryDevInfo(m_loginHandle, NetSDKLib.NET_QUERY_GET_CAMERA_STATE,
|
stIn.getPointer(), stOut.getPointer(), null, 3000);
|
if(bRet) {
|
stOut.read();
|
ToolKits.GetPointerDataToStructArr(stOut.pCameraStateInfo, arrCameraStatus); // 将Pointer拷贝到数组内存
|
final String [] connectionState = {"未知", "正在连接", "已连接", "未连接", "通道未配置,无信息", "通道有配置,但被禁用"};
|
for (int i = 0; i < stOut.nValidNum; ++i) {
|
System.out.printf("通道%d:%s ", arrCameraStatus[i].nChannel, connectionState[arrCameraStatus[i].emConnectionState]);
|
if ((i+1)%8 == 0) {
|
System.out.println();
|
}
|
}
|
|
} else {
|
System.err.println("Query Camera State Failed!" + ToolKits.getErrorCode());
|
}
|
|
return bRet;
|
}
|
|
/**
|
* 获取自动维护配置
|
* @return 成功返回配置信息, 失败返回null
|
*/
|
public NETDEV_AUTOMT_CFG getAutoRecordCyc() {
|
NETDEV_AUTOMT_CFG stuCfg = new NETDEV_AUTOMT_CFG();
|
IntByReference nReturnLen = new IntByReference(0);
|
if (!netsdkApi.CLIENT_GetDevConfig(m_loginHandle, NetSDKLib.NET_DEV_AUTOMTCFG, -1,
|
stuCfg.getPointer(), stuCfg.size(), nReturnLen, 5000)) {
|
System.out.println("getAutoRecordCyc Failed!" + ToolKits.getErrorCode());
|
return null;
|
}
|
|
stuCfg.read();
|
return stuCfg;
|
}
|
|
/**
|
* 自动录像保存周期设置
|
* @param stuCfg 自动维护配置
|
*/
|
public boolean setAutoRecordCyc(NETDEV_AUTOMT_CFG stuCfg) {
|
stuCfg.write();
|
if (!netsdkApi.CLIENT_SetDevConfig(m_loginHandle, NetSDKLib.NET_DEV_AUTOMTCFG, -1,
|
stuCfg.getPointer(), stuCfg.size(), 5000)) {
|
System.out.println("setAutoRecordCyc Failed!" + ToolKits.getErrorCode());
|
return false;
|
}else {
|
System.out.println("setAutoRecordCyc Success!");
|
}
|
|
return true;
|
}
|
|
/*************************************************************************************
|
* Download Record Implement *
|
*************************************************************************************/
|
private static SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
|
/**
|
* 下载录像
|
*/
|
public void downloadRecordFile() {
|
|
int nStreamType = 0; // 0-主辅码流,1-主码流,2-辅码流
|
int nChannel = 0; // 通道号
|
NET_TIME stTimeStart = new NET_TIME(); // 开始时间
|
NET_TIME stTimeEnd = new NET_TIME(); // 结束时间
|
|
Calendar calendar = Calendar.getInstance();
|
|
@SuppressWarnings("resource")
|
Scanner scanner = new Scanner(System.in);
|
System.out.println("默认下载通道0主辅码流的最近10分钟录像");
|
System.out.print("如果想要自己设置通道或时间段请输入1: ");
|
if (scanner.nextInt() == 1) {
|
try {
|
System.out.print("请输入通道号(从0开始): ");
|
nChannel = scanner.nextInt();
|
|
System.out.print("请输入开始时间(格式:yyyy-MM-dd HH:mm:ss): ");
|
calendar.setTime(format.parse("2020-9-15 11:38:00"));
|
setTime(calendar, stTimeStart);
|
|
System.out.print("请输入结束时间(格式:yyyy-MM-dd HH:mm:ss): ");
|
calendar.setTime(format.parse("2019-12-02 11:39:00"));
|
setTime(calendar, stTimeEnd);
|
} catch (ParseException e) {
|
System.err.println("时间输入非法");
|
return;
|
}
|
|
}else {
|
calendar.setTime(new Date());
|
setTime(calendar, stTimeEnd);
|
|
calendar.add(Calendar.MINUTE, -10);
|
setTime(calendar, stTimeStart);
|
}
|
|
String savedFileName = "dowload_" + System.currentTimeMillis() + ".mp4"; // 保存录像文件名
|
|
downloadRecordFile(nStreamType, nChannel, stTimeStart, stTimeEnd, savedFileName);
|
}
|
|
/**
|
* 按时间标记录像
|
*/
|
public void markFileByTime() {
|
int nChannel = 0;
|
NET_TIME_EX stTimeStart = new NET_TIME_EX();
|
NET_TIME_EX stTimeEnd = new NET_TIME_EX();
|
int nMark = 1;
|
Calendar calendar = Calendar.getInstance();
|
|
@SuppressWarnings("resource")
|
Scanner scanner = new Scanner(System.in);
|
System.out.println("默认对通道0前6个小时的录像加解锁");
|
System.out.print("如果想要自己设置通道和时间段请输入1: ");
|
if (scanner.nextInt() == 1) {
|
try {
|
System.out.print("请输入标记类型(1加锁 0 解锁): ");
|
nMark = scanner.nextInt();
|
|
System.out.print("请输入通道号(从0开始, -1代表全通道): ");
|
nChannel = scanner.nextInt();
|
|
System.out.print("请输入开始时间(格式:yyyy-MM-dd HH:mm:ss): ");
|
calendar.setTime(format.parse(scanner.next()));
|
setTime(calendar, stTimeStart);
|
|
System.out.print("请输入结束时间(格式:yyyy-MM-dd HH:mm:ss): ");
|
calendar.setTime(format.parse(scanner.next()));
|
setTime(calendar, stTimeEnd);
|
} catch (ParseException e) {
|
System.err.println("时间输入非法");
|
return;
|
}
|
}else {
|
System.out.print("请输入标记类型(1加锁 0 解锁): ");
|
nMark = scanner.nextInt();
|
|
calendar.setTime(new Date());
|
setTime(calendar, stTimeEnd);
|
|
calendar.add(Calendar.HOUR_OF_DAY, -6);
|
setTime(calendar, stTimeStart);
|
}
|
|
markFileByTime(nChannel, stTimeStart, stTimeEnd, nMark);
|
}
|
|
/**
|
* 获取某段时间内的录像加锁文件
|
*/
|
public void queryMarkFile() {
|
int nChannel = 0;
|
NET_TIME stTimeStart = new NET_TIME();
|
NET_TIME stTimeEnd = new NET_TIME();
|
Calendar calendar = Calendar.getInstance();
|
|
@SuppressWarnings("resource")
|
Scanner scanner = new Scanner(System.in);
|
System.out.println("默认查询通道0前6个小时的加锁录像");
|
System.out.print("如果想要自己设置通道和时间段请输入1: ");
|
if (scanner.nextInt() == 1) {
|
try {
|
System.out.print("请输入通道号(从0开始, -1代表全通道): ");
|
nChannel = scanner.nextInt();
|
|
System.out.print("请输入开始时间(格式:yyyy-MM-dd HH:mm:ss): ");
|
calendar.setTime(format.parse(scanner.next()));
|
setTime(calendar, stTimeStart);
|
|
System.out.print("请输入结束时间(格式:yyyy-MM-dd HH:mm:ss): ");
|
calendar.setTime(format.parse(scanner.next()));
|
setTime(calendar, stTimeEnd);
|
} catch (ParseException e) {
|
System.err.println("时间输入非法");
|
return;
|
}
|
}else {
|
calendar.setTime(new Date());
|
setTime(calendar, stTimeEnd);
|
|
calendar.add(Calendar.HOUR_OF_DAY, -6);
|
setTime(calendar, stTimeStart);
|
}
|
|
queryMarkFile(nChannel, stTimeStart, stTimeEnd);
|
}
|
|
/**
|
* 按文件录像解锁
|
*/
|
public void UnlockRecordByFile() {
|
if (lstLockFile.isEmpty()) {
|
queryMarkFile();
|
}
|
|
for (LockFileInfo stFileInfo : lstLockFile) {
|
UnlockRecordByFile(stFileInfo);
|
}
|
|
lstLockFile.clear();
|
}
|
|
private void setTime(Calendar calendar, NET_TIME_EX stuTime) {
|
stuTime.dwYear = calendar.get(Calendar.YEAR);
|
stuTime.dwMonth = calendar.get(Calendar.MONTH) + 1;
|
stuTime.dwDay = calendar.get(Calendar.DAY_OF_MONTH);
|
stuTime.dwHour = calendar.get(Calendar.HOUR_OF_DAY);
|
stuTime.dwMinute = calendar.get(Calendar.MINUTE);
|
stuTime.dwSecond = calendar.get(Calendar.SECOND);
|
}
|
|
private void setTime(Calendar calendar, NET_TIME stuTime) {
|
stuTime.setTime(calendar.get(Calendar.YEAR), calendar.get(Calendar.MONTH) + 1, calendar.get(Calendar.DAY_OF_MONTH),
|
calendar.get(Calendar.HOUR_OF_DAY), calendar.get(Calendar.MINUTE), calendar.get(Calendar.SECOND));
|
}
|
|
/**
|
* 查询设备状态
|
*/
|
public void queryDeviceStatus() {
|
|
System.out.println("-------------------设备在线状态-------------------");
|
queryOnlineState();
|
|
System.out.println("-------------------硬盘状态-------------------");
|
queryHardDiskState(); // 查询硬盘状态
|
|
System.out.println("-------------------Raid状态-------------------");
|
queryRaidStatue(); // 查询Raid状态
|
|
System.out.println("-------------------摄像机状态-------------------");
|
queryCameraState(); // 获取摄像机状态
|
}
|
public void GetIVSSDisk() {
|
NET_IN_STORAGE_DEV_INFOS inInfo = new NET_IN_STORAGE_DEV_INFOS();
|
inInfo.emVolumeType = NET_VOLUME_TYPE.VOLUME_TYPE_ALL; // 单盘可以查询支持的工作组
|
NET_OUT_STORAGE_DEV_INFOS outInfo = new NET_OUT_STORAGE_DEV_INFOS();
|
for (int i = 0; i < outInfo.stuStoregeDevInfos.length; i ++)
|
{
|
outInfo.stuStoregeDevInfos[i].dwSize = outInfo.stuStoregeDevInfos[0].dwSize;
|
}
|
inInfo.write();
|
outInfo.write();
|
boolean bRet = netsdkApi.CLIENT_QueryDevInfo(m_loginHandle, NetSDKLib.NET_QUERY_DEV_STORAGE_INFOS, inInfo.getPointer(), outInfo.getPointer(), null, 5000);
|
inInfo.read();
|
outInfo.read();
|
if (!bRet) {
|
System.err.println("CLIENT_QueryDevInfo Failed!" + ToolKits.getErrorCode());
|
return;
|
}
|
for (int i = 0; i < outInfo.nDevInfosNum; i ++)
|
{
|
System.out.println("------------第"+(i+1)+"块盘-------------");
|
NET_STORAGE_DEVICE device = outInfo.stuStoregeDevInfos[i];
|
System.out.println("槽位："+device.nPhysicNo); // 槽位
|
System.out.println("名称："+new String(device.szName).trim()); // 名称
|
//System.out.println(device.nTotalSpace);
|
//System.out.println(device.nFreeSpace);
|
System.out.println(new String(device.szModule).trim()); // 型号
|
String valume[] = {"0-物理卷", "1-Raid卷", "2-VG虚拟卷", "3-ISCSI", "4-独立物理卷", "5-全局热备卷", "6-NAS卷(包括FTP, SAMBA, NFS)", "7-独立RAID卷（指没有加入到，虚拟卷组等组中）"};
|
System.out.println("byVolume的值: "+device.byVolume);
|
System.out.println("卷类型: "+valume[device.byVolume]); // 卷类型
|
if (device.byVolume == 1) {
|
System.out.println("Raid Stat: " + device.stuRaid.nState);
|
} else { // 单盘问题
|
String arState[] =
|
{
|
"Offline-物理硬盘脱机状态", "Running-物理硬盘运行状态", "Active-RAID活动", "Sync-RAID同步", "Spare-RAID热备(局部)",
|
"Faulty-RAID失效", "Rebuilding-RAID重建", "Removed-RAID移除", "WriteError-RAID写错误", "WantReplacement-RAID需要被替换",
|
"Replacement-RAID是替代设备", "GlobalSpare-全局热备", "Error-一般错误，部分分区可用", "RaidSub-该盘目前是单盘，原先是块Raid子盘,有可能在重启后自动加入Raid",
|
};
|
if ((int)device.byState != NetFinalVar.NET_STORAGE_DEV_RUNNING) {
|
System.out.println(arState[(int)device.byState]); // 状态
|
continue;
|
}
|
if (device.emPreDiskCheck != EM_STORAGE_DISK_PREDISKCHECK.EM_STORAGE_DISK_PREDISKCHECK_UNKNOWN) {
|
System.out.println("device.emPreDiskCheck " + device.emPreDiskCheck);
|
}
|
}
|
}
|
}
|
|
/**
|
* 自动录像保存周期设置
|
*/
|
public void setAutoRecordCyc() {
|
// 先获取再配置
|
NETDEV_AUTOMT_CFG stuCfg = getAutoRecordCyc();
|
if (stuCfg != null) {
|
System.out.println("设置前自动录像保存天数(0：从不删除, 1：24H,2：48H,3：72H,4：96H,...):" + stuCfg.byAutoDeleteFilesTime);
|
@SuppressWarnings("resource")
|
Scanner scanner = new Scanner(System.in);
|
System.out.print("请输入自动录像保存天数(0：从不删除, 1：24H,2：48H,3：72H,4：96H,...):");
|
stuCfg.byAutoDeleteFilesTime = scanner.nextByte();
|
setAutoRecordCyc(stuCfg);
|
}
|
}
|
|
/**
|
* 自动录像保存周期设置扩展 新设备支持
|
*/
|
public void setAutoRecordCycEx() {
|
for (int i = 0; i < deviceinfo.byChanNum; i ++) {
|
NET_CFG_FILE_HOLD_DAYS_INFO cfg = new NET_CFG_FILE_HOLD_DAYS_INFO();
|
cfg.write();
|
boolean bGet = netsdkApi.CLIENT_GetConfig(m_loginHandle, NET_EM_CFG_OPERATE_TYPE.NET_EM_CFG_FILE_HOLD_DAYS, i, cfg.getPointer(), cfg.size(), 5000, null);
|
cfg.read();
|
if (!bGet) {
|
System.err.println("Failed to Get. Channel:" + i + " " + ToolKits.getErrorCode());
|
} else {
|
System.out.println("Channel: " + i +";nDays: " + cfg.nDays);
|
cfg.nDays += 1;
|
}
|
|
cfg.write();
|
boolean bSet = netsdkApi.CLIENT_SetConfig(m_loginHandle, NET_EM_CFG_OPERATE_TYPE.NET_EM_CFG_FILE_HOLD_DAYS, i, cfg.getPointer(), cfg.size(), 5000, null,null);
|
cfg.read();
|
if (!bSet) {
|
System.err.println("Failed to Set. Channel:" + i + " " + ToolKits.getErrorCode());
|
}
|
}
|
}
|
|
////////////////////////////////////////////////////////////////
|
String m_strIp = "10.33.121.53";
|
int m_nPort = 37777;
|
String m_strUser = "admin";
|
String m_strPassword = "admin";
|
////////////////////////////////////////////////////////////////
|
|
public void RunTest()
|
{
|
System.out.println("Run Test");
|
CaseMenu menu = new CaseMenu();
|
menu.addItem(new CaseMenu.Item(this , "下载录像" , "downloadRecordFile"));
|
menu.addItem(new CaseMenu.Item(this , "停止下载录像" , "stopDownLoadRecordFile"));
|
|
menu.addItem(new CaseMenu.Item(this , "按时间对录像加解锁" , "markFileByTime"));
|
menu.addItem(new CaseMenu.Item(this , "按时间查询加锁文件" , "queryMarkFile"));
|
menu.addItem(new CaseMenu.Item(this , "按文件录像解锁" , "UnlockRecordByFile"));
|
|
menu.addItem(new CaseMenu.Item(this , "报警监听" , "startListen"));
|
menu.addItem(new CaseMenu.Item(this , "停止报警监听" , "stopListen"));
|
menu.addItem(new CaseMenu.Item(this , "查询设备状态" , "queryDeviceStatus"));
|
|
menu.addItem(new CaseMenu.Item(this , "获取raid状态" , "GetIVSSDisk"));
|
menu.addItem(new CaseMenu.Item(this , "自动录像保存周期设置" , "setAutoRecordCycEx"));
|
|
menu.run();
|
}
|
|
public static void main(String[]args)
|
{
|
DownloadRecord demo = new DownloadRecord();
|
demo.InitTest();
|
demo.RunTest();
|
demo.EndTest();
|
}
|
}
|
