package com.netsdk.demo.accessControl;

import com.netsdk.demo.customize.PrintStruct;
import com.netsdk.demo.customize.healthCodeEx.callback.RegisterServiceCallBack;
import com.netsdk.demo.customize.healthCodeEx.entity.DeviceInfo;
import com.netsdk.demo.customize.healthCodeEx.entity.ListenInfo;
import com.netsdk.demo.customize.healthCodeEx.module.AutoRegisterModule;
import com.netsdk.demo.customize.healthCodeEx.module.LoginModule;
import com.netsdk.demo.util.Base64Util;
import com.netsdk.demo.util.CaseMenu;
import com.netsdk.lib.NetSDKLib;
import com.netsdk.lib.NetSDKLib.*;
import com.netsdk.lib.ToolKits;
import com.netsdk.lib.enumeration.ENUMERROR;
import com.netsdk.lib.structure.BYTE_32;
import com.netsdk.lib.structure.NET_DEV_EVENT_USERMANAGER_FOR_TWSDK_INFO;
import com.netsdk.lib.structure.NET_TIME_EX;
import com.netsdk.lib.structure.NET_USERMANAGER_IMAGE_INFO;
import com.sun.jna.Memory;
import com.sun.jna.NativeLong;
import com.sun.jna.Pointer;

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.*;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Map;
import java.util.Scanner;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;

import static com.netsdk.lib.Utils.getOsPrefix;

public class AccessNew {
	static NetSDKLib netsdkApi = NetSDKLib.NETSDK_INSTANCE;

	// 设备信息
	private	static String m_strIp = "172.5.99.171";//172.5.111.16 172.10.6.187
	private	static  int m_nPort = 37777;
	private static String m_strUser = "admin";
	private static 	String m_strPassword = "admin123";

	// 接口调用超时时间
	private static final int TIME_OUT = 6 * 1000;

	private static NetSDKLib.NET_DEVICEINFO_Ex deviceinfo = new NetSDKLib.NET_DEVICEINFO_Ex();

	private static LLong loginHandle = new LLong(0); // 登陆句柄

	private static LLong m_hAttachHandle = new LLong(0); // 订阅句柄

	// 设备断线回调: 通过 CLIENT_Init 设置该回调函数，当设备出现断线时，SDK会调用该函数
	public class fDisConnectCB implements NetSDKLib.fDisConnect {
		public void invoke(LLong lLoginID, String pchDVRIP, int nDVRPort,
				Pointer dwUser) {
			System.out.printf("Device[%s] Port[%d] Disconnect!\n", pchDVRIP,
					nDVRPort);
		}
	}

	// 网络连接恢复，设备重连成功回调
	// 通过 CLIENT_SetAutoReconnect 设置该回调函数，当已断线的设备重连成功时，SDK会调用该函数
	public class HaveReConnect implements NetSDKLib.fHaveReConnect {
		public void invoke(LLong loginHandle, String pchDVRIP, int nDVRPort,
				Pointer dwUser) {
			System.out.printf("ReConnect Device[%s] Port[%d]\n", pchDVRIP,
					nDVRPort);
		}
	}

	private fDisConnectCB m_DisConnectCB = new fDisConnectCB();
	private HaveReConnect haveReConnect = new HaveReConnect();

	// 用户存储注册上来的设备信息的缓存 Map 项目中请替换成其他中间件
	private final Map<String, DeviceInfo> deviceInfoMap = new ConcurrentHashMap<>();

	// 主动注册监听句柄
	private NetSDKLib.LLong m_hListenHandle = new NetSDKLib.LLong(0);

	/////////////// 注册地址(服务器 这里是运行此Demo的电脑IP) 监听端口 //////////////////////
	private final String serverIpAddr = "10.33.121.53";
	private final int serverPort = 9500; // 注意不要和其他程序发生冲突
	private String username = "admin";
	private String password = "admin321";


	/**
	 * 主动注册
	 */
	public void autoRegisterLogin() {
		// 开启监听
		serverStartListen();
		// 登录设备
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入设备的注册 Serial：");
		String key = sc.nextLine().trim();

		DeviceInfo deviceInfo = deviceInfoMap.get(key);
		if (deviceInfo == null) {
			System.out.println("注册上报的设备中没有该 Serial");
			return;
		}

		// 注册设备的IP
		String ipAddr = deviceInfo.ipAddress;
		// 注册设备的端口
		int port = deviceInfo.port;
		// 账号
		String username = this.username;
		// 密码
		String password = this.password;

		loginHandle = LoginModule.AutoRegisterLoginWithHighSecurity(key, ipAddr, port, username,
				password, deviceInfo.m_stDeviceInfo);

		if (loginHandle.longValue() == 0) {
			System.err.println("主动注册登录失败:" + ENUMERROR.getErrorMessage());
			return;
		}
		loginHandle.setValue(loginHandle.longValue());
		// 清除此注册信息 请等待重新上报后再重新登录
		deviceInfoMap.remove(key);
	}
	private volatile Boolean taskIsOpen = false;
	/**
	 * 开启监听
	 */
	public void serverStartListen() {
		m_hListenHandle = AutoRegisterModule.ServerStartListen(serverIpAddr, serverPort,
				RegisterServiceCallBack.getInstance());
		if (m_hListenHandle.longValue() == 0)
			return;
		taskIsOpen = true;
		new Thread(this::eventListTask).start();
	}
	// 获取监听回调数据并放入缓存
	public void eventListTask() {
		while (taskIsOpen) {
			try {
				// 稍微延迟一下，避免循环的太快
				Thread.sleep(10);
				// 阻塞获取
				ListenInfo listenInfo = RegisterServiceCallBack.ServerInfoQueue.poll(50, TimeUnit.MILLISECONDS);
				if (listenInfo == null)
					continue;
				// 结果放入缓存
				if (!deviceInfoMap.containsKey(listenInfo.devSerial)) {
					deviceInfoMap.put(listenInfo.devSerial,
							new DeviceInfo(listenInfo.devIpAddress, listenInfo.devPort));
					System.out.println("...有新设备上报注册信息... Serial:" + listenInfo.devSerial);
				}
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	public void InitTest() {
		// 初始化SDK库，必须调用
		netsdkApi.CLIENT_Init(m_DisConnectCB, null);

		// 设置断线重连回调接口，设置过断线重连成功回调函数后，当设备出现断线情况，SDK内部会自动进行重连操作
		// 此操作为可选操作，但建议用户进行设置
		netsdkApi.CLIENT_SetAutoReconnect(haveReConnect, null);

		// 设置登录超时时间和尝试次数，可选
		int waitTime = 5000; // 登录请求响应超时时间设置为5S
		int tryTimes = 3; // 登录时尝试建立链接3次
		netsdkApi.CLIENT_SetConnectTime(waitTime, tryTimes);

		// 设置更多网络参数，NET_PARAM的nWaittime，nConnectTryNum成员与CLIENT_SetConnectTime
		// 接口设置的登录设备超时时间和尝试次数意义相同,可选
		NetSDKLib.NET_PARAM netParam = new NetSDKLib.NET_PARAM();
		netParam.nConnectTime = 10000; // 登录时尝试建立链接的超时时间

		netsdkApi.CLIENT_SetNetworkParam(netParam);

		// 打开日志，可选
		NetSDKLib.LOG_SET_PRINT_INFO setLog = new NetSDKLib.LOG_SET_PRINT_INFO();

		File path = new File("./sdklog/");
		if (!path.exists()) {
			path.mkdir();
		}

		String logPath = path.getAbsoluteFile().getParent()
				+ "/sdklog/sdklog.log";

		System.out.println(logPath);
		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 !!!");
		}

		deviceLogin();
	}

	/**
	 * 登录设备 两种登录方式 TCP登录 主动注册
	 */
	public void deviceLogin() {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入登录方式   1 TCP登录    2 主动注册:");
		String key = sc.nextLine().trim();
		if ("1".equals(key)) {
			tcpLogin();
		} else if ("2".equals(key)) {
			autoRegisterLogin();
		} else {
			System.out.println("输入信息错误...");
		}
	}


	// 登录 高安全 TCP
	public static NetSDKLib.LLong tcpLogin() {
		System.out.println("设备地址：" + m_strIp+ "\n端口号：" + m_nPort + "\n用户名：" + m_strUser + "\n密码：" + m_strPassword);


		NetSDKLib.NET_IN_LOGIN_WITH_HIGHLEVEL_SECURITY pstInParam =
				new NetSDKLib.NET_IN_LOGIN_WITH_HIGHLEVEL_SECURITY();   // 输入结构体参数
		System.arraycopy(m_strIp.getBytes(), 0, pstInParam.szIP, 0, m_strIp.length());
		pstInParam.nPort = m_nPort;
		System.arraycopy(m_strUser.getBytes(), 0, pstInParam.szUserName, 0, m_strUser.length());
		System.arraycopy(m_strPassword.getBytes(), 0, pstInParam.szPassword, 0, m_strPassword.length());
		pstInParam.emSpecCap = NetSDKLib.EM_LOGIN_SPAC_CAP_TYPE.EM_LOGIN_SPEC_CAP_TCP;

		NetSDKLib.NET_OUT_LOGIN_WITH_HIGHLEVEL_SECURITY pstOutParam =
				new NetSDKLib.NET_OUT_LOGIN_WITH_HIGHLEVEL_SECURITY();  // 输出结构体参数
		pstOutParam.stuDeviceInfo = deviceinfo;                     // 设备信息 登陆成功后会刷新这个实例

		loginHandle = netsdkApi.CLIENT_LoginWithHighLevelSecurity(pstInParam, pstOutParam);
		if (loginHandle.longValue() == 0) {
			System.err.printf("Login Device[%s] Port[%d]Failed. Last Error[%s]\n", m_strIp, m_nPort, ENUMERROR.getErrorMessage());
			EndTest();
		} else {
			System.out.println("Login Success [ " + m_strIp + " ]");
		}
		return loginHandle;
	}


	public static void EndTest() {
		System.out.println("End Test");
		if (loginHandle.longValue() != 0) {
			netsdkApi.CLIENT_Logout(loginHandle);
		}
		System.out.println("See You...");

		// 工程关闭时，释放SDK资源
		netsdkApi.CLIENT_Cleanup();
		System.exit(0);
	}

	// 获取当前时间
	public String getDate() {
		SimpleDateFormat simpleDate = new SimpleDateFormat(
				"yyyy-MM-dd HH:mm:ss");
		String date = simpleDate.format(new java.util.Date()).replace(" ", "_")
				.replace(":", "-");

		return date;
	}

	/**
	 * 获取接口错误码
	 * 
	 * @return
	 */
	public static String getErrorCode() {
		return " { error code: ( 0x80000000|"
				+ (netsdkApi.CLIENT_GetLastError() & 0x7fffffff)
				+ " ). 参考  NetSDKLib.java }";
	}

	/************************************************************************************************
	 * 获取或推送比对成功及失败记录（包括比对照片, 这个是通过触发事件，接收信息
	 ************************************************************************************************/
	/**
	 * 订阅
	 */
	public void realLoadPicture() {
		int bNeedPicture = 1; // 是否需要图片
		int ChannelId = 0; // -1代表全通道

		m_hAttachHandle = netsdkApi.CLIENT_RealLoadPictureEx(loginHandle,
				ChannelId, NetSDKLib.EVENT_IVS_ALL, bNeedPicture,
				fAnalyzerDataCB.getInstance(), null, null);
		if (m_hAttachHandle.longValue() != 0) {
			System.out.println("智能订阅成功.");
		} else {
			System.err.println("智能订阅失败." + getErrorCode());
			return;
		}
	}

	/**
	 * 取消订阅
	 *
	 */
	public void stopRealLoadPicture() {
		if (0 != m_hAttachHandle.longValue()) {
			netsdkApi.CLIENT_StopLoadPic(m_hAttachHandle);
			m_hAttachHandle.setValue(0);

			System.out.println("停止智能订阅.");
		}
	}

	static int count=0;
	/**
	 * 智能报警事件回调
	 */
	public static class fAnalyzerDataCB implements
			NetSDKLib.fAnalyzerDataCallBack {
		private fAnalyzerDataCB() {
		}

		private static class fAnalyzerDataCBHolder {
			private static final fAnalyzerDataCB instance = new fAnalyzerDataCB();
		}

		public static fAnalyzerDataCB getInstance() {
			return fAnalyzerDataCBHolder.instance;
		}

		@Override
		public int invoke(LLong lAnalyzerHandle, int dwAlarmType,
				Pointer pAlarmInfo, Pointer pBuffer, int dwBufSize,
				Pointer dwUser, int nSequence, Pointer reserved) {
			System.out.println("dwAlarmType:" + dwAlarmType);

			File path = new File("./AccessPicture/");
			if (!path.exists()) {
				path.mkdir();
			}

			switch (dwAlarmType) {
			case NetSDKLib.EVENT_IVS_ACCESS_CTL: // /< 门禁事件
			{
				DEV_EVENT_ACCESS_CTL_INFO msg = new DEV_EVENT_ACCESS_CTL_INFO();
				ToolKits.GetPointerData(pAlarmInfo, msg);

				System.out.println("事件名称 :" + new String(msg.szName).trim());
				if (msg.emEventType == 1) {
					System.out.println("门禁事件类型 : 进门！");
				} else if (msg.emEventType == 2) {
					System.out.println("门禁事件类型 : 出门！");
				}

				if (msg.bStatus == 1) {
					System.out.println("刷卡结果 : 成功！");
				} else if (msg.bStatus == 0) {
					System.out.println("刷卡结果 : 失败！");
				}

				System.out.println("卡类型：" + msg.emCardType);
				System.out.println("开门方式：" + msg.emOpenMethod);
				System.out.println("卡号 :" + new String(msg.szCardNo).trim());
				System.out.println("开门用户 :" + new String(msg.szUserID).trim());
				System.out.println("开门失败原因错误码：" + msg.nErrorCode);
				System.out.println("考勤状态：" + msg.emAttendanceState);
				System.out.println("卡命名 :" + new String(msg.szCardName).trim());
				System.out.println("相似度：" + msg.uSimilarity);
				System.out.println("证件号："
						+ new String(msg.szCitizenIDNo).trim());
				
				System.out.println("当前事件是否为采集卡片：" + msg.emCardState);
				
				System.out.println("szSN："
						+ new String(msg.szSN).trim());

				String facePicPath = "";
				for (int i = 0; i < msg.nImageInfoCount; i++) {
					facePicPath = path + "\\" + System.currentTimeMillis()
							+ "人脸图.jpg"; // 保存图片地址

					byte[] faceBuf = pBuffer.getByteArray(
							msg.stuImageInfo[i].nOffSet,
							msg.stuImageInfo[i].nLength);

					ByteArrayInputStream byteArrInputFace = new ByteArrayInputStream(
							faceBuf);

					try {
						BufferedImage bufferedImage = ImageIO
								.read(byteArrInputFace);
						if (bufferedImage != null) {
							ImageIO.write(bufferedImage, "jpg", new File(
									facePicPath));
							System.out.println("人脸图保存路径：" + facePicPath);
						}
					} catch (IOException e2) {
						e2.printStackTrace();
					}
				}

				break;
			}

			case NetSDKLib.EVENT_IVS_FACEDETECT: {		// 目标检测事件 
				DEV_EVENT_FACEDETECT_INFO msg = new DEV_EVENT_FACEDETECT_INFO();
				ToolKits.GetPointerData(pAlarmInfo, msg);
				Calendar cal = Calendar.getInstance();

				count++;
				System.out.println("count:"+count);
				Date date1 = cal.getTime();
				System.out.println("start:"+new SimpleDateFormat("yyyy/MM/dd-HH:mm:ss:SSS").format(date1));
				break;
				//System.out.println("人的运动速度 :" + msg.stuObject.Speed);
			}
				case NetSDKLib.EVENT_IVS_USERMANAGER_FOR_TWSDK:{ // 用户信息上报事件(对应 NET_DEV_EVENT_USERMANAGER_FOR_TWSDK_INFO)
					System.out.println("用户信息上报事件" );
					NET_DEV_EVENT_USERMANAGER_FOR_TWSDK_INFO msg=new NET_DEV_EVENT_USERMANAGER_FOR_TWSDK_INFO();

					ToolKits.GetPointerData(pAlarmInfo, msg);

					NET_TIME_EX stuUTC = msg.stuUTC;

					System.out.println("事件发生的时间:"+stuUTC.toStringTime());

					byte[] szUserID = msg.szUserID;

					byte[] szUserName = msg.szUserName;

					try {
						System.out.println("用户ID:"+new String(szUserID,encode));

						System.out.println("用户名:"+new String(szUserName,encode));

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

					int nType = msg.nType;
					/**
					 * 消息类型 0: 未知 1: 人员新增消息 2: 人员修改消息 3:人员删除消息（删除时仅UserID有效）
					 */
					System.out.println("消息类型:"+nType);

					int nCardListNum = msg.nCardListNum;
					System.out.println("卡片数量:"+nCardListNum);
					BYTE_32[] szCardList = msg.szCardList;

					for(int i=0;i<nCardListNum;i++){
						try {
							System.out.println("卡片[:"+i+"]"+new String(szCardList[i].SN_32,encode));
						} catch (UnsupportedEncodingException e) {
							e.printStackTrace();
						}
					}
					
					int nUserCount = msg.nUserCount;

					System.out.println("用户总数量:"+nUserCount);

					int nFingerCount = msg.nFingerCount;

					System.out.println("信息总数量:"+nFingerCount);

					int nFaceCount = msg.nFaceCount;

					System.out.println("目标总数量:"+nFaceCount);

					int nCardCount = msg.nCardCount;

					System.out.println("卡片总数量:"+nCardCount);
					/**
					 * 用户信息图片信息
					 */
					NET_USERMANAGER_IMAGE_INFO[] stuImageInfo = msg.stuImageInfo;

					int nImageInfoCount = msg.nImageInfoCount;
					System.out.println("用户信息图片信息个数:"+nImageInfoCount);

					for(int i=0;i<nImageInfoCount;i++){

						String picture = path + "/" + System.currentTimeMillis() + "ImageInfo.jpg";
						System.out.println("["+i+"]nOffset:"+stuImageInfo[i].nOffset+"nLength:"+stuImageInfo[i].nLength);
						ToolKits.savePicture(pBuffer,stuImageInfo[i].nOffset,stuImageInfo[i].nLength,picture);
					}

					break;
				}

			default:
				System.out.println("other--");
				break;
			}
			return 0;
		}
	}

	/*
	 * 报警事件回调 -----门禁事件(对应结构体 ALARM_ACCESS_CTL_EVENT_INFO)
	 */
	private static class fAlarmAccessDataCB implements NetSDKLib.fMessCallBack {
		private fAlarmAccessDataCB() {
		}

		private static class fAlarmDataCBHolder {
			private static fAlarmAccessDataCB instance = new fAlarmAccessDataCB();
		}

		public static fAlarmAccessDataCB getInstance() {
			return fAlarmDataCBHolder.instance;
		}

		public boolean invoke(int lCommand, LLong lLoginID, Pointer pStuEvent,
				int dwBufLen, String strDeviceIP, NativeLong nDevicePort,
				Pointer dwUser) {
//			System.out.printf("command = %x\n", lCommand);
			switch (lCommand) {
				case NetSDKLib.NET_ALARM_ACCESS_CTL_EVENT: // 设备请求对方发起对讲事件
				{
					NetSDKLib.ALARM_ACCESS_CTL_EVENT_INFO msg = new NetSDKLib.ALARM_ACCESS_CTL_EVENT_INFO();
					ToolKits.GetPointerData(pStuEvent, msg);
					PrintStruct.print(msg);
					break;
				}
			}

			return true;
		}
	}


	/**
	 * 订阅报警信息
	 * 
	 * @return
	 */
	public void startListen() {
		// 设置报警回调函数
		netsdkApi.CLIENT_SetDVRMessCallBack(fAlarmAccessDataCB.getInstance(),
				null);

		// 订阅报警
		boolean bRet = netsdkApi.CLIENT_StartListenEx(loginHandle);
		if (!bRet) {
			System.err.println("订阅报警失败! LastError = 0x%x\n"
					+ netsdkApi.CLIENT_GetLastError());
		} else {
			System.out.println("订阅报警成功.");
		}
	}

	/**
	 * 取消订阅报警信息
	 * 
	 * @return
	 */
	public void stopListen() {
		// 停止订阅报警
		boolean bRet = netsdkApi.CLIENT_StopListen(loginHandle);
		if (bRet) {
			System.out.println("取消订阅报警信息.");
		}
	}

	/************************************************************************************************
	 * 用户操作：添加/修改/删除/获取/清空
	 ************************************************************************************************/

	/**
	 * 查询所有用户信息
	 */
	public void queryAllUser() {
		String userId = "1011";
		// ////////////////////////////////////////////////////////////////////////////////////////////////
		/**
		 * 入参
		 */
		NET_IN_USERINFO_START_FIND stInFind = new NET_IN_USERINFO_START_FIND();
		// 用户ID, 为空或者不填，查询所有用户
		// System.arraycopy(userId.getBytes(), 0, stInFind.szUserID, 0,
		// userId.getBytes().length);

		/**
		 * 出参
		 */
		NET_OUT_USERINFO_START_FIND stOutFind = new NET_OUT_USERINFO_START_FIND();

		LLong lFindHandle = netsdkApi.CLIENT_StartFindUserInfo(loginHandle,
				stInFind, stOutFind, TIME_OUT);
		if (lFindHandle.longValue() == 0) {
			System.err.println("StartFindUserInfo Failed, " + getErrorCode());
			return;
		}
		System.out.println("符合查询条件的总数:" + stOutFind.nTotalCount);

		if (stOutFind.nTotalCount <= 0) {
			return;
		}
		// ////////////////////////////////////////////////////////////////////////////////////////////////
		int startNo = 0; // 起始序号
		int nFindCount = stOutFind.nCapNum == 0 ? 10 : stOutFind.nCapNum; // 每次查询的个数

		while (true) {
			// 用户信息
			NET_ACCESS_USER_INFO[] userInfos = new NET_ACCESS_USER_INFO[nFindCount];
			for (int i = 0; i < userInfos.length; i++) {
				userInfos[i] = new NET_ACCESS_USER_INFO();
			}

			/**
			 * 入参
			 */
			NET_IN_USERINFO_DO_FIND stInDoFind = new NET_IN_USERINFO_DO_FIND();
			// 起始序号
			stInDoFind.nStartNo = startNo;

			// 本次查询的条数
			stInDoFind.nCount = nFindCount;

			/**
			 * 出参
			 */
			NET_OUT_USERINFO_DO_FIND stOutDoFind = new NET_OUT_USERINFO_DO_FIND();
			// 用户分配内存的个数
			stOutDoFind.nMaxNum = nFindCount;

			stOutDoFind.pstuInfo = new Memory(userInfos[0].size() * nFindCount);
			stOutDoFind.pstuInfo.clear(userInfos[0].size() * nFindCount);

			ToolKits.SetStructArrToPointerData(userInfos, stOutDoFind.pstuInfo);

			if (netsdkApi.CLIENT_DoFindUserInfo(lFindHandle, stInDoFind,
					stOutDoFind, TIME_OUT)) {

				ToolKits.GetPointerDataToStructArr(stOutDoFind.pstuInfo,
						userInfos);

				if (stOutDoFind.nRetNum <= 0) {
					break;
				}

				for (int i = 0; i < stOutDoFind.nRetNum; i++) {
					System.out.println("[" + (startNo + i) + "]用户ID："
							+ new String(userInfos[i].szUserID).trim());

					try {
						System.out
								.println("["
										+ (startNo + i)
										+ "]用户名称："
										+ new String(userInfos[i].szName, "GBK")
												.trim());
					} catch (UnsupportedEncodingException e) {
						e.printStackTrace();
					}

					System.out.println("[" + (startNo + i) + "]密码："
							+ new String(userInfos[i].szPsw).trim());

					for (int j = 0; j < userInfos[i].nRoom; j++) {
						System.out
								.println("["
										+ (startNo + i)
										+ "]用户ID："
										+ new String(
												userInfos[i].szRoomNos[j].szRoomNo)
												.trim());
					}
				}
			}

			if (stOutDoFind.nRetNum < nFindCount) {
				break;
			} else {
				startNo += nFindCount;
			}
		}

		// ////////////////////////////////////////////////////////////////////////////////////////////////
		// 停止查询
		if (lFindHandle.longValue() != 0) {
			netsdkApi.CLIENT_StopFindUserInfo(lFindHandle);
			lFindHandle.setValue(0);
		}
	}

	/**
	 * 用户信息
	 */
	public class USER_INFO {
		public String userId; // 用户ID
		public String userName; // 用户名
		public String passwd; // 密码
		public String roomNo; // 房间号

		public void setUser(String userId, String userName, String passwd,
				String roomNo) {
			this.userId = userId;
			this.userName = userName;
			this.passwd = passwd;
			this.roomNo = roomNo;
		}
	}

	/**
	 * 批量添加/修改用户
	 */
	public void addUser() {
		// 此demo添加两个用户
		USER_INFO[] userInfos = new USER_INFO[2];
		for (int i = 0; i < userInfos.length; i++) {
			userInfos[i] = new USER_INFO();
		}
		userInfos[0].setUser("1011", "张三", "123456", "101");
		userInfos[1].setUser("2022", "李四", "456789", "202");

		// 用户操作类型
		// 添加用户
		int emtype = NET_EM_ACCESS_CTL_USER_SERVICE.NET_EM_ACCESS_CTL_USER_SERVICE_INSERT;

		// 添加的用户个数
		int nMaxNum = userInfos.length;

		/**
		 * 用户信息数组
		 */
		// 先初始化用户信息数组
		NET_ACCESS_USER_INFO[] users = new NET_ACCESS_USER_INFO[nMaxNum];
		// 初始化返回的失败信息数组
		FAIL_CODE[] failCodes = new FAIL_CODE[nMaxNum];

		for (int i = 0; i < nMaxNum; i++) {
			users[i] = new NET_ACCESS_USER_INFO();
			failCodes[i] = new FAIL_CODE();
		}

		/**
		 * 用户信息赋值
		 */
		for (int i = 0; i < nMaxNum; i++) {
			// 用户ID, 用于后面的添加卡、人脸、信息
			System.arraycopy(userInfos[i].userId.getBytes(), 0,
					users[i].szUserID, 0, userInfos[i].userId.getBytes().length);

			// 用户名称
			try {
				System.arraycopy(userInfos[i].userName.getBytes("GBK"), 0,
						users[i].szName, 0,
						userInfos[i].userName.getBytes("GBK").length);
			} catch (UnsupportedEncodingException e) {
				e.printStackTrace();
			}

			// 用户类型
			users[i].emUserType = NET_ENUM_USER_TYPE.NET_ENUM_USER_TYPE_NORMAL;

			// 密码, UserID+密码开门时密码
			System.arraycopy(
					(userInfos[i].userId + userInfos[i].passwd).getBytes(),
					0,
					users[i].szPsw,
					0,
					(userInfos[i].userId + userInfos[i].passwd).getBytes().length);

			// 来宾卡的通行次数
			users[i].nUserTime = 100;

			// 有效门数, 门个数 表示双门控制器
			users[i].nDoorNum = 1;

			// 有权限的门序号, 表示第一个门有权限
			users[i].nDoors[0] = 0;

			// 房间个数
			//users[i].nRoom = 1;

			// 房间号
			//System.arraycopy(userInfos[i].roomNo.getBytes(), 0,
					//users[i].szRoomNos[0].szRoomNo, 0,
					//userInfos[i].roomNo.getBytes().length);

			// 与门数对应
			users[i].nTimeSectionNum = 1;

			// 表示第一个门全天有效
			users[i].nTimeSectionNo[0] = 255;

			// 开始有效期
			users[i].stuValidBeginTime.setTime(2019, 3, 29, 14, 1, 1);

			// 结束有效期
			users[i].stuValidEndTime.setTime(2019, 4, 1, 14, 1, 1);
		}

		// /////////////////////////// 以下固定写法
		// /////////////////////////////////////
		/**
		 * 入参
		 */
		NET_IN_ACCESS_USER_SERVICE_INSERT stIn = new NET_IN_ACCESS_USER_SERVICE_INSERT();
		stIn.nInfoNum = nMaxNum;
		stIn.pUserInfo = new Memory(users[0].size() * nMaxNum); // 申请内存
		stIn.pUserInfo.clear(users[0].size() * nMaxNum);

		// 将用户信息传给指针
		ToolKits.SetStructArrToPointerData(users, stIn.pUserInfo);

		/**
		 * 出参
		 */
		NET_OUT_ACCESS_USER_SERVICE_INSERT stOut = new NET_OUT_ACCESS_USER_SERVICE_INSERT();
		stOut.nMaxRetNum = nMaxNum;
		stOut.pFailCode = new Memory(failCodes[0].size() * nMaxNum); // 申请内存
		stOut.pFailCode.clear(failCodes[0].size() * nMaxNum);

		ToolKits.SetStructArrToPointerData(failCodes, stOut.pFailCode);

		stIn.write();
		stOut.write();
		if (netsdkApi.CLIENT_OperateAccessUserService(loginHandle, emtype,
				stIn.getPointer(), stOut.getPointer(), TIME_OUT)) {
			// 将指针转为具体的信息
			ToolKits.GetPointerDataToStructArr(stOut.pFailCode, failCodes);

			/**
			 * 具体的打印信息
			 */
			for (int i = 0; i < nMaxNum; i++) {
				System.out.println("[" + i + "]添加用户结果："
						+ failCodes[i].nFailCode);
			}
		} else {
			System.err.println("添加用户失败, " + getErrorCode());
		}

		stIn.read();
		stOut.read();
	}

	/**
	 * 批量添加/修改用户（拓展32位字段）
	 */
	public void addUserEx() {
		// 此demo添加两个用户
		USER_INFO[] userInfos = new USER_INFO[2];
		for (int i = 0; i < userInfos.length; i++) {
			userInfos[i] = new USER_INFO();
		}
		userInfos[0].setUser("01234567890123456789012345678901", "张三", "123456", "101");
		userInfos[1].setUser("12345678901234567890123456789012", "李四", "456789", "202");

		// 用户操作类型
		// 添加用户
		int emtype = NET_EM_ACCESS_CTL_USER_SERVICE.NET_EM_ACCESS_CTL_USER_SERVICE_INSERT;

		// 添加的用户个数
		int nMaxNum = userInfos.length;

		/**
		 * 用户信息数组
		 */
		// 先初始化用户信息数组
		NET_ACCESS_USER_INFO[] users = new NET_ACCESS_USER_INFO[nMaxNum];
		// 初始化返回的失败信息数组
		FAIL_CODE[] failCodes = new FAIL_CODE[nMaxNum];

		for (int i = 0; i < nMaxNum; i++) {
			users[i] = new NET_ACCESS_USER_INFO();
			failCodes[i] = new FAIL_CODE();
		}

		/**
		 * 用户信息赋值
		 */
		for (int i = 0; i < nMaxNum; i++) {
			users[i].bUserIDEx = 1;
			// 用户ID, 用于后面的添加卡、人脸、信息
			System.arraycopy(userInfos[i].userId.getBytes(), 0,
					users[i].szUserIDEx, 0, userInfos[i].userId.getBytes().length);

			// 用户名称
			try {
				System.arraycopy(userInfos[i].userName.getBytes("GBK"), 0,
						users[i].szName, 0,
						userInfos[i].userName.getBytes("GBK").length);
			} catch (UnsupportedEncodingException e) {
				e.printStackTrace();
			}

			// 用户类型
			users[i].emUserType = NET_ENUM_USER_TYPE.NET_ENUM_USER_TYPE_NORMAL;

			// 密码, UserID+密码开门时密码
			System.arraycopy(
					(userInfos[i].userId + userInfos[i].passwd).getBytes(),
					0,
					users[i].szPsw,
					0,
					(userInfos[i].userId + userInfos[i].passwd).getBytes().length);

			// 来宾卡的通行次数
			users[i].nUserTime = 100;

			// 有效门数, 门个数 表示双门控制器
			users[i].nDoorNum = 1;

			// 有权限的门序号, 表示第一个门有权限
			users[i].nDoors[0] = 0;

			// 房间个数
			//users[i].nRoom = 1;

			// 房间号
			//System.arraycopy(userInfos[i].roomNo.getBytes(), 0,
			//users[i].szRoomNos[0].szRoomNo, 0,
			//userInfos[i].roomNo.getBytes().length);

			// 与门数对应
			users[i].nTimeSectionNum = 1;

			// 表示第一个门全天有效
			users[i].nTimeSectionNo[0] = 255;

			// 开始有效期
			users[i].stuValidBeginTime.setTime(2019, 3, 29, 14, 1, 1);

			// 结束有效期
			users[i].stuValidEndTime.setTime(2019, 4, 1, 14, 1, 1);
		}

		// /////////////////////////// 以下固定写法
		// /////////////////////////////////////
		/**
		 * 入参
		 */
		NET_IN_ACCESS_USER_SERVICE_INSERT stIn = new NET_IN_ACCESS_USER_SERVICE_INSERT();
		stIn.nInfoNum = nMaxNum;
		stIn.pUserInfo = new Memory(users[0].size() * nMaxNum); // 申请内存
		stIn.pUserInfo.clear(users[0].size() * nMaxNum);

		// 将用户信息传给指针
		ToolKits.SetStructArrToPointerData(users, stIn.pUserInfo);

		/**
		 * 出参
		 */
		NET_OUT_ACCESS_USER_SERVICE_INSERT stOut = new NET_OUT_ACCESS_USER_SERVICE_INSERT();
		stOut.nMaxRetNum = nMaxNum;
		stOut.pFailCode = new Memory(failCodes[0].size() * nMaxNum); // 申请内存
		stOut.pFailCode.clear(failCodes[0].size() * nMaxNum);

		ToolKits.SetStructArrToPointerData(failCodes, stOut.pFailCode);

		stIn.write();
		stOut.write();
		if (netsdkApi.CLIENT_OperateAccessUserService(loginHandle, emtype,
				stIn.getPointer(), stOut.getPointer(), TIME_OUT)) {
			// 将指针转为具体的信息
			ToolKits.GetPointerDataToStructArr(stOut.pFailCode, failCodes);

			/**
			 * 具体的打印信息
			 */
			for (int i = 0; i < nMaxNum; i++) {
				System.out.println("[" + i + "]添加用户结果："
						+ failCodes[i].nFailCode);
			}
		} else {
			System.err.println("添加用户失败, " + getErrorCode());
		}

		stIn.read();
		stOut.read();
	}

	/**
	 * 根据用户ID获取用户信息
	 */
	public void getUser() {
		String[] userIDs = { "1011", "2022" };

		// 获取的用户个数
		int nMaxNum = userIDs.length;

		// /////////////////////////// 以下固定写法
		// /////////////////////////////////////
		// 用户操作类型
		// 获取用户
		int emtype = NET_EM_ACCESS_CTL_USER_SERVICE.NET_EM_ACCESS_CTL_USER_SERVICE_GET;

		/**
		 * 用户信息数组
		 */
		// 先初始化用户信息数组
		NET_ACCESS_USER_INFO[] users = new NET_ACCESS_USER_INFO[nMaxNum];
		// 初始化返回的失败信息数组
		FAIL_CODE[] failCodes = new FAIL_CODE[nMaxNum];

		for (int i = 0; i < nMaxNum; i++) {
			users[i] = new NET_ACCESS_USER_INFO();
			failCodes[i] = new FAIL_CODE();
		}

		/**
		 * 入参
		 */
		NET_IN_ACCESS_USER_SERVICE_GET stIn = new NET_IN_ACCESS_USER_SERVICE_GET();
		// 用户ID个数
		stIn.nUserNum = userIDs.length;

		// 用户ID
		for (int i = 0; i < userIDs.length; i++) {
			System.arraycopy(userIDs[i].getBytes(), 0,
					stIn.szUserIDs[i].szUserID, 0, userIDs[i].getBytes().length);
		}

		/**
		 * 出参
		 */
		NET_OUT_ACCESS_USER_SERVICE_GET stOut = new NET_OUT_ACCESS_USER_SERVICE_GET();
		stOut.nMaxRetNum = nMaxNum;

		stOut.pUserInfo = new Memory(users[0].size() * nMaxNum); // 申请内存
		stOut.pUserInfo.clear(users[0].size() * nMaxNum);

		stOut.pFailCode = new Memory(failCodes[0].size() * nMaxNum); // 申请内存
		stOut.pFailCode.clear(failCodes[0].size() * nMaxNum);

		ToolKits.SetStructArrToPointerData(users, stOut.pUserInfo);
		ToolKits.SetStructArrToPointerData(failCodes, stOut.pFailCode);

		stIn.write();
		stOut.write();
		if (netsdkApi.CLIENT_OperateAccessUserService(loginHandle, emtype,
				stIn.getPointer(), stOut.getPointer(), TIME_OUT)) {
			// 将指针转为具体的信息
			ToolKits.GetPointerDataToStructArr(stOut.pUserInfo, users);
			ToolKits.GetPointerDataToStructArr(stOut.pFailCode, failCodes);

			/**
			 * 打印具体的信息
			 */
			for (int i = 0; i < nMaxNum; i++) {
				try {
					System.out.println("[" + i + "]用户名："
							+ new String(users[i].szName, "GBK").trim());
				} catch (UnsupportedEncodingException e) {
					e.printStackTrace();
				}
				System.out.println("[" + i + "]密码："
						+ new String(users[i].szPsw).trim());
				System.out.println("[" + i + "]查询用户结果："
						+ failCodes[i].nFailCode);
			}
		} else {
			System.err.println("查询用户失败, " + getErrorCode());
		}

		stIn.read();
		stOut.read();
	}

	/**
	 * 删除指定用户ID的用户
	 */
	public void deleteUser() {
		String[] userIDs = { "1011", "2022" };

		// 删除的用户个数
		int nMaxNum = userIDs.length;

		// /////////////////////////// 以下固定写法
		// /////////////////////////////////////
		// 用户操作类型
		// 删除用户
		int emtype = NET_EM_ACCESS_CTL_USER_SERVICE.NET_EM_ACCESS_CTL_USER_SERVICE_REMOVE;

		// 初始化返回的失败信息数组
		FAIL_CODE[] failCodes = new FAIL_CODE[nMaxNum];
		for (int i = 0; i < nMaxNum; i++) {
			failCodes[i] = new FAIL_CODE();
		}

		/**
		 * 入参
		 */
		NET_IN_ACCESS_USER_SERVICE_REMOVE stIn = new NET_IN_ACCESS_USER_SERVICE_REMOVE();
		// 用户ID个数
		stIn.nUserNum = userIDs.length;

		// 用户ID
		for (int i = 0; i < userIDs.length; i++) {
			System.arraycopy(userIDs[i].getBytes(), 0,
					stIn.szUserIDs[i].szUserID, 0, userIDs[i].getBytes().length);
		}

		/**
		 * 出参
		 */
		NET_OUT_ACCESS_USER_SERVICE_REMOVE stOut = new NET_OUT_ACCESS_USER_SERVICE_REMOVE();
		stOut.nMaxRetNum = nMaxNum;

		stOut.pFailCode = new Memory(failCodes[0].size() * nMaxNum); // 申请内存
		stOut.pFailCode.clear(failCodes[0].size() * nMaxNum);

		ToolKits.SetStructArrToPointerData(failCodes, stOut.pFailCode);

		stIn.write();
		stOut.write();
		if (netsdkApi.CLIENT_OperateAccessUserService(loginHandle, emtype,
				stIn.getPointer(), stOut.getPointer(), TIME_OUT)) {
			// 将指针转为具体的信息
			ToolKits.GetPointerDataToStructArr(stOut.pFailCode, failCodes);

			/**
			 * 打印具体的信息
			 */
			for (int i = 0; i < nMaxNum; i++) {
				System.out.println("[" + i + "]删除用户结果："
						+ failCodes[i].nFailCode);
			}
		} else {
			System.err.println("删除用户失败, " + getErrorCode());
		}

		stIn.read();
		stOut.read();
	}

	/**
	 * 清空所有用户
	 */
	public void clearUser() {
		// 用户操作类型
		// 清空用户
		int emtype = NET_EM_ACCESS_CTL_USER_SERVICE.NET_EM_ACCESS_CTL_USER_SERVICE_CLEAR;

		/**
		 * 入参
		 */
		NET_IN_ACCESS_USER_SERVICE_CLEAR stIn = new NET_IN_ACCESS_USER_SERVICE_CLEAR();

		/**
		 * 出参
		 */
		NET_OUT_ACCESS_USER_SERVICE_CLEAR stOut = new NET_OUT_ACCESS_USER_SERVICE_CLEAR();

		stIn.write();
		stOut.write();
		if (netsdkApi.CLIENT_OperateAccessUserService(loginHandle, emtype,
				stIn.getPointer(), stOut.getPointer(), TIME_OUT)) {
			System.out.println("清空用户成功！");
		} else {
			System.err.println("清空用户失败, " + getErrorCode());
		}

		stIn.read();
		stOut.read();
	}

	/************************************************************************************************
	 * 卡操作：添加/修改/删除/获取/清空 一个用户最多添加5张卡
	 ************************************************************************************************/
	/**
	 * 查询所有卡信息
	 */
	public void queryAllCard() {
//		String userId = "1011";
		// ////////////////////////////////////////////////////////////////////////////////////////////////
		/**
		 * 入参
		 */
		NET_IN_CARDINFO_START_FIND stInFind = new NET_IN_CARDINFO_START_FIND();
		// 用户ID, 为空或者不填，查询所有用户的所有卡
//		System.arraycopy(userId.getBytes(), 0, stInFind.szUserID, 0,
//				userId.getBytes().length);

		/**
		 * 出参
		 */
		NET_OUT_CARDINFO_START_FIND stOutFind = new NET_OUT_CARDINFO_START_FIND();

		LLong lFindHandle = netsdkApi.CLIENT_StartFindCardInfo(loginHandle,
				stInFind, stOutFind, TIME_OUT);

		if (lFindHandle.longValue() == 0) {
			return;
		}

		System.out.println("符合查询条件的总数:" + stOutFind.nTotalCount);

		if (stOutFind.nTotalCount <= 0) {
			return;
		}
		// ////////////////////////////////////////////////////////////////////////////////////////////////
		// 起始序号
		int startNo = 0;

		// 每次查询的个数
		int nFindCount = stOutFind.nCapNum == 0 ? 5 : stOutFind.nCapNum;

		while (true) {

			NET_ACCESS_CARD_INFO[] cardInfos = new NET_ACCESS_CARD_INFO[nFindCount];
			for (int i = 0; i < nFindCount; i++) {
				cardInfos[i] = new NET_ACCESS_CARD_INFO();
				cardInfos[i].bUserIDEx = 1;
			}

			/**
			 * 入参
			 */
			NET_IN_CARDINFO_DO_FIND stInDoFind = new NET_IN_CARDINFO_DO_FIND();
			// 起始序号
			stInDoFind.nStartNo = startNo;

			// 本次查询的条数
			stInDoFind.nCount = nFindCount;

			/**
			 * 出参
			 */
			NET_OUT_CARDINFO_DO_FIND stOutDoFind = new NET_OUT_CARDINFO_DO_FIND();
			stOutDoFind.nMaxNum = nFindCount;

			stOutDoFind.pstuInfo = new Memory(cardInfos[0].size() * nFindCount);
			stOutDoFind.pstuInfo.clear(cardInfos[0].size() * nFindCount);

			ToolKits.SetStructArrToPointerData(cardInfos, stOutDoFind.pstuInfo);

			if (netsdkApi.CLIENT_DoFindCardInfo(lFindHandle, stInDoFind,
					stOutDoFind, TIME_OUT)) {
				if (stOutDoFind.nRetNum <= 0) {
					return;
				}

				ToolKits.GetPointerDataToStructArr(stOutDoFind.pstuInfo,
						cardInfos);

				for (int i = 0; i < stOutDoFind.nRetNum; i++) {
					System.out.println("[" + (startNo + i) + "]用户ID："
							+ new String(cardInfos[i].szUserID).trim());
					System.out.println("[" + (startNo + i) + "]卡号："
							+ new String(cardInfos[i].szCardNo).trim());
					System.out.println("[" + (startNo + i) + "]卡类型："
							+ cardInfos[i].emType + "\n");
				}
			}

			if (stOutDoFind.nRetNum < nFindCount) {
				break;
			} else {
				startNo += nFindCount;
			}
		}

		// ////////////////////////////////////////////////////////////////////////////////////////////////
		// 停止查找
		if (lFindHandle.longValue() != 0) {
			netsdkApi.CLIENT_StopFindCardInfo(lFindHandle);
			lFindHandle.setValue(0);
		}
	}

	/**
	 * 卡信息
	 */
	public class CARD_INFO {
		public String userId; // 用户ID
		public String cardNo; // 卡号
		public int emType; // 卡类型

		public void setCard(String userId, String cardNo, int emType) {
			this.userId = userId;
			this.cardNo = cardNo;
			this.emType = emType;
		}
	}

	/**
	 * 根据用户ID添加多张卡 一个用户ID添加多张卡 也可以多个用户ID，分别添加卡
	 */
	public void addCard() {
		CARD_INFO[] cardInfos = new CARD_INFO[4];
		for (int i = 0; i < cardInfos.length; i++) {
			cardInfos[i] = new CARD_INFO();
		}

		cardInfos[0].setCard("1011", "JJDHH122", 0);
		cardInfos[1].setCard("1011", "YYUU122", 0);
		cardInfos[2].setCard("2022", "SSDD122", 0);
		cardInfos[3].setCard("2022", "RRUU555", 0);

		// 添加的卡的最大个数
		int nMaxCount = cardInfos.length;

		// 卡片信息
		NET_ACCESS_CARD_INFO[] cards = new NET_ACCESS_CARD_INFO[nMaxCount];
		for (int i = 0; i < nMaxCount; i++) {
			cards[i] = new NET_ACCESS_CARD_INFO();
		}

		//
		FAIL_CODE[] failCodes = new FAIL_CODE[nMaxCount];
		for (int i = 0; i < nMaxCount; i++) {
			failCodes[i] = new FAIL_CODE();
		}

		/**
		 * 卡信息赋值
		 */
		for (int i = 0; i < nMaxCount; i++) {
			// 卡类型
			cards[i].emType = cardInfos[i].emType; // NET_ACCESSCTLCARD_TYPE;

			// 用户ID
			System.arraycopy(cardInfos[i].userId.getBytes(), 0,
					cards[i].szUserID, 0, cardInfos[i].userId.getBytes().length);

			// 卡号
			System.arraycopy(cardInfos[i].cardNo.getBytes(), 0,
					cards[i].szCardNo, 0, cardInfos[i].cardNo.getBytes().length);
		}

		// 卡操作类型
		// 添加卡
		int emtype = NET_EM_ACCESS_CTL_CARD_SERVICE.NET_EM_ACCESS_CTL_CARD_SERVICE_INSERT;

		/**
		 * 入参
		 */
		NET_IN_ACCESS_CARD_SERVICE_INSERT stIn = new NET_IN_ACCESS_CARD_SERVICE_INSERT();
		stIn.nInfoNum = nMaxCount;
		stIn.pCardInfo = new Memory(cards[0].size() * nMaxCount);
		stIn.pCardInfo.clear(cards[0].size() * nMaxCount);

		ToolKits.SetStructArrToPointerData(cards, stIn.pCardInfo);

		/**
		 * 出参
		 */
		NET_OUT_ACCESS_CARD_SERVICE_INSERT stOut = new NET_OUT_ACCESS_CARD_SERVICE_INSERT();
		stOut.nMaxRetNum = nMaxCount;
		stOut.pFailCode = new Memory(failCodes[0].size() * nMaxCount);
		stOut.pFailCode.clear(failCodes[0].size() * nMaxCount);

		ToolKits.SetStructArrToPointerData(failCodes, stOut.pFailCode);

		stIn.write();
		stOut.write();
		if (netsdkApi.CLIENT_OperateAccessCardService(loginHandle, emtype,
				stIn.getPointer(), stOut.getPointer(), TIME_OUT)) {
			// 将获取到的结果信息转成 failCodes
			ToolKits.GetPointerDataToStructArr(stOut.pFailCode, failCodes);

			// 打印具体信息
			for (int i = 0; i < nMaxCount; i++) {
				System.out.println("[" + i + "]添加卡结果 : "
						+ failCodes[i].nFailCode);
			}
		} else {
			System.err.println("添加卡失败, " + getErrorCode());
		}
		stIn.read();
		stOut.read();
	}

	/**
	 * 修改多张卡, 不能直接修改卡号，只能删除，重新添加，可以修改卡的其他信息
	 */
	public void modifyCard() {
		CARD_INFO[] cardInfos = new CARD_INFO[4];
		for (int i = 0; i < cardInfos.length; i++) {
			cardInfos[i] = new CARD_INFO();
		}

		cardInfos[0].setCard("1011", "JJDHH122", 1);
		cardInfos[1].setCard("1011", "YYUU122", 1);
		cardInfos[2].setCard("2022", "SSDD122", 1);
		cardInfos[3].setCard("2022", "RRUU555", 1);

		// 修改的卡的最大个数
		int nMaxCount = cardInfos.length;

		// 卡片信息
		NET_ACCESS_CARD_INFO[] cards = new NET_ACCESS_CARD_INFO[nMaxCount];
		for (int i = 0; i < nMaxCount; i++) {
			cards[i] = new NET_ACCESS_CARD_INFO();
		}

		//
		FAIL_CODE[] failCodes = new FAIL_CODE[nMaxCount];
		for (int i = 0; i < nMaxCount; i++) {
			failCodes[i] = new FAIL_CODE();
		}

		/**
		 * 卡信息赋值
		 */
		for (int i = 0; i < nMaxCount; i++) {
			// 卡类型
			cards[i].emType = cardInfos[i].emType; // NET_ACCESSCTLCARD_TYPE;

			// 用户ID
			System.arraycopy(cardInfos[i].userId.getBytes(), 0,
					cards[i].szUserID, 0, cardInfos[i].userId.getBytes().length);

			// 卡号
			System.arraycopy(cardInfos[i].cardNo.getBytes(), 0,
					cards[i].szCardNo, 0, cardInfos[i].cardNo.getBytes().length);
		}

		// 卡操作类型
		// 修改卡
		int emtype = NET_EM_ACCESS_CTL_CARD_SERVICE.NET_EM_ACCESS_CTL_CARD_SERVICE_UPDATE;

		/**
		 * 入参
		 */
		NET_IN_ACCESS_CARD_SERVICE_UPDATE stIn = new NET_IN_ACCESS_CARD_SERVICE_UPDATE();
		stIn.nInfoNum = nMaxCount;
		stIn.pCardInfo = new Memory(cards[0].size() * nMaxCount);
		stIn.pCardInfo.clear(cards[0].size() * nMaxCount);

		ToolKits.SetStructArrToPointerData(cards, stIn.pCardInfo);

		/**
		 * 出参
		 */
		NET_OUT_ACCESS_CARD_SERVICE_UPDATE stOut = new NET_OUT_ACCESS_CARD_SERVICE_UPDATE();
		stOut.nMaxRetNum = nMaxCount;
		stOut.pFailCode = new Memory(failCodes[0].size() * nMaxCount);
		stOut.pFailCode.clear(failCodes[0].size() * nMaxCount);

		ToolKits.SetStructArrToPointerData(failCodes, stOut.pFailCode);

		stIn.write();
		stOut.write();
		if (netsdkApi.CLIENT_OperateAccessCardService(loginHandle, emtype,
				stIn.getPointer(), stOut.getPointer(), TIME_OUT)) {
			// 将获取到的结果信息转成 failCodes
			ToolKits.GetPointerDataToStructArr(stOut.pFailCode, failCodes);

			// 打印具体信息
			for (int i = 0; i < nMaxCount; i++) {
				System.out.println("[" + i + "]修改卡结果 : "
						+ failCodes[i].nFailCode);
			}
		} else {
			System.err.println("修改卡失败, " + getErrorCode());
		}
		stIn.read();
		stOut.read();
	}

	/**
	 * 根据卡号获取卡信息
	 */
	public void getCard() {
		String[] cardNOs = { "abc123", "def456", "ghi789", "jkl123" };

		// 修改的卡的最大个数
		int nMaxCount = cardNOs.length;

		// 卡片信息
		NET_ACCESS_CARD_INFO[] cards = new NET_ACCESS_CARD_INFO[nMaxCount];
		for (int i = 0; i < nMaxCount; i++) {
			cards[i] = new NET_ACCESS_CARD_INFO();
		}

		//
		FAIL_CODE[] failCodes = new FAIL_CODE[nMaxCount];
		for (int i = 0; i < nMaxCount; i++) {
			failCodes[i] = new FAIL_CODE();
		}

		// 卡操作类型
		// 获取卡信息
		int emtype = NET_EM_ACCESS_CTL_CARD_SERVICE.NET_EM_ACCESS_CTL_CARD_SERVICE_GET;

		/**
		 * 入参
		 */
		NET_IN_ACCESS_CARD_SERVICE_GET stIn = new NET_IN_ACCESS_CARD_SERVICE_GET();
		// 卡号数量
		stIn.nCardNum = cardNOs.length;

		for (int i = 0; i < cardNOs.length; i++) {
			// 卡号
			System.arraycopy(cardNOs[i].getBytes(), 0,
					stIn.szCardNos[i].szCardNo, 0, cardNOs[i].getBytes().length);
		}

		/**
		 * 出参
		 */
		NET_OUT_ACCESS_CARD_SERVICE_GET stOut = new NET_OUT_ACCESS_CARD_SERVICE_GET();
		stOut.nMaxRetNum = nMaxCount;

		stOut.pCardInfo = new Memory(cards[0].size() * nMaxCount);
		stOut.pCardInfo.clear(cards[0].size() * nMaxCount);

		stOut.pFailCode = new Memory(failCodes[0].size() * nMaxCount);
		stOut.pFailCode.clear(failCodes[0].size() * nMaxCount);

		ToolKits.SetStructArrToPointerData(cards, stOut.pCardInfo);
		ToolKits.SetStructArrToPointerData(failCodes, stOut.pFailCode);

		stIn.write();
		stOut.write();
		if (netsdkApi.CLIENT_OperateAccessCardService(loginHandle, emtype,
				stIn.getPointer(), stOut.getPointer(), TIME_OUT)) {
			// 将获取到的结果信息转成具体的结构体
			ToolKits.GetPointerDataToStructArr(stOut.pCardInfo, cards);
			ToolKits.GetPointerDataToStructArr(stOut.pFailCode, failCodes);

			// 打印具体信息
			for (int i = 0; i < nMaxCount; i++) {
				System.out.println("[" + i + "]用户ID : "
						+ new String(cards[i].szUserID).trim());
				System.out.println("[" + i + "]卡号 : "
						+ new String(cards[i].szCardNo).trim());
				System.out.println("[" + i + "]卡类型 : " + cards[i].emType);
				System.out.println("[" + i + "]查询卡结果 : "
						+ failCodes[i].nFailCode + "\n");
			}
		} else {
			System.err.println("查询卡失败, " + getErrorCode());
		}
		stIn.read();
		stOut.read();
	}

	/**
	 * 根据卡号删除卡信息
	 */
	public void deleteCard() {
		String[] cardNOs = { "JJDHH122", "YYUU122" };

		// 删除的卡的最大个数
		int nMaxCount = cardNOs.length;

		//
		FAIL_CODE[] failCodes = new FAIL_CODE[nMaxCount];
		for (int i = 0; i < nMaxCount; i++) {
			failCodes[i] = new FAIL_CODE();
		}

		// 卡操作类型
		// 删除卡信息
		int emtype = NET_EM_ACCESS_CTL_CARD_SERVICE.NET_EM_ACCESS_CTL_CARD_SERVICE_REMOVE;

		/**
		 * 入参
		 */
		NET_IN_ACCESS_CARD_SERVICE_REMOVE stIn = new NET_IN_ACCESS_CARD_SERVICE_REMOVE();
		// 卡号数量
		stIn.nCardNum = cardNOs.length;

		for (int i = 0; i < cardNOs.length; i++) {
			// 卡号
			System.arraycopy(cardNOs[i].getBytes(), 0,
					stIn.szCardNos[i].szCardNo, 0, cardNOs[i].getBytes().length);
		}

		/**
		 * 出参
		 */
		NET_OUT_ACCESS_CARD_SERVICE_REMOVE stOut = new NET_OUT_ACCESS_CARD_SERVICE_REMOVE();
		stOut.nMaxRetNum = nMaxCount;
		stOut.pFailCode = new Memory(failCodes[0].size() * nMaxCount);
		stOut.pFailCode.clear(failCodes[0].size() * nMaxCount);

		ToolKits.SetStructArrToPointerData(failCodes, stOut.pFailCode);

		stIn.write();
		stOut.write();
		if (netsdkApi.CLIENT_OperateAccessCardService(loginHandle, emtype,
				stIn.getPointer(), stOut.getPointer(), TIME_OUT)) {
			// 将获取到的结果信息转成具体的结构体
			ToolKits.GetPointerDataToStructArr(stOut.pFailCode, failCodes);

			// 打印具体信息
			for (int i = 0; i < nMaxCount; i++) {
				System.out.println("[" + i + "]删除卡结果 : "
						+ failCodes[i].nFailCode);
			}
		} else {
			System.err.println("删除卡失败, " + getErrorCode());
		}
		stIn.read();
		stOut.read();
	}

	/**
	 * 清空卡信息
	 */
	public void clearCard() {
		// 卡操作类型
		// 清空卡信息
		int emtype = NET_EM_ACCESS_CTL_CARD_SERVICE.NET_EM_ACCESS_CTL_CARD_SERVICE_CLEAR;

		/**
		 * 入参
		 */
		NET_IN_ACCESS_CARD_SERVICE_CLEAR stIn = new NET_IN_ACCESS_CARD_SERVICE_CLEAR();

		/**
		 * 出参
		 */
		NET_OUT_ACCESS_CARD_SERVICE_CLEAR stOut = new NET_OUT_ACCESS_CARD_SERVICE_CLEAR();

		stIn.write();
		stOut.write();
		if (netsdkApi.CLIENT_OperateAccessCardService(loginHandle, emtype,
				stIn.getPointer(), stOut.getPointer(), TIME_OUT)) {
			System.out.println("清空卡信息成功!");
		} else {
			System.err.println("清空卡信息失败, " + getErrorCode());
		}
		stIn.read();
		stOut.read();
	}

	/************************************************************************************************
	 * 人脸操作：添加/修改/删除/获取/清空 可以批量添加多个用户的人脸，但是每个用户只能添加一张图片，大小最大200K
	 ************************************************************************************************/
	// 获取图片大小
	public int GetFileSize(String filePath) {
		File f = new File(filePath);
		if (f.exists() && f.isFile()) {
			return (int) f.length();
		} else {
			return 0;
		}
	}

	public byte[] GetFacePhotoData(String file) {
		int fileLen = GetFileSize(file);
		if (fileLen <= 0) {
			return null;
		}

		try {
			File infile = new File(file);
			if (infile.canRead()) {
				FileInputStream in = new FileInputStream(infile);
				byte[] buffer = new byte[fileLen];
				long currFileLen = 0;
				int readLen = 0;
				while (currFileLen < fileLen) {
					readLen = in.read(buffer);
					currFileLen += readLen;
				}

				in.close();
				return buffer;
			} else {
				System.err.println("Failed to open file %s for read!!!\n");
				return null;
			}
		} catch (Exception e) {
			System.err.println("Failed to open file %s for read!!!\n");
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 每个用户的人脸图片信息
	 */
	public class FACE_INFO {
		public String userId; // 用户ID
		public byte[] szFacePhotoData; // 图片数据，目前一个用户ID只支持添加一张

		public void setFace(String userId, byte[] szFacePhotoData) {
			this.userId = userId;
			this.szFacePhotoData = szFacePhotoData;
		}
	}

	/**
	 * 根据用户ID添加人脸， 此demo展示的是添加两个用户的人脸，每个用户仅且只能添加一张人脸
	 * [0]用户ID：123456
	 * [0]用户名称：
	 * [0]密码：
	 * [1]用户ID：85467
	 * [1]用户名称：
	 * [1]密码：
	 * [2]用户ID：7845612
	 * [2]用户名称：
	 * [2]密码：
	 * [3]用户ID：1011
	 * [3]用户名称：寮犱笁
	 * [3]密码：1011123456
	 * [4]用户ID：2022
	 * [4]用户名称：鏉庡洓
	 * [4]密码：2022456789
	 * [5]用户ID：3033
	 * [5]用户名称：3033
	 * [5]密码：3033
	 * [6]用户ID：4044
	 * [6]用户名称：4044
	 * [6]密码：4044
	 * [7]用户ID：5055
	 * [7]用户名称：5055
	 * [7]密码：5055
	 * [8]用户ID：6066
	 * [8]用户名称：6066
	 * [8]密码：6066
	 * [9]用户ID：7077
	 * [9]用户名称：7077
	 * [9]密码：7077
	 * [10]用户ID：8088
	 * [10]用户名称：8088
	 * [10]密码：8088
	 * [11]用户ID：9099
	 * [11]用户名称：9099
	 * [11]密码：9099
	 */
	public boolean addFace() {
		// ////////////////////////// 获取图片数据 ///////////////////////
		String[] szPaths = { "d:/1.jpg", "d:/2.jpg","d:/3.jpg","d:/4.jpg" };

		byte[] buf1 = GetFacePhotoData(szPaths[0]);
		byte[] buf2 = GetFacePhotoData(szPaths[1]);
		byte[] buf3 = GetFacePhotoData(szPaths[2]);
		byte[] buf4 = GetFacePhotoData(szPaths[3]);

		// //////////////////// 将图片数据传入数组FACE_INFO， 用于存储图片数据
		// ////////////////////
		FACE_INFO[] faceInfos = new FACE_INFO[10];
		for (int i = 0; i < faceInfos.length; i++) {
			faceInfos[i] = new FACE_INFO();
		}
		//123456  85467    7845612  1011  2022 3033
		faceInfos[0].setFace("123456", buf1);
		faceInfos[1].setFace("85467", buf2);
		faceInfos[2].setFace("7845612", buf3);
		faceInfos[3].setFace("1011", buf4);
		faceInfos[4].setFace("2022", buf4);
		faceInfos[5].setFace("3033", buf4);
		faceInfos[6].setFace("4044", buf4);
		faceInfos[7].setFace("5055", buf4);
		faceInfos[8].setFace("6066", buf4);
		faceInfos[9].setFace("7077", buf4);
		// ///////////////////////////////////////////////////////////////////////////////////////////
		// 以上是获取人脸图片信息
		// 以下可以固定写法
		// ///////////////////////////////////////////////////////////////////////////////////////////

		// 添加人脸的用户最大个数
		int nMaxCount = faceInfos.length;

		// ////////////////////// 每个用户的人脸信息初始化 ////////////////////////
		NET_ACCESS_FACE_INFO[] faces = new NET_ACCESS_FACE_INFO[nMaxCount];
		for (int i = 0; i < faces.length; i++) {
			faces[i] = new NET_ACCESS_FACE_INFO();

			faces[i].nInFacePhotoLen[0] = 200 * 1024;
			faces[i].pFacePhotos[0].pFacePhoto = new Memory(200 * 1024); // 人脸照片数据,大小不超过200K
			faces[i].pFacePhotos[0].pFacePhoto.clear(200 * 1024);
		}

		// ////////////////////////////// 人脸信息赋值 ///////////////////////////////
		for (int i = 0; i < faces.length; i++) {
			// 用户ID
			System.arraycopy(faceInfos[i].userId.getBytes(), 0,
					faces[i].szUserID, 0, faceInfos[i].userId.getBytes().length);

			// 人脸照片个数
			faces[i].nFacePhoto = 1;

			// 每张照片实际大小
			faces[i].nOutFacePhotoLen[0] = faceInfos[i].szFacePhotoData.length;

			// 图片数据
			faces[i].pFacePhotos[0].pFacePhoto.write(0,
					faceInfos[i].szFacePhotoData, 0,
					faceInfos[i].szFacePhotoData.length);
		}
		// ///////////////////////////////////////////////////////////////////////

		// 初始化
		FAIL_CODE[] failCodes = new FAIL_CODE[nMaxCount];
		for (int i = 0; i < failCodes.length; i++) {
			failCodes[i] = new FAIL_CODE();
		}

		// 人脸操作类型
		// 添加人脸信息
		int emtype = NET_EM_ACCESS_CTL_FACE_SERVICE.NET_EM_ACCESS_CTL_FACE_SERVICE_INSERT;

		/**
		 * 入参
		 */
		NET_IN_ACCESS_FACE_SERVICE_INSERT stIn = new NET_IN_ACCESS_FACE_SERVICE_INSERT();
		stIn.nFaceInfoNum = nMaxCount;
		stIn.pFaceInfo = new Memory(faces[0].size() * nMaxCount);
		stIn.pFaceInfo.clear(faces[0].size() * nMaxCount);

		ToolKits.SetStructArrToPointerData(faces, stIn.pFaceInfo);

		/**
		 * 出参
		 */
		NET_OUT_ACCESS_FACE_SERVICE_INSERT stOut = new NET_OUT_ACCESS_FACE_SERVICE_INSERT();
		stOut.nMaxRetNum = nMaxCount;
		stOut.pFailCode = new Memory(failCodes[0].size() * nMaxCount);
		stOut.pFailCode.clear(failCodes[0].size() * nMaxCount);

		ToolKits.SetStructArrToPointerData(failCodes, stOut.pFailCode);

		stIn.write();
		stOut.write();
		if (netsdkApi.CLIENT_OperateAccessFaceService(loginHandle, emtype,
				stIn.getPointer(), stOut.getPointer(), TIME_OUT)) {
			// 将获取到的结果信息转成具体的结构体
			ToolKits.GetPointerDataToStructArr(stOut.pFailCode, failCodes);

			// 打印具体信息
			for (int i = 0; i < nMaxCount; i++) {
				System.out.println("[" + i + "]添加人脸结果 : "
						+ failCodes[i].nFailCode);
			}
			stIn.read();
			stOut.read();
			return true;
		} else {
			System.err.println("添加人脸失败, " + getErrorCode());
			stIn.read();
			stOut.read();
			return false;
		}

	}

	/**
	 * 修改人脸
	 */
	public void modifyFace() {
		// //////////////////////////获取图片数据 ///////////////////////
		String[] szPaths = { "d:/123.jpg", "d:/girl.jpg" };

		byte[] buf1 = GetFacePhotoData(szPaths[0]);
		byte[] buf2 = GetFacePhotoData(szPaths[1]);

		// //////////////////// 将图片数据传入数组FACE_INFO， 用于存储图片数据
		// ////////////////////
		// new 两个用户
		FACE_INFO[] faceInfos = new FACE_INFO[2];
		for (int i = 0; i < faceInfos.length; i++) {
			faceInfos[i] = new FACE_INFO();
		}

		faceInfos[0].setFace("1011", buf1);
		faceInfos[1].setFace("2022", buf2);

		// ///////////////////////////////////////////////////////////////////////////////////////////
		// 以上是获取人脸图片信息
		// 以下可以固定写法
		// ///////////////////////////////////////////////////////////////////////////////////////////

		// 修改人脸的用户最大个数
		int nMaxCount = faceInfos.length;

		// ////////////////////// 每个用户的人脸信息初始化 ////////////////////////
		NET_ACCESS_FACE_INFO[] faces = new NET_ACCESS_FACE_INFO[nMaxCount];
		for (int i = 0; i < faces.length; i++) {
			faces[i] = new NET_ACCESS_FACE_INFO();

			// 根据每个用户的人脸图片的实际个数申请内存
			faces[i].nInFacePhotoLen[0] = 200 * 1024;
			faces[i].pFacePhotos[0].pFacePhoto = new Memory(200 * 1024); // 人脸照片数据,大小不超过200K
			faces[i].pFacePhotos[0].pFacePhoto.clear(200 * 1024);
		}

		// ////////////////////////////// 人脸信息赋值 ///////////////////////////////
		for (int i = 0; i < faces.length; i++) {
			// 用户ID
			System.arraycopy(faceInfos[i].userId.getBytes(), 0,
					faces[i].szUserID, 0, faceInfos[i].userId.getBytes().length);

			// 人脸照片个数
			faces[i].nFacePhoto = 1;

			// 每张照片实际大小
			faces[i].nOutFacePhotoLen[0] = faceInfos[i].szFacePhotoData.length;
			// 图片数据
			faces[i].pFacePhotos[0].pFacePhoto.write(0,
					faceInfos[i].szFacePhotoData, 0,
					faceInfos[i].szFacePhotoData.length);
		}
		// ///////////////////////////////////////////////////////////////////////

		// 初始化
		FAIL_CODE[] failCodes = new FAIL_CODE[nMaxCount];
		for (int i = 0; i < failCodes.length; i++) {
			failCodes[i] = new FAIL_CODE();
		}

		// 人脸操作类型
		// 修改人脸信息
		int emtype = NET_EM_ACCESS_CTL_FACE_SERVICE.NET_EM_ACCESS_CTL_FACE_SERVICE_UPDATE;

		/**
		 * 入参
		 */
		NET_IN_ACCESS_FACE_SERVICE_UPDATE stIn = new NET_IN_ACCESS_FACE_SERVICE_UPDATE();
		stIn.nFaceInfoNum = nMaxCount;
		stIn.pFaceInfo = new Memory(faces[0].size() * nMaxCount);
		stIn.pFaceInfo.clear(faces[0].size() * nMaxCount);

		ToolKits.SetStructArrToPointerData(faces, stIn.pFaceInfo);

		/**
		 * 出参
		 */
		NET_OUT_ACCESS_FACE_SERVICE_UPDATE stOut = new NET_OUT_ACCESS_FACE_SERVICE_UPDATE();
		stOut.nMaxRetNum = nMaxCount;
		stOut.pFailCode = new Memory(failCodes[0].size() * nMaxCount);
		stOut.pFailCode.clear(failCodes[0].size() * nMaxCount);

		ToolKits.SetStructArrToPointerData(failCodes, stOut.pFailCode);

		stIn.write();
		stOut.write();
		if (netsdkApi.CLIENT_OperateAccessFaceService(loginHandle, emtype,
				stIn.getPointer(), stOut.getPointer(), TIME_OUT)) {
			// 将获取到的结果信息转成具体的结构体
			ToolKits.GetPointerDataToStructArr(stOut.pFailCode, failCodes);

			// 打印具体信息
			for (int i = 0; i < nMaxCount; i++) {
				System.out.println("[" + i + "]修改人脸结果 : "
						+ failCodes[i].nFailCode);
			}
		} else {
			System.err.println("修改人脸失败, " + getErrorCode());
		}

		stIn.read();
		stOut.read();
	}

	/**
	 * 获取人脸信息
	 */
	public void getFace() {
		String[] userIDs = { "1"};//1011

		// 获取人脸的用户最大个数
		int nMaxCount = userIDs.length;

		// ////////////////////// 每个用户的人脸信息初始化 ////////////////////////
		NET_ACCESS_FACE_INFO[] faces = new NET_ACCESS_FACE_INFO[nMaxCount];
		for (int i = 0; i < faces.length; i++) {
			faces[i] = new NET_ACCESS_FACE_INFO();

			// 根据每个用户的人脸图片的实际个数申请内存，最多5张照片

			faces[i].nFacePhoto = 1; // 每个用户图片个数

			// 对每张照片申请内存
			faces[i].nInFacePhotoLen[0] = 200 * 1024;
			faces[i].pFacePhotos[0].pFacePhoto = new Memory(200 * 1024); // 人脸照片数据,大小不超过200K
			faces[i].pFacePhotos[0].pFacePhoto.clear(200 * 1024);

			// 是否使用扩展人脸模板数据
			faces[i].bFaceDataExEnable=0;

			// 人脸特征值个数
			faces[i].nEigenData=1;

			faces[i].nInEigenDataLen[0]=2*1024;

			faces[i].pEigenDatas[0].pEigenData=new Memory(2*1024);// 人脸特征值, 大小不超过2048

			faces[i].pEigenDatas[0].pEigenData.clear(2*1024);

		}

		// 初始化
		FAIL_CODE[] failCodes = new FAIL_CODE[nMaxCount];
		for (int i = 0; i < failCodes.length; i++) {
			failCodes[i] = new FAIL_CODE();
		}

		// 人脸操作类型
		// 获取人脸信息
		int emtype = NET_EM_ACCESS_CTL_FACE_SERVICE.NET_EM_ACCESS_CTL_FACE_SERVICE_GET;

		/**
		 * 入参
		 */
		NET_IN_ACCESS_FACE_SERVICE_GET stIn = new NET_IN_ACCESS_FACE_SERVICE_GET();
		stIn.nUserNum = nMaxCount;
		for (int i = 0; i < nMaxCount; i++) {
			System.arraycopy(userIDs[i].getBytes(), 0,
					stIn.szUserIDs[i].szUserID, 0, userIDs[i].getBytes().length);
		}

		/**
		 * 出参
		 */
		NET_OUT_ACCESS_FACE_SERVICE_GET stOut = new NET_OUT_ACCESS_FACE_SERVICE_GET();
		stOut.nMaxRetNum = nMaxCount;

		stOut.pFaceInfo = new Memory(faces[0].size() * nMaxCount);
		stOut.pFaceInfo.clear(faces[0].size() * nMaxCount);

		stOut.pFailCode = new Memory(failCodes[0].size() * nMaxCount);
		stOut.pFailCode.clear(failCodes[0].size() * nMaxCount);

		ToolKits.SetStructArrToPointerData(faces, stOut.pFaceInfo);
		ToolKits.SetStructArrToPointerData(failCodes, stOut.pFailCode);

		stIn.write();
		stOut.write();
		if (netsdkApi.CLIENT_OperateAccessFaceService(loginHandle, emtype,
				stIn.getPointer(), stOut.getPointer(), TIME_OUT)) {
			// 将获取到的结果信息转成具体的结构体
			ToolKits.GetPointerDataToStructArr(stOut.pFaceInfo, faces);
			ToolKits.GetPointerDataToStructArr(stOut.pFailCode, failCodes);

			File path = new File(".");

			// 打印具体信息
			// nMaxCount 几个用户
			for (int i = 0; i < nMaxCount; i++) {
				System.out.println("[" + i + "]用户ID : "
						+ new String(faces[i].szUserID).trim());

				// 保存查询到的图片
				String savePath = "";
				for (int j = 0; j < faces[i].nFacePhoto; j++) {

					if (faces[i].nFacePhoto == 0
							|| faces[i].pFacePhotos[j].pFacePhoto == null) {
						return;
					}

					savePath = path.getAbsoluteFile().getParent() + "\\/"
							+ getDate() + "_"
							+ new String(faces[i].szUserID).trim() + ".jpg";
					System.out.println("路径：" + savePath);
/*
					System.out.println("每张图片实际的大小：" + faces[i].nOutFacePhotoLen[j]);

					// 人脸图片数据
					byte[] buffer = faces[i].pFacePhotos[j].pFacePhoto
							.getByteArray(0, faces[i].nOutFacePhotoLen[j]);

					ByteArrayInputStream byteInputStream = new ByteArrayInputStream(
							buffer);*/

					ToolKits.savePicture(faces[i].pFacePhotos[j].pFacePhoto,faces[i].nOutFacePhotoLen[j],savePath);
										
					// 人脸特征值个数
					int nEigenData = faces[i].nEigenData;
					System.out.println("nEigenData:"+nEigenData);
					// 每个人脸特征值实际的大小
					int[] nOutEigenDataLen = faces[i].nOutEigenDataLen;

					EIGENDATA[] pEigenDatas
							= faces[i].pEigenDatas;// 人脸特征值, 大小不超过2048

					for(int m=0;m<nEigenData;m++ ){
						Pointer pEigenData
								= pEigenDatas[i].pEigenData;

						System.out.println("nOutEigenDataLen[i]:"+nOutEigenDataLen[i]);

						byte[] buff = new byte[ nOutEigenDataLen[i]];
						pEigenData.read(0, buff, 0, nOutEigenDataLen[i]);

						System.out.println("buffer:"+new String(buff));

					}
				}



				System.out.println("[" + i + "]获取人脸结果 : "
						+ failCodes[i].nFailCode);
			}
		} else {
			System.err.println("获取人脸失败, " + getErrorCode());
		}

		stIn.read();
		stOut.read();
	}

	//win下
	public static void GetString(byte[] buff) {
	String buffer="";

	for (int i=0;i<buff.length;i++){
		buffer+=buff[i];
		}
		System.out.println("buffer:"+buffer);
	}
	/**
	 * 根据用户ID删除人脸
	 */
	public void deleteFace() {
		String[] userIDs = { "1011", "2022" };

		// 删除人脸的用户最大个数
		int nMaxCount = userIDs.length;

		// 初始化
		FAIL_CODE[] failCodes = new FAIL_CODE[nMaxCount];
		for (int i = 0; i < failCodes.length; i++) {
			failCodes[i] = new FAIL_CODE();
		}

		// 人脸操作类型
		// 删除人脸信息
		int emtype = NET_EM_ACCESS_CTL_FACE_SERVICE.NET_EM_ACCESS_CTL_FACE_SERVICE_REMOVE;

		/**
		 * 入参
		 */
		NET_IN_ACCESS_FACE_SERVICE_REMOVE stIn = new NET_IN_ACCESS_FACE_SERVICE_REMOVE();
		stIn.nUserNum = nMaxCount;
		for (int i = 0; i < nMaxCount; i++) {
			System.arraycopy(userIDs[i].getBytes(), 0,
					stIn.szUserIDs[i].szUserID, 0, userIDs[i].getBytes().length);
		}

		/**
		 * 出参
		 */
		NET_OUT_ACCESS_FACE_SERVICE_REMOVE stOut = new NET_OUT_ACCESS_FACE_SERVICE_REMOVE();
		stOut.nMaxRetNum = nMaxCount;

		stOut.pFailCode = new Memory(failCodes[0].size() * nMaxCount);
		stOut.pFailCode.clear(failCodes[0].size() * nMaxCount);

		ToolKits.SetStructArrToPointerData(failCodes, stOut.pFailCode);

		stIn.write();
		stOut.write();
		if (netsdkApi.CLIENT_OperateAccessFaceService(loginHandle, emtype,
				stIn.getPointer(), stOut.getPointer(), TIME_OUT)) {
			// 将获取到的结果信息转成具体的结构体
			ToolKits.GetPointerDataToStructArr(stOut.pFailCode, failCodes);

			// 打印具体信息
			for (int i = 0; i < nMaxCount; i++) {
				System.out.println("[" + i + "]删除人脸结果 : "
						+ failCodes[i].nFailCode);
			}
		} else {
			System.err.println("删除人脸失败, " + getErrorCode());
		}

		stIn.read();
		stOut.read();
	}

	/**
	 * 清空所有人脸
	 */
	public void clearFace() {
		// 人脸操作类型
		// 清空人脸信息
		int emtype = NET_EM_ACCESS_CTL_FACE_SERVICE.NET_EM_ACCESS_CTL_FACE_SERVICE_CLEAR;

		/**
		 * 入参
		 */
		NET_IN_ACCESS_FACE_SERVICE_CLEAR stIn = new NET_IN_ACCESS_FACE_SERVICE_CLEAR();

		/**
		 * 出参
		 */
		NET_OUT_ACCESS_FACE_SERVICE_CLEAR stOut = new NET_OUT_ACCESS_FACE_SERVICE_CLEAR();

		stIn.write();
		stOut.write();
		if (netsdkApi.CLIENT_OperateAccessFaceService(loginHandle, emtype,
				stIn.getPointer(), stOut.getPointer(), TIME_OUT)) {
			System.out.println("清空人脸成功 ！");
		} else {
			System.err.println("清空人脸失败, " + getErrorCode());
		}

		stIn.read();
		stOut.read();
	}

	/************************************************************************************************
	 * 信息操作：添加/修改/删除/获取/清空 一次只能针对一个用户添加/修改/删除信息操作，并只能对应一个信息， 每个用户最多添加3个信息
	 * 
	 * 如果需要给操作一个用户的信息，需要循环操作 例： 接口调用： 用户ID：1011 + 一个信息数据 再次接口调用 用户ID：1011 +
	 * 一个信息数据
	 ************************************************************************************************/
	/**
	 * 根据用户ID添加信息(一个用户ID对应一个信息)
	 */
	public void addFingerprint() {
		String userId = "1011";

		String finger = "xTxpAASFsk3+8hoDh4ky0ghH2oR7hjp658Wp"
				+ "Q4eJQyEQBdoFgIerDuhFuAQGhsr6BvQpguuF804HMjpFaIUjOQ"
				+ "AJyUSGiAwlCEupSGSFnA3gS7nF2IUUVe62SYVXhcSBoJG5iGSGvJqI"
				+ "lZsRkYhksjBNnUmjh4VOEFEpizyGVUnol4oQQohVft6sOQdWh93lzarniBeJK"
				+ "4EANhtCKoqEmuA0C4M+im2+/zPJAzCKrcX5OipCtIpF9g6DqQOth32CAA8bUiiGdbog0wqKWofGYtxwecgQhsZi"
				+ "ONMO3VqH5p7b8kmGiooaSQfF/MEWilKZ+Dgeg4iJuwYQBgyDJ4uEMfg3/kOsi53VB/++RTaLbf74N/uFY4NzPegFyQNfg3Ot6EXawda"
				+ "CO63/fhpAWIS0YehJyoRSg9SR+IfYRFCCbQXnxcrBR4RtTeCJykPKgrU5/rYagr6EvbIOeDhCOoWt5dB/yI"
				+ "dDgd3FB8f4BEGDpf3oR/oDQYImAQfJ+kM+iy5x+HXMRUaJznnQtCrGNoteifk4CkUohZaWyIepBTGEdsLX/9qBHoZO0pD"
				+ "JGog6iybq+Tn3x1yH7vrbco2HN4R+8s//+EIhhbcW18f3RZqGnx4LfhvXO4qvOvlB+0qQhpc9/L5MVlJH878zUyMvjxF2YSIlVRJUamE"
				+ "lNH8nRUGD8niPUp/xI6f28/czRPMPMfH2QvIvQSNEcyNB/zIyRSM/8zXzUvMzYfNFQ/IzUh9CNSf1X//xL0U6MohGebIWlDNWhRZi/xIVgkVP+Hhn"
				+ "9f9RAUWhRi8eafk+QXSytDwtFjGCklxSMTK8pNZYFILYkrkkYmS30qhUEcKqtNswRwKFkq8QQSHHkRBtESNRkfhdEbK9ovslIVKMoYYdMtGdgSM0"
				+ "ERE1cnIOQQTYoLJkIQJ0gJsNFFTugetWEhME5zESEnLokpsbFFS+kYVfVLGbs"
				+ "E4qQTaYgcEOIRPEkfQRJGDhkWsOEmXWoLdpRKKNoA5tRENBoM"
				+ "5GEFEkosISZBLUkKlXIHbdkGRRAQHRoAwLDw4NFwgJChglKxEoKiYaGQcSBDIbIy0pNBQWFVVs";

		// 初始化信息数据
		NET_ACCESS_FINGERPRINT_INFO fingerprint = new NET_ACCESS_FINGERPRINT_INFO();

		/**
		 * 添加信息数据
		 */
		// 用户ID
		System.arraycopy(userId.getBytes(), 0, fingerprint.szUserID, 0,
				userId.getBytes().length);

		// 将字符串转为信息数据
		byte[] fingerPrintBuffer = Base64Util.getDecoder().decode(finger);

		// 单个信息长度
		fingerprint.nPacketLen = fingerPrintBuffer.length;

		// 信息包个数
		fingerprint.nPacketNum = 1;

		// 信息数据
		// 先申请内存
		fingerprint.szFingerPrintInfo = new Memory(fingerPrintBuffer.length);
		fingerprint.szFingerPrintInfo.clear(fingerPrintBuffer.length);

		fingerprint.szFingerPrintInfo.write(0, fingerPrintBuffer, 0,
				fingerPrintBuffer.length);

		// //////////////////////////////////////////////////////////////////////////////////////////

		// 初始化
		FAIL_CODE failCode = new FAIL_CODE();

		// 信息操作类型
		// 添加信息信息
		int emtype = NET_EM_ACCESS_CTL_FINGERPRINT_SERVICE.NET_EM_ACCESS_CTL_FINGERPRINT_SERVICE_INSERT;

		/**
		 * 入参
		 */
		NET_IN_ACCESS_FINGERPRINT_SERVICE_INSERT stIn = new NET_IN_ACCESS_FINGERPRINT_SERVICE_INSERT();
		stIn.nFpNum = 1;

		stIn.pFingerPrintInfo = fingerprint.getPointer();

		/**
		 * 出参
		 */
		NET_OUT_ACCESS_FINGERPRINT_SERVICE_INSERT stOut = new NET_OUT_ACCESS_FINGERPRINT_SERVICE_INSERT();
		stOut.nMaxRetNum = 1;

		stOut.pFailCode = failCode.getPointer();

		stIn.write();
		stOut.write();
		fingerprint.write();
		failCode.write();
		if (netsdkApi.CLIENT_OperateAccessFingerprintService(loginHandle,
				emtype, stIn.getPointer(), stOut.getPointer(), TIME_OUT)) {

			// 打印具体信息
			System.out.println("添加信息结果 : " + failCode.nFailCode);
		} else {
			System.err.println("添加信息失败, " + getErrorCode());
		}

		fingerprint.read();
		failCode.read();
		stIn.read();
		stOut.read();
	}

	/**
	 * 根据用户ID修改信息(一个用户ID对应一个信息)
	 */
	public void modifyFingerprint() {
		String userId = "1011";

		String finger = "xTxpAASFsk3+8hoDh4ky0ghH2oR7hjp658Wp"
				+ "Q4eJQyEQBdoFgIerDuhFuAQGhsr6BvQpguuF804HMjpFaIUjOQ"
				+ "AJyUSGiAwlCEupSGSFnA3gS7nF2IUUVe62SYVXhcSBoJG5iGSGvJqI"
				+ "lZsRkYhksjBNnUmjh4VOEFEpizyGVUnol4oQQohVft6sOQdWh93lzarniBeJK"
				+ "4EANhtCKoqEmuA0C4M+im2+/zPJAzCKrcX5OipCtIpF9g6DqQOth32CAA8bUiiGdbog0wqKWofGYtxwecgQhsZi"
				+ "ONMO3VqH5p7b8kmGiooaSQfF/MEWilKZ+Dgeg4iJuwYQBgyDJ4uEMfg3/kOsi53VB/++RTaLbf74N/uFY4NzPegFyQNfg3Ot6EXawda"
				+ "CO63/fhpAWIS0YehJyoRSg9SR+IfYRFCCbQXnxcrBR4RtTeCJykPKgrU5/rYagr6EvbIOeDhCOoWt5dB/yI"
				+ "dDgd3FB8f4BEGDpf3oR/oDQYImAQfJ+kM+iy5x+HXMRUaJznnQtCrGNoteifk4CkUohZaWyIepBTGEdsLX/9qBHoZO0pD"
				+ "JGog6iybq+Tn3x1yH7vrbco2HN4R+8s//+EIhhbcW18f3RZqGnx4LfhvXO4qvOvlB+0qQhpc9/L5MVlJH878zUyMvjxF2YSIlVRJUamE"
				+ "lNH8nRUGD8niPUp/xI6f28/czRPMPMfH2QvIvQSNEcyNB/zIyRSM/8zXzUvMzYfNFQ/IzUh9CNSf1X//xL0U6MohGebIWlDNWhRZi/xIVgkVP+Hhn"
				+ "9f9RAUWhRi8eafk+QXSytDwtFjGCklxSMTK8pNZYFILYkrkkYmS30qhUEcKqtNswRwKFkq8QQSHHkRBtESNRkfhdEbK9ovslIVKMoYYdMtGdgSM0"
				+ "ERE1cnIOQQTYoLJkIQJ0gJsNFFTugetWEhME5zESEnLokpsbFFS+kYVfVLGbs"
				+ "E4qQTaYgcEOIRPEkfQRJGDhkWsOEmXWoLdpRKKNoA5tRENBoM"
				+ "5GEFEkosISZBLUkKlXIHbdkGRRAQHRoAwLDw4NFwgJChglKxEoKiYaGQcSBDIbIy0pNBQWFVVs";

		// 初始化信息数据
		NET_ACCESS_FINGERPRINT_INFO fingerprint = new NET_ACCESS_FINGERPRINT_INFO();

		/**
		 * 添加信息数据
		 */
		// 用户ID
		System.arraycopy(userId.getBytes(), 0, fingerprint.szUserID, 0,
				userId.getBytes().length);

		// 将字符串转为信息数据
		byte[] fingerPrintBuffer = Base64Util.getDecoder().decode(finger);

		// 单个信息长度
		fingerprint.nPacketLen = fingerPrintBuffer.length;

		// 信息包个数
		fingerprint.nPacketNum = 1;

		// 信息数据
		// 先申请内存
		fingerprint.szFingerPrintInfo = new Memory(fingerPrintBuffer.length);
		fingerprint.szFingerPrintInfo.clear(fingerPrintBuffer.length);

		fingerprint.szFingerPrintInfo.write(0, fingerPrintBuffer, 0,
				fingerPrintBuffer.length);

		// //////////////////////////////////////////////////////////////////////////////////////////
		// //////////////////////////////////////////////////////////////////////////////////////////

		// 初始化
		FAIL_CODE failCode = new FAIL_CODE();

		// 信息操作类型
		// 修改信息信息
		int emtype = NET_EM_ACCESS_CTL_FINGERPRINT_SERVICE.NET_EM_ACCESS_CTL_FINGERPRINT_SERVICE_UPDATE;

		/**
		 * 入参
		 */
		NET_IN_ACCESS_FINGERPRINT_SERVICE_UPDATE stIn = new NET_IN_ACCESS_FINGERPRINT_SERVICE_UPDATE();
		stIn.nFpNum = 1;

		stIn.pFingerPrintInfo = fingerprint.getPointer();

		/**
		 * 出参
		 */
		NET_OUT_ACCESS_FINGERPRINT_SERVICE_UPDATE stOut = new NET_OUT_ACCESS_FINGERPRINT_SERVICE_UPDATE();
		stOut.nMaxRetNum = 1;

		stOut.pFailCode = failCode.getPointer();

		stIn.write();
		stOut.write();
		fingerprint.write();
		failCode.write();
		if (netsdkApi.CLIENT_OperateAccessFingerprintService(loginHandle,
				emtype, stIn.getPointer(), stOut.getPointer(), TIME_OUT)) {

			// 打印具体信息
			System.out.println("修改信息结果 : " + failCode.nFailCode);
		} else {
			System.err.println("修改信息失败, " + getErrorCode());
		}

		fingerprint.read();
		failCode.read();
		stIn.read();
		stOut.read();
	}

	/**
	 * 根据用户ID获取单个信息(一个用户ID对应一个信息)
	 */
	public void getFingerprint() {
		String userId = "1011";

		// 信息操作类型
		// 获取信息信息
		int emtype = NET_EM_ACCESS_CTL_FINGERPRINT_SERVICE.NET_EM_ACCESS_CTL_FINGERPRINT_SERVICE_GET;

		/**
		 * 入参
		 */
		NET_IN_ACCESS_FINGERPRINT_SERVICE_GET stIn = new NET_IN_ACCESS_FINGERPRINT_SERVICE_GET();
		// 用户ID
		System.arraycopy(userId.getBytes(), 0, stIn.szUserID, 0,
				userId.getBytes().length);

		/**
		 * 出参
		 */
		NET_OUT_ACCESS_FINGERPRINT_SERVICE_GET stOut = new NET_OUT_ACCESS_FINGERPRINT_SERVICE_GET();
		// 接受信息数据的缓存的最大长度
		stOut.nMaxFingerDataLength = 1024;

		stOut.pbyFingerData = new Memory(1024);
		stOut.pbyFingerData.clear(1024);

		stIn.write();
		stOut.write();
		if (netsdkApi.CLIENT_OperateAccessFingerprintService(loginHandle,
				emtype, stIn.getPointer(), stOut.getPointer(), TIME_OUT)) {
			// 需要在此处，才能获取到具体信息
			stIn.read();
			stOut.read();

			byte[] buffer = stOut.pbyFingerData.getByteArray(0,
					stOut.nRetFingerDataLength);

			// 将获取到的信息转成没有乱码的字符串
			String figerStr = Base64Util.getEncoder().encodeToString(buffer);

			System.out.println("获取到的信息数据：" + figerStr);
		} else {
			System.err.println("获取信息失败, " + getErrorCode());
		}
	}

	/**
	 * 根据用户ID删除信息
	 */
	public void deleteFingerprint() {
		String userID = "1011";

		// 初始化
		FAIL_CODE failCode = new FAIL_CODE();

		// 信息操作类型
		// 删除信息信息
		int emtype = NET_EM_ACCESS_CTL_FINGERPRINT_SERVICE.NET_EM_ACCESS_CTL_FINGERPRINT_SERVICE_REMOVE;

		/**
		 * 入参
		 */
		NET_IN_ACCESS_FINGERPRINT_SERVICE_REMOVE stIn = new NET_IN_ACCESS_FINGERPRINT_SERVICE_REMOVE();
		stIn.nUserNum = 1;
		System.arraycopy(userID.getBytes(), 0, stIn.szUserIDs[0].szUserID, 0,
				userID.getBytes().length);

		/**
		 * 出参
		 */
		NET_OUT_ACCESS_FINGERPRINT_SERVICE_REMOVE stOut = new NET_OUT_ACCESS_FINGERPRINT_SERVICE_REMOVE();
		stOut.nMaxRetNum = 1;

		stOut.pFailCode = failCode.getPointer();

		stIn.write();
		stOut.write();
		if (netsdkApi.CLIENT_OperateAccessFingerprintService(loginHandle,
				emtype, stIn.getPointer(), stOut.getPointer(), TIME_OUT)) {

			// 打印具体信息
			System.out.println("删除信息结果 : " + failCode.nFailCode);

		} else {
			System.err.println("删除信息失败, " + getErrorCode());
		}

		stIn.read();
		stOut.read();
	}

	/**
	 * 清空所有信息
	 */
	public void clearFingerprint() {
		// 信息操作类型
		// 清空信息信息
		int emtype = NET_EM_ACCESS_CTL_FINGERPRINT_SERVICE.NET_EM_ACCESS_CTL_FINGERPRINT_SERVICE_CLEAR;

		/**
		 * 入参
		 */
		NET_IN_ACCESS_FINGERPRINT_SERVICE_CLEAR stIn = new NET_IN_ACCESS_FINGERPRINT_SERVICE_CLEAR();

		/**
		 * 出参
		 */
		NET_OUT_ACCESS_FINGERPRINT_SERVICE_CLEAR stOut = new NET_OUT_ACCESS_FINGERPRINT_SERVICE_CLEAR();

		stIn.write();
		stOut.write();
		if (netsdkApi.CLIENT_OperateAccessFingerprintService(loginHandle,
				emtype, stIn.getPointer(), stOut.getPointer(), TIME_OUT)) {
			System.out.println("清空信息成功 ！");
		} else {
			System.err.println("清空信息失败, " + getErrorCode());
		}

		stIn.read();
		stOut.read();
	}
	
    /**
     * 设置对讲状态
     */   
    public void setThirdCallStatus()
    {
    	// 入参
    	NET_IN_VTP_THIRDCALL_STATUS stIn = new NET_IN_VTP_THIRDCALL_STATUS();
    	stIn.emCallStatus = 2;
    	// 出参
    	NET_OUT_VTP_THIRDCALL_STATUS stOut = new NET_OUT_VTP_THIRDCALL_STATUS();
    	
    	stIn.write();
    	stOut.write();
    	boolean bRet = netsdkApi.CLIENT_ControlDeviceEx(loginHandle, NetSDKLib.CtrlType.CTRLTYPE_CTRL_SET_THIRD_CALLSTATUS, stIn.getPointer(), stOut.getPointer(), 5000);
    	if (!bRet) {
    		System.err.println("Failed to setThirdCallStatus, last error " + String.format("[0x%x]", netsdkApi.CLIENT_GetLastError()));
    	}
    	else {
    		System.out.println("Seccessed to setThirdCallStatus.");
    	}
    	stIn.read();
    	stOut.read();
    }
	// 编码格式
	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";
		}
	}
    //向视频输出口投放视频和图片文件
    public void setDelivery()
    {
    	NET_CTRL_DELIVERY_FILE stuInfo = new NET_CTRL_DELIVERY_FILE();
    	stuInfo.nPort = 0;
    	stuInfo.emPlayMode = 2;
//    	stuInfo.stuStartPlayTime.dwYear = 2024;
//    	stuInfo.stuStartPlayTime.dwMonth = 01;
//    	stuInfo.stuStartPlayTime.dwDay = 01;
//    	stuInfo.stuStartPlayTime.dwHour = 0;
//    	stuInfo.stuStartPlayTime.dwMinute = 0;
//    	stuInfo.stuStartPlayTime.dwSecond = 0;
//
//    	stuInfo.stuStopPlayTime.dwYear = 2025;
//    	stuInfo.stuStopPlayTime.dwMonth = 01;
//    	stuInfo.stuStopPlayTime.dwDay = 01;
//    	stuInfo.stuStopPlayTime.dwHour = 0;
//    	stuInfo.stuStopPlayTime.dwMinute = 0;
//    	stuInfo.stuStopPlayTime.dwSecond = 0;

    	stuInfo.nFileCountEx = 1;
    	stuInfo.nNumber = 1;//序号
		stuInfo.bEnable = true;//播放使能

    	stuInfo.stuFileInfoEx[0].emFileType = 1; //视频
    	stuInfo.stuFileInfoEx[0].nImageSustain = 5;
    	stuInfo.emOperateType = 1; //1替换 2新增 3删除 4清空


		for(int i = 0 ;i < 48;i++){
			stuInfo.stuTimeSection.stuTimeSection[i].bEnable = 1;//使能
			stuInfo.stuTimeSection.stuTimeSection[i].iBeginHour = 0;
			stuInfo.stuTimeSection.stuTimeSection[i].iBeginMin = 0;
			stuInfo.stuTimeSection.stuTimeSection[i].iBeginSec = 0;
			stuInfo.stuTimeSection.stuTimeSection[i].iEndHour = 23;
			stuInfo.stuTimeSection.stuTimeSection[i].iEndMin = 59;
			stuInfo.stuTimeSection.stuTimeSection[i].iEndSec = 59;
		}


		try{
			byte[] szName = "33".getBytes(encode);
			System.arraycopy(szName, 0, stuInfo.szName, 0, szName.length);
		}catch (Exception e){

		}
    	String FileURL = "/PublishFilePath/01.dav"; //直接配置视频路径

    	ToolKits.ByteArrZero( stuInfo.stuFileInfoEx[0].szFileURL);//赋值前，可先清空，要赋值的byte[]; 若byte[]本身就没有值，可不进行这不。


		try {
			System.arraycopy(FileURL.getBytes(encode), 0, stuInfo.stuFileInfoEx[0].szFileURL, 0,
					FileURL.getBytes(encode).length);
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}


		// 文件所属的模式, 参考 @LINK EM_PLAY_WITH_MODE
		stuInfo.stuFileInfoEx[0].emPlayWithMode = 2;
//
//		stuInfo.stuFileInfo[1].emFileType = 2;
//		stuInfo.stuFileInfo[1].nImageSustain = 3;
//
//    	String FileURL2 = "/mnt/appdata1/AdPicture/大华宣传片正式发布版1024_12s_divx.dav";
//		System.arraycopy(FileURL2.getBytes(), 0, stuInfo.stuFileInfo[1].szFileURL, 0,
//				FileURL2.getBytes().length);
//		// 文件所属的模式, 参考 @LINK EM_PLAY_WITH_MODE
//		stuInfo.stuFileInfo[1].emPlayWithMode = 2;
//
//
//		stuInfo.stuFileInfo[2].emFileType = 2;
//		stuInfo.stuFileInfo[2].nImageSustain = 5;
//		String FileURL3 = "/mnt/appdata1/AdPicture/7.png";
//		System.arraycopy(FileURL3.getBytes(), 0, stuInfo.stuFileInfo[2].szFileURL, 0,
//			FileURL3.getBytes().length);
//		// 文件所属的模式, 参考 @LINK EM_PLAY_WITH_MODE
//		stuInfo.stuFileInfo[2].emPlayWithMode = 2;
//
		stuInfo.write();

		int emType = NetSDKLib.CtrlType.CTRLTYPE_CTRL_DELIVERY_FILE;
		boolean bRet = netsdkApi.CLIENT_ControlDevice(loginHandle, emType,
				stuInfo.getPointer(), 3000);
		
		stuInfo.read();

		if (bRet) {
			System.out.println("SetParkInfo Succeed!");
		} else {
			System.err.printf("SetParkInfo Failed! %x\n",
					netsdkApi.CLIENT_GetLastError());
		}
    }
    
	// 门禁事件配置
	public void AccessConfig() {
		// 获取
		String szCommand = NetSDKLib.CFG_CMD_ACCESS_EVENT;
		int nChn = 0; // 通道
		CFG_ACCESS_EVENT_INFO access = new CFG_ACCESS_EVENT_INFO(); // m_stDeviceInfo.byChanNum为设备通道数

		if (ToolKits.GetDevConfig(loginHandle, nChn, szCommand, access)) {
			System.out.println("门禁通道名称:"
					+ new String(access.szChannelName).trim());
			System.out.println("首卡使能:" + access.stuFirstEnterInfo.bEnable); // 0-false;
																			// 1-true
			System.out.println("首卡权限验证通过后的门禁状态:"
					+ access.stuFirstEnterInfo.emStatus); // 状态参考枚举
															// CFG_ACCESS_FIRSTENTER_STATUS
			System.out.println("需要首卡验证的时间段, 值为通道号:"
					+ access.stuFirstEnterInfo.nTimeIndex);
			
			System.out.println(" 当前门采集状态:" + access.emReadCardState);
		}

		// 设置
//		access.emReadCardState = EM_CFG_CARD_STATE.EM_CFG_CARD_STATE_SWIPE;	 // 门禁刷卡
		access.emReadCardState = EM_CFG_CARD_STATE.EM_CFG_CARD_STATE_COLLECTION;	 // 门禁采集卡
//		access.emReadCardState = EM_CFG_CARD_STATE.EM_CFG_CARD_STATE_UNKNOWN;	// 退出读卡状态

		boolean bRet = ToolKits.SetDevConfig(loginHandle, nChn, szCommand,
				access);
		if (bRet) {
			System.out.println("Set Succeed!");
		}
	}
	
	/**
	 * 根据用户ID获取人脸特征值
	 */
	public void getFaceEigenData() {
		String[] userIDs = {"232614"};
		// 获取人脸的用户最大个数
		int nMaxCount = userIDs.length;
		// 每个用户的人脸信息初始化 
		NET_ACCESS_FACE_INFO[] faces = new NET_ACCESS_FACE_INFO[nMaxCount];
		for (int i = 0; i < faces.length; i++) {
			faces[i] = new NET_ACCESS_FACE_INFO();
			
			// 根据每个用户的人脸图片的实际个数申请内存，最多5张照片
			faces[i].nFacePhoto = 0; // 每个用户图片个数
			// 对每张照片申请内存
			faces[i].nInFacePhotoLen[0] = 200 * 1024;
			faces[i].pFacePhotos[0].pFacePhoto = new Memory(200 * 1024); // 人脸照片数据,大小不超过200K
			faces[i].pFacePhotos[0].pFacePhoto.clear(200 * 1024);

			// 是否使用扩展人脸模板数据
			faces[i].bFaceDataExEnable=0;

			// 根据每个用户的人脸特征值的实际个数申请内存，最多5个
			// 人脸特征值个数
			faces[i].nEigenData=1;
			faces[i].nInEigenDataLen[0]=2*1024;
			faces[i].pEigenDatas[0].pEigenData=new Memory(2*1024);// 人脸特征值, 大小不超过2048
			faces[i].pEigenDatas[0].pEigenData.clear(2*1024);
		}
		// 初始化
		FAIL_CODE[] failCodes = new FAIL_CODE[nMaxCount];
		for (int i = 0; i < failCodes.length; i++) {
			failCodes[i] = new FAIL_CODE();
		}
		// 人脸操作类型
		int emtype = NET_EM_ACCESS_CTL_FACE_SERVICE.NET_EM_ACCESS_CTL_FACE_SERVICE_GET;
		/**
		 * 入参
		 */
		NET_IN_ACCESS_FACE_SERVICE_GET stIn = new NET_IN_ACCESS_FACE_SERVICE_GET();
		stIn.nUserNum = nMaxCount;
		for (int i = 0; i < nMaxCount; i++) {
			System.arraycopy(userIDs[i].getBytes(), 0,stIn.szUserIDs[i].szUserID, 0, userIDs[i].getBytes().length);
		}
		/**
		 * 出参
		 */
		NET_OUT_ACCESS_FACE_SERVICE_GET stOut = new NET_OUT_ACCESS_FACE_SERVICE_GET();
		stOut.nMaxRetNum = nMaxCount;

		stOut.pFaceInfo = new Memory(faces[0].size() * nMaxCount);
		stOut.pFaceInfo.clear(faces[0].size() * nMaxCount);

		stOut.pFailCode = new Memory(failCodes[0].size() * nMaxCount);
		stOut.pFailCode.clear(failCodes[0].size() * nMaxCount);

		ToolKits.SetStructArrToPointerData(faces, stOut.pFaceInfo);
		ToolKits.SetStructArrToPointerData(failCodes, stOut.pFailCode);

		stIn.write();
		stOut.write();
		if (netsdkApi.CLIENT_OperateAccessFaceService(loginHandle, emtype,stIn.getPointer(), stOut.getPointer(), TIME_OUT)) {
			stIn.read();
			stOut.read();	
			// 将获取到的结果信息转成具体的结构体
			ToolKits.GetPointerDataToStructArr(stOut.pFaceInfo, faces);
			ToolKits.GetPointerDataToStructArr(stOut.pFailCode, failCodes);

			// nMaxCount 几个用户
			for (int i = 0; i < nMaxCount; i++) {
				System.out.println("[" + i + "]用户ID : "+ new String(faces[i].szUserID).trim());				
				// 人脸特征值个数
				int nEigenData = faces[i].nEigenData;
				System.out.println("nEigenData:"+nEigenData);
				// 每个人脸特征值实际的大小
				int[] nOutEigenDataLen = faces[i].nOutEigenDataLen;
				EIGENDATA[] pEigenDatas = faces[i].pEigenDatas;// 人脸特征值, 大小不超过2048
				for(int m=0;m<nEigenData;m++ ){
					Pointer pEigenData= pEigenDatas[i].pEigenData;
					System.out.println("nOutEigenDataLen[i]:"+nOutEigenDataLen[i]);
					byte[] buff = new byte[ nOutEigenDataLen[i]];
					pEigenData.read(0, buff, 0, nOutEigenDataLen[i]);	
					
					buff1 = buff;//实际使用赋值
					GetString(buff);//打印效果
					
				}
				System.out.println("[" + i + "]获取人脸特征结果 : "+ failCodes[i].nFailCode);
			}
		} else {
			System.err.println("获取人脸特征失败, " + getErrorCode());
		}
	}

	byte[] buff1;//特征值存储
	/**
	 * 根据用户ID添加人脸特征值
	 */
	public void addFaceEigenData() {
		String[] userIDs = {"5"};
		//////////////////////////// 获取特征值数据 ///////////////////////		

		// 添加人脸的用户最大个数
		int nMaxCount = userIDs.length;

		// ////////////////////// 每个用户的人脸信息初始化 ////////////////////////
		NET_ACCESS_FACE_INFO[] faces = new NET_ACCESS_FACE_INFO[nMaxCount];
		for (int i = 0; i < faces.length; i++) {
			faces[i] = new NET_ACCESS_FACE_INFO();
			// 根据每个用户的人脸图片的实际个数申请内存，最多5张照片
			faces[i].nFacePhoto = 0; // 每个用户图片个数
			//faces[i].nInFacePhotoLen[0] = 200 * 1024;
			//faces[i].pFacePhotos[0].pFacePhoto = new Memory(200 * 1024); // 人脸照片数据,大小不超过200K
			//faces[i].pFacePhotos[0].pFacePhoto.clear(200 * 1024);
			
			// 是否使用扩展人脸模板数据
			faces[i].bFaceDataExEnable=0;
			
			//人脸模板数据
			faces[i].nFaceData = 0; // 脸模板数据个数,最大20
			//faces[i].nMaxFaceDataLen[0] = 2 * 1024;
			//faces[i].pFaceDataEx[0].pFaceDataEx = new Memory(2 * 1024); // 人脸模板数据扩展字段
			//faces[i].pFaceDataEx[0].pFaceDataEx.clear(2 * 1024);			

			// 根据每个用户的人脸特征值的实际个数申请内存，最多5个
			// 人脸特征值个数
			faces[i].nEigenData=1;
			faces[i].nInEigenDataLen[0]=2*1024;
			faces[i].pEigenDatas[0].pEigenData=new Memory(2*1024);// 人脸特征值, 大小不超过2048
			faces[i].pEigenDatas[0].pEigenData.clear(2*1024);
		}

		// ////////////////////////////// 人脸特征值信息赋值 ///////////////////////////////
		for (int i = 0; i < faces.length; i++) {
			// 用户ID
			System.arraycopy(userIDs[i].getBytes(), 0, faces[i].szUserID, 0,
					userIDs[i].getBytes().length);
			// 特征值字节数组
			byte[] eigenData= buff1;

			// 人脸特征值个数
			faces[i].nEigenData = 1;
			
			// 人脸特征值实际大小0
			faces[i].nOutEigenDataLen[0] = eigenData.length;
			System.out.println("人脸特征值实际大小:"+faces[i].nOutEigenDataLen[0]);
			// 人脸特征值数据
			faces[i].pEigenDatas[0].pEigenData.write(0, eigenData, 0,eigenData.length);
			
			//特征值通过人脸模板数据字段下发
			//faces[i].bFaceDataExEnable = 1;
			//faces[i].nFaceData = 1; // 脸模板数据个数,最大20
			//faces[i].nRetFaceDataLen[0] = eigenData.length;
			//System.out.println("人脸特征值实际大小:"+faces[i].nRetFaceDataLen[0]);
			//faces[i].pFaceDataEx[0].pFaceDataEx.write(0, eigenData, 0,eigenData.length);	
			
		}
		// ///////////////////////////////////////////////////////////////////////

		// 初始化
		FAIL_CODE[] failCodes = new FAIL_CODE[nMaxCount];
		for (int i = 0; i < failCodes.length; i++) {
			failCodes[i] = new FAIL_CODE();
		}

		// 人脸操作类型
		// 添加人脸信息
		int emtype = NET_EM_ACCESS_CTL_FACE_SERVICE.NET_EM_ACCESS_CTL_FACE_SERVICE_INSERT;

		/**
		 * 入参
		 */
		NET_IN_ACCESS_FACE_SERVICE_INSERT stIn = new NET_IN_ACCESS_FACE_SERVICE_INSERT();
		stIn.nFaceInfoNum = nMaxCount;
		stIn.pFaceInfo = new Memory(faces[0].size() * nMaxCount);
		stIn.pFaceInfo.clear(faces[0].size() * nMaxCount);

		ToolKits.SetStructArrToPointerData(faces, stIn.pFaceInfo);

		/**
		 * 出参
		 */
		NET_OUT_ACCESS_FACE_SERVICE_INSERT stOut = new NET_OUT_ACCESS_FACE_SERVICE_INSERT();
		stOut.nMaxRetNum = nMaxCount;
		stOut.pFailCode = new Memory(failCodes[0].size() * nMaxCount);
		stOut.pFailCode.clear(failCodes[0].size() * nMaxCount);

		ToolKits.SetStructArrToPointerData(failCodes, stOut.pFailCode);

		stIn.write();
		stOut.write();
		if (netsdkApi.CLIENT_OperateAccessFaceService(loginHandle, emtype, stIn.getPointer(), stOut.getPointer(),
				TIME_OUT)) {	
			stOut.read();
			// 将获取到的结果信息转成具体的结构体
			ToolKits.GetPointerDataToStructArr(stOut.pFailCode, failCodes);

			// 打印具体信息
			for (int i = 0; i < nMaxCount; i++) {
				System.out.println("[" + i + "]添加人脸特征值结果 : " + failCodes[i].nFailCode);
			}

		} else {
			System.err.println("添加人脸特征值失败, " + getErrorCode());
		}
	}

	public void RunTest() {
		System.out.println("Run Test");
		CaseMenu menu = new CaseMenu();

		menu.addItem(new CaseMenu.Item(this, "智能订阅事件", "realLoadPicture"));
		menu.addItem(new CaseMenu.Item(this, "取消智能订阅事件", "stopRealLoadPicture"));

		menu.addItem(new CaseMenu.Item(this, "订阅报警事件", "startListen"));
		menu.addItem(new CaseMenu.Item(this, "取消报警事件", "stopListen"));
		menu.addItem(new CaseMenu.Item(this, "门禁事件配置", "AccessConfig"));

		menu.addItem(new CaseMenu.Item(this, "查询所有用户信息", "queryAllUser"));

		menu.addItem(new CaseMenu.Item(this, "添加用户", "addUser"));
		menu.addItem(new CaseMenu.Item(this, "根据用户ID查询用户信息", "getUser"));
		menu.addItem(new CaseMenu.Item(this, "删除指定用户ID的用户", "deleteUser"));
		menu.addItem(new CaseMenu.Item(this, "清空所有用户", "clearUser"));

		menu.addItem(new CaseMenu.Item(this, "根据用户ID查询所有卡", "queryAllCard"));

		menu.addItem(new CaseMenu.Item(this, "根据用户ID添加多张卡", "addCard"));
		menu.addItem(new CaseMenu.Item(this, "根据用户ID修改多张卡", "modifyCard"));
		menu.addItem(new CaseMenu.Item(this, "根据卡号获取卡信息", "getCard"));
		menu.addItem(new CaseMenu.Item(this, "根据卡号删除卡", "deleteCard"));
		menu.addItem(new CaseMenu.Item(this, "清空卡信息", "clearCard"));

		menu.addItem(new CaseMenu.Item(this, "根据用户ID添加人脸", "addFace"));
		menu.addItem(new CaseMenu.Item(this, "根据用户ID修改人脸", "modifyFace"));
		menu.addItem(new CaseMenu.Item(this, "根据用户ID获取人脸", "getFace"));
		menu.addItem(new CaseMenu.Item(this, "根据用户ID删除人脸", "deleteFace"));
		menu.addItem(new CaseMenu.Item(this, "清空所有人脸", "clearFace"));

		menu.addItem(new CaseMenu.Item(this, "根据用户ID添加信息", "addFingerprint"));
		menu.addItem(new CaseMenu.Item(this, "根据用户ID修改信息", "modifyFingerprint"));
		menu.addItem(new CaseMenu.Item(this, "根据用户ID获取单个信息", "getFingerprint"));
		menu.addItem(new CaseMenu.Item(this, "根据用户ID删除信息", "deleteFingerprint"));
		menu.addItem(new CaseMenu.Item(this, "清空所有信息", "clearFingerprint"));
		menu.addItem(new CaseMenu.Item(this, "设置对讲状态", "setThirdCallStatus"));
		
		menu.addItem(new CaseMenu.Item(this, "設置投放的文件类型", "setDelivery"));
		
		menu.addItem(new CaseMenu.Item(this, "根据用户ID获取人脸特征值", "getFaceEigenData"));
		menu.addItem(new CaseMenu.Item(this, "根据用户ID仅添加人脸特征值", "addFaceEigenData"));
		
		menu.run();
	}

	public void for1000(){
			for(int i=0;i<10000;i++){
				boolean b
						= addFace();
				if(b){
					System.out.println("add "+b);


				}else {
					System.err.println("add "+b);
				}
				clearFace();
			}
	}

	/**
	 [0]用户ID：123456
	 [0]用户名称：
	 [0]密码：
	 [1]用户ID：85467
	 [1]用户名称：
	 [1]密码：
	 [2]用户ID：7845612
	 [2]用户名称：
	 [2]密码：
	 [3]用户ID：1011
	 [3]用户名称：寮犱笁
	 [3]密码：1011123456
	 [4]用户ID：2022
	 [4]用户名称：鏉庡洓
	 [4]密码：2022456789
	 [5]用户ID：3033
	 [5]用户名称：3033
	 [5]密码：3033
	 [6]用户ID：4044
	 [6]用户名称：4044
	 [6]密码：4044
	 [7]用户ID：5055
	 [7]用户名称：5055
	 [7]密码：5055
	 [8]用户ID：6066
	 [8]用户名称：6066
	 [8]密码：6066
	 [9]用户ID：7077
	 [9]用户名称：7077
	 [9]密码：7077
	 [10]用户ID：8088
	 [10]用户名称：8088
	 [10]密码：8088
	 [11]用户ID：9099
	 [11]用户名称：9099
	 [11]密码：9099
	 * @param args
	 */
	public static void main(String[] args) {
		AccessNew demo = new AccessNew();

		demo.InitTest();
		demo.RunTest();
	//	demo.for1000();
		demo.EndTest();
	}
}