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();
|
}
|
}
|
