package com.netsdk.demo.customize;

import java.io.File;
import java.util.Arrays;
import java.util.Scanner;

import com.netsdk.demo.util.CaseMenu;
import com.netsdk.lib.NetSDKLib;
import com.netsdk.lib.NetSDKLib.LLong;
import com.netsdk.lib.NetSDKLib.NET_IN_ATTACH_STATE;
import com.netsdk.lib.NetSDKLib.NET_OUT_ATTACH_STATE;
import com.netsdk.lib.NetSDKLib.NET_OUT_BURN_GET_STATE;
import com.netsdk.lib.ToolKits;
import com.netsdk.lib.NetSDKLib.*;
import com.sun.jna.Memory;
import com.sun.jna.Pointer;
import com.sun.jna.ptr.IntByReference;

// 刻录
public class Burner {
	static NetSDKLib netsdkApi 	= NetSDKLib.NETSDK_INSTANCE;
	static NetSDKLib configApi 	= NetSDKLib.CONFIG_INSTANCE;
	
	////////////////////////////////////////////////////////////////
	String m_strIp 			="172.10.1.240";// "172.11.1.17";
	int    m_nPort 			= 37777;
	String m_strUser 		= "admin";
	String m_strPassword 	= "admin123";//"admin123";
	////////////////////////////////////////////////////////////////
	private String burnerName = "/dev/sg1";
	private NetSDKLib.NET_DEVICEINFO_Ex deviceinfo = new NetSDKLib.NET_DEVICEINFO_Ex();
	private static LLong loginHandle = new LLong(0);   //登陆句柄
	private static LLong lBurnSession = new LLong(0);
	private static LLong lAttachBurnStateHandle = new LLong(0);
	
	private volatile static boolean m_bNeetStop = false;   //附件刻录下载完成标志
	
	// 设备断线回调: 通过 CLIENT_Init 设置该回调函数，当设备出现断线时，SDK会调用该函数
	public static 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 static 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 static fDisConnectCB  	m_DisConnectCB   = new fDisConnectCB();
	private static HaveReConnect haveReConnect = new HaveReConnect(); 
	
	public void EndTest()
	{
		System.out.println("End Test");
		if( loginHandle.longValue() != 0)
		{
			netsdkApi.CLIENT_Logout(loginHandle);
			StopBurn();
		}
		System.out.println("See You...");
		
		netsdkApi.CLIENT_Cleanup();
		System.exit(0);
	}

	public void InitTest()
	{				
		// 初始化SDK库， 在启动工程的时候调用，只需要调用一次即可，属于初始化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(".");			
		String logPath = path.getAbsoluteFile().getParent() + "\\sdk_log\\" + System.currentTimeMillis() + ".log";
			
		setLog.bSetFilePath = 1;
		System.arraycopy(logPath.getBytes(), 0, setLog.szLogFilePath, 0, logPath.getBytes().length);
	
		setLog.bSetPrintStrategy = 1;
		setLog.nPrintStrategy = 0;
		boolean bLogopen = netsdkApi.CLIENT_LogOpen(setLog);
		if (!bLogopen) {
			System.err.println("Failed to open NetSDK log !!!");
		}
		
    	// 向设备登入
    	int nSpecCap = 0;
    	Pointer pCapParam = null;
    	IntByReference nError = new IntByReference(0);
    	loginHandle = netsdkApi.CLIENT_LoginEx2(m_strIp, m_nPort, m_strUser , 
				m_strPassword ,nSpecCap,pCapParam, deviceinfo,nError);
		
		if(loginHandle.longValue() != 0) {
    		System.out.printf("Login Device[%s] Port[%d]Success!\n" , m_strIp , m_nPort);
    		System.out.println("通道号个数："+deviceinfo.byChanNum);
    	}
    	else {	
    		System.out.printf("Login Device[%s] Port[%d]Fail. %s\n" , m_strIp , m_nPort , ToolKits.getErrorCode());
    		EndTest();   
    	}
	}
	
	/**
	 * 查询刻录机信息
	 */
	public void QueryBurnDevice() {
		NET_BURNING_DEVINFO burnDevInfo = new NET_BURNING_DEVINFO();
		IntByReference retLen = new IntByReference(0);

		burnDevInfo.write();
		if (!netsdkApi.CLIENT_QueryDevState(loginHandle, 
											NetSDKLib.NET_DEVSTATE_BURNING_DEV, 
											burnDevInfo.getPointer(), 
											burnDevInfo.size(), 
											retLen, 
											3000)) {
			System.err.println("查询刻录机信息失败, " + ToolKits.getErrorCode());
			return;
		}
		
		burnDevInfo.read();
		PrintStruct.print(burnDevInfo);
	}
	
	/**
	 * 弹出刻录机光驱门
	 */
	/*public void EjectBurner() {

		NET_CTRL_BURNERDOOR ctrlBurn = new NET_CTRL_BURNERDOOR();
		
		ctrlBurn.szBurnerName = new Memory(NetSDKLib.NET_BURNING_DEV_NAMELEN);
		ctrlBurn.szBurnerName.write(0, burnerName.getBytes(), 0, burnerName.getBytes().length);	
//		ctrlBurn.bSafeEject = 1;

		ctrlBurn.write();
		if (netsdkApi.CLIENT_ControlDevice(loginHandle, 
											NetSDKLib.CtrlType.CTRLTYPE_CTRL_EJECT_BURNER, 
											ctrlBurn.getPointer(),  
											3000)) {
			System.out.println("弹出刻录机光驱门成功!");
		}else {
			System.err.println("弹出刻录机光驱门失败!" + ToolKits.getErrorCode());
		}
	}
	
	/**
	 * 关闭刻录机光驱门
	 */
	/*public void CloseBurner() {

		NET_CTRL_BURNERDOOR ctrlBurn = new NET_CTRL_BURNERDOOR();
		
		ctrlBurn.szBurnerName = new Memory(NetSDKLib.NET_BURNING_DEV_NAMELEN);
		ctrlBurn.szBurnerName.write(0, burnerName.getBytes(), 0, burnerName.getBytes().length);	

		ctrlBurn.write();
		if (netsdkApi.CLIENT_ControlDevice(loginHandle, 
											NetSDKLib.CtrlType.CTRLTYPE_CTRL_CLOSE_BURNER, 
											ctrlBurn.getPointer(),  
											3000)) {
			System.out.println("关闭刻录机光驱门成功!");
		}else {
			System.err.println("关闭刻录机光驱门失败!" + ToolKits.getErrorCode());
		}
	}*/

	/**
	 * 打开刻录会话
	 */
	public boolean StartBurnSession() {
		
		if (lBurnSession.longValue() != 0)
		{
			return true;
		}
		
		NET_IN_START_BURN_SESSION stuInParam = new NET_IN_START_BURN_SESSION();
		NET_OUT_START_BURN_SESSION stuOutParam = new NET_OUT_START_BURN_SESSION();
		
		stuInParam.nSessionID = 0;
		lBurnSession = netsdkApi.CLIENT_StartBurnSession(loginHandle, stuInParam, stuOutParam, 3000);
		if(lBurnSession.longValue() != 0) {
			System.out.println("打开刻录会话成功!");
		} else {
			System.err.println("打开刻录会话失败, " + ToolKits.getErrorCode());
			return false;
		}
		
		return true;
	}
	
	/**
	 * 关闭刻录会话
	 */
	public void StopBurnSession() 
	{
		if (lBurnSession.longValue() != 0) {
			netsdkApi.CLIENT_StopBurnSession(lBurnSession);
		}	
	}
	// 画中画通道号最大值
	int allchannel;
	
	/**
	 * 开始刻录
	 */
	public void StartBurn() 
	{								//使能下发				
		System.out.println("num: "+allchannel);
		String command = NetSDKLib.CFG_CMD_JUDICATURE;
		int channel = -1;
		CFG_JUDICATURE_INFO[] stuCfg = new CFG_JUDICATURE_INFO[allchannel+1];
		for (int i = 0; i < stuCfg.length; ++i) {
			 stuCfg[i] = new CFG_JUDICATURE_INFO();
	    }
		
	    int flg = ToolKits.GetDevConfig(loginHandle, channel, command, stuCfg);
	    System.out.println("个数："+flg);
	    for (int i = 0; i < stuCfg.length; i++) {
	      stuCfg[i].bAttachFileEn=0;
	    }	    	
		if(ToolKits.SetDevConfig(loginHandle, channel, command, stuCfg)) {
			System.out.println("设置使能成功");
		}else{
			System.err.println("设置使能失败, " + ToolKits.getErrorCode());
		};				
		
		if (!StartBurnSession()) {
			return;
		}
		NET_IN_START_BURN stuInParam = new NET_IN_START_BURN();
		NET_OUT_START_BURN stuOutParam = new NET_OUT_START_BURN();
		
		stuInParam.dwDevMask = 1;								// 刻录设备掩码, 按位表示多个刻录设备组合
		stuInParam.emMode = NET_BURN_MODE.BURN_MODE_SYNC;  		// 刻录模式
		stuInParam.emPack = NET_BURN_RECORD_PACK.BURN_PACK_MP4; // 刻录流格式
		stuInParam.nChannelCount = 1; 							// 刻录通道信息
		stuInParam.nChannels[0] = 0;							// 刻录通道
		stuInParam.emExtMode = 1;                               // 额外刻录模式

		if (netsdkApi.CLIENT_StartBurn(lBurnSession, stuInParam, stuOutParam, 30000)) {
			System.out.println("开始刻录成功!");
		} else {
			System.err.println("开始刻录失败, " + ToolKits.getErrorCode());
		}
	}
	
	
	
	
	

//	打开刻录会话, 返回刻录会话句柄,pstInParam与pstOutParam内存由用户申请释放
//	CLIENT_NET_API LLONG CALL_METHOD CLIENT_StartBurnSession(LLONG lLoginID, const NET_IN_START_BURN_SESSION* pstInParam, NET_OUT_START_BURN_SESSION *pstOutParam, int nWaitTime); 
	
	/**
	 * 监听刻录状态
	 */
	public void AttachBurnState() {
		
		if (lBurnSession.longValue() == 0 || lAttachBurnStateHandle.longValue() != 0) {
			return;
		}
			
		NET_IN_ATTACH_STATE stIn = new NET_IN_ATTACH_STATE();
		stIn.szDeviceName = new Memory(NetSDKLib.NET_BURNING_DEV_NAMELEN);
		stIn.szDeviceName.write(0, burnerName.getBytes(), 0, burnerName.getBytes().length);	
		stIn.cbAttachStateEx = AttachBurnStateCB.getInstance();  // 回调函数
		stIn.lBurnSession = lBurnSession;
		
		NET_OUT_ATTACH_STATE stOut = new NET_OUT_ATTACH_STATE();
		lAttachBurnStateHandle = netsdkApi.CLIENT_AttachBurnState(loginHandle, stIn, stOut, 3000);
		
		if(lAttachBurnStateHandle.longValue() != 0) {
			System.out.println("监听刻录状态成功!");
		} else {
			System.err.println("监听刻录状态失败, " + ToolKits.getErrorCode());
		}
	}
	
	/**
	 * 监听刻录状态回调
	 */
	private static class AttachBurnStateCB implements fAttachBurnStateCBEx {
		private AttachBurnStateCB() {}
		
		private static class AttachBurnStateCBHolder {
			private static AttachBurnStateCB instance = new AttachBurnStateCB();
		}
		
		public static AttachBurnStateCB getInstance() {
			return AttachBurnStateCBHolder.instance;
		}

		@Override
		public void invoke(LLong lLoginID, LLong lAttachHandle,
				NET_OUT_BURN_GET_STATE pBuf, int nBufLen, Pointer dwUser) {
			
			System.out.println("监听到刻录状态: " + pBuf.emState); // 参见NET_BURN_STATE
		}
						
	}
	/**
	 * 刻录进度回调
	 */
	private static class BurnFileCB implements fBurnFileCallBack {
		private BurnFileCB() {}
		
		private static class BurnFileCBHolder {
			private static BurnFileCB instance = new BurnFileCB();
		}
		
		public static BurnFileCB getInstance() {
			return BurnFileCBHolder.instance;
		}
		@Override
		public void invoke(LLong lLoginID, LLong lUploadHandle,  
				int nTotalSize, int nSendSize, Pointer dwUser){
			 if (lUploadHandle.intValue() ==0 || lLoginID.intValue() == 0){
				 System.out.println((lUploadHandle.intValue() ==0) +" "+(lLoginID.intValue() == 0) +" finished");
				 m_bNeetStop=true;
			 }	 
			 if (nTotalSize == nSendSize){
				 System.out.println("finished");
				 m_bNeetStop=true;
			 }
			 double percent=((double)nSendSize/(double)nTotalSize)*100;
			 double frac=percent-Math.floor(percent);  //小数部分
			 percent=Math.floor(percent);
			 if(1-frac<10e-2){
				 percent+=1;
				 frac=1-frac;
			 }
			 //上传进度
			 if(frac<10e-2)
				 System.out.println("Send: "+(double)nSendSize+"\tTotal: "+(double)nTotalSize
						 +"\t\t"+"Upload progress: "+(int)percent+"%");
			 
//			 if(nSendSize==-2){
//				 System.out.println("上传失败，上传需要先开始刻录(并最好稍作等待)");
//				 m_bNeetStop=true;
//			 }
		}					
	}
	
	/**
	 * 取消监听刻录状态
	 */
	public void DetachBurnState() {
		if(lAttachBurnStateHandle.longValue() != 0) {
			netsdkApi.CLIENT_DetachBurnState(lAttachBurnStateHandle);
			lAttachBurnStateHandle.setValue(0);
		}
	}
	
	/**
	 * 获取刻录状态
	 */
	public void BurnGetState() {
		
		NET_IN_BURN_GET_STATE stIn = new NET_IN_BURN_GET_STATE();
		NET_OUT_BURN_GET_STATE stOut = new NET_OUT_BURN_GET_STATE(); 
		
		if(netsdkApi.CLIENT_BurnGetState(lBurnSession, stIn, stOut, 3000)) {
			PrintStruct.print(stOut);
		} else {
			System.err.println("获取刻录状态失败!" + ToolKits.getErrorCode());
		}
	}

	/**
	 * 暂停刻录
	 */
	public void PauseBurn() 
	{
		if (lBurnSession.longValue() == 0) {
			System.err.println("请先开始刻录");
			return;
		}
		
		if (netsdkApi.CLIENT_PauseBurn(lBurnSession, 1)) {
			System.out.println("暂停刻录成功!");
		} else {
			System.err.println("暂停刻录失败, " + ToolKits.getErrorCode());
		}
	}
	
	/**
	 * 恢复刻录
	 */
	public void ResumeBurn() 
	{
		if (lBurnSession.longValue() == 0) {
			System.err.println("请先开始刻录");
			return;
		}
		
		if (netsdkApi.CLIENT_PauseBurn(lBurnSession, 0)) {
			System.out.println("恢复刻录成功!");
		} else {
			System.err.println("恢复刻录失败, " + ToolKits.getErrorCode());
		}
	}
	
	/**
	 * 停止刻录
	 */
	public void StopBurn() 
	{
		if (lBurnSession.longValue() != 0) {
			netsdkApi.CLIENT_StopBurn(lBurnSession);
			StopBurnSession();
		}	
	}
	

	/**
	 * 查询画中画通道信息
	 */
	public void QueryPicInPic() {
		IntByReference retLen = new IntByReference(0);
		int nSize = 4 * 1024;
		Pointer p = new Memory(nSize);
		p.clear(nSize);
		if (!netsdkApi.CLIENT_QueryDevState(loginHandle, NetSDKLib.NET_DEVSTATE_PICINPIC_CHN, p, nSize, retLen, 3000)) {
			System.err.println("查询画中画通道信息失败, " + ToolKits.getErrorCode());
			return;
		}
		int nNum = retLen.getValue()/4;
		System.out.println("画中画通道个数: " + nNum);
		int[] channels = new int[nNum];
		p.read(0, channels, 0, nNum);
		if(nNum>0) {
			for (int c : channels) {
				System.out.println(c);			
			}
			Arrays.parallelSort(channels);
			allchannel = channels[channels.length-1];
		}
	}
	
	
	
	/**
	 * 查询设备在线状态
	 */
	public void QueryOnlineState() {

		IntByReference retLen = new IntByReference(0);
		Pointer p = new Memory(Integer.SIZE);
		p.clear(Integer.SIZE);
		if (!netsdkApi.CLIENT_QueryDevState(loginHandle, 
											NetSDKLib.NET_DEVSTATE_ONLINE, 
											p, 
											Integer.SIZE, 
											retLen, 
											3000)) {
			System.err.println("查询设备在线状态失败, " + ToolKits.getErrorCode());
			return;
		}
		int []a = new int[1];
		p.read(0, a, 0, 1);
		System.out.println(a[0]);
	}
	
	/**
	 * 刻录配置
	 */
	public void SetJudicature() {
		String command = NetSDKLib.CFG_CMD_JUDICATURE;
		int channel = 0;
		CFG_JUDICATURE_INFO stuCfg = new CFG_JUDICATURE_INFO();
	
		// 获取
		if(ToolKits.GetDevConfig(loginHandle, channel, command, stuCfg)) {
			System.out.println("案件编号叠加使能 : " + stuCfg.bCaseNoOsdEn);
			if (stuCfg.bCaseNoOsdEn == 1) {
				System.out.println("案件编号 :" + new String(stuCfg.szCaseNo).trim());
			}
			
			// 设置，在获取的基础上设置
			stuCfg.bCaseNoOsdEn = 1; // 案件编号叠加使能
			String caseNo = "AJBH001"; // 案件编号
			System.arraycopy(caseNo.getBytes(), 0, stuCfg.szCaseNo, 0, caseNo.getBytes().length);
			if(ToolKits.SetDevConfig(loginHandle, channel, command, stuCfg)) {
				System.out.println("设置刻录配置成功!");
			} else {
				System.err.println("设置刻录配置失败!" + ToolKits.getErrorCode());
			}
			
		} else {
			System.err.println("设置刻录配置失败!" + ToolKits.getErrorCode());
		}
	}
	
	/**
	 * 刻录密码修改
	 */
	public void SetJudicatureSecret() {
		String command = NetSDKLib.CFG_CMD_JUDICATURE;
		int channel = 0;
		CFG_JUDICATURE_INFO stuCfg = new CFG_JUDICATURE_INFO();

		// 获取
		if(ToolKits.GetDevConfig(loginHandle, channel, command, stuCfg)) {
			
			System.out.println("愿密码:"+new String(stuCfg.szPassword).trim());
			System.out.println("愿密码长度:"+stuCfg.nPasswordLen);
			
		    System.out.println("请输入新密码(支持数字和英文字母):");
		    Scanner read=new Scanner(System.in);
		    byte[] newPwd=read.next().getBytes();
		    int newlen=newPwd.length;
		    
//		    stuCfg.szPassword=newPwd;
		    stuCfg.nPasswordLen=newlen;

			System.arraycopy(newPwd, 0, stuCfg.szPassword, 0, newlen);
			if(ToolKits.SetDevConfig(loginHandle, channel, command, stuCfg)) {
				System.out.println("修改刻录密码成功!");
			} else {
				System.err.println("修改刻录密码失败!" + ToolKits.getErrorCode());
			}
			
		} else {
			System.err.println("修改刻录密码失败!" + ToolKits.getErrorCode());
		}
	}
	
	//附件刻录
	public void UploadFileBurned(){
		
		//使能下发
		String command = NetSDKLib.CFG_CMD_JUDICATURE;
		int channel = 0;
		CFG_JUDICATURE_INFO stuCfg = new CFG_JUDICATURE_INFO();
		if(ToolKits.GetDevConfig(loginHandle, channel, command, stuCfg)) {
//			System.out.println("原使能:"+stuCfg.bAttachFileEn);
			stuCfg.bAttachFileEn=1;
//			System.out.println("新使能:"+stuCfg.bAttachFileEn);
			if(ToolKits.SetDevConfig(loginHandle, channel, command, stuCfg))
				System.out.println("下发使能成功!");
		    else 
				System.err.println("下发使能失败!" + ToolKits.getErrorCode());
		} else {
			System.err.println("下发使能失败!" + ToolKits.getErrorCode());
		}
		
			
		NET_IN_FILEBURNED_START stIn = new NET_IN_FILEBURNED_START();
		
		Scanner read=new Scanner(System.in);
		System.out.println("请输入要刻录的文件名:");  //即要上传的附件
		String szFilename=read.next();
		stIn.szFilename = new Memory(128);   //文件名 char[128]
		stIn.szFilename.write(0, szFilename.getBytes(), 0, szFilename.getBytes().length);
		
		//szMode
		System.out.println("请选择上传方式:\n"
				+ "1.append, 追加模式,此时刻录文件名固定为 FILE.zip ,filename被忽\n"
				+ "2.evidence, 证据等大附件, 要求单独刻录的光盘内");
		String szMode=read.nextInt()==1?"append":"evidence";
		stIn.szMode = new Memory(16);   
		stIn.szMode.write(0, szMode.getBytes(), 0, szMode.getBytes().length);	
//		read.close();  不可关闭，否则会退出main方法
		
		stIn.szDeviceName = new Memory(NetSDKLib.NET_BURNING_DEV_NAMELEN);
		stIn.szDeviceName.write(0, burnerName.getBytes(), 0, burnerName.getBytes().length);	
		
//		stIn.dwUser=null;
		stIn.cbBurnPos = BurnFileCB.getInstance();
		
		if (!StartBurnSession()) {
			System.err.println("open lBurnSession Error");
			return;
		}
		stIn.lBurnSession = lBurnSession;
		
		NET_OUT_FILEBURNED_START stOut = new NET_OUT_FILEBURNED_START();

		//开始刻录附件上传
		LLong lStartUploadFileBurnedHandle=netsdkApi.CLIENT_StartUploadFileBurned(loginHandle, stIn, stOut, 3000);
		if(0 == lStartUploadFileBurnedHandle.intValue()){
			System.err.println("开始刻录附件上传失败, " + ToolKits.getErrorCode());
			return ;
		}

		//刻录上传附件
		boolean bRet = netsdkApi.CLIENT_SendFileBurned(lStartUploadFileBurnedHandle);
		if(! bRet){
			System.err.println("上传刻录附件失败, " + ToolKits.getErrorCode());
			return ;
		}
		else System.out.println("上传刻录附件成功, ");
		
		//刻录附件上传停止
		while(!m_bNeetStop);
		bRet = netsdkApi.CLIENT_StopUploadFileBurned(lStartUploadFileBurnedHandle);
		if (bRet != true)
			System.err.println("刻录附件上传停止失败, " + ToolKits.getErrorCode());
		else
			System.out.println("刻录附件上传停止成功");
	}
	
	public void RunTest()
	{
		System.out.println("Run Test");		
		CaseMenu menu = new CaseMenu();
	
		menu.addItem(new CaseMenu.Item(this , "查询刻录机信息" , "QueryBurnDevice"));
//		menu.addItem(new CaseMenu.Item(this , "弹出刻录机光驱门" , "EjectBurner"));	// 设备暂不支持
//		menu.addItem(new CaseMenu.Item(this , "关闭刻录机光驱门" , "CloseBurner"));
		menu.addItem(new CaseMenu.Item(this , "开始刻录" , "StartBurn"));
		menu.addItem(new CaseMenu.Item(this , "监听刻录状态" , "AttachBurnState"));
		menu.addItem(new CaseMenu.Item(this , "取消监听刻录状态" , "DetachBurnState"));
		menu.addItem(new CaseMenu.Item(this , "获取刻录状态" , "BurnGetState"));
		menu.addItem(new CaseMenu.Item(this , "暂停刻录" , "PauseBurn"));
		menu.addItem(new CaseMenu.Item(this , "恢复刻录" , "ResumeBurn"));
		menu.addItem(new CaseMenu.Item(this , "停止刻录" , "StopBurn"));
		menu.addItem(new CaseMenu.Item(this , "查询画中画通道" , "QueryPicInPic"));
		menu.addItem(new CaseMenu.Item(this , "查询设备在线状态" , "QueryOnlineState"));
		menu.addItem(new CaseMenu.Item(this , "刻录配置" , "SetJudicature"));
		menu.addItem(new CaseMenu.Item(this , "刻录密码修改" , "SetJudicatureSecret"));
		menu.addItem(new CaseMenu.Item(this , "附件刻录" , "UploadFileBurned"));
		
//		menu.addItem(new CaseMenu.Item(this , "打开刻录会话" , "StartBurnSession"));
//		menu.addItem(new CaseMenu.Item(this , "关闭刻录会话" , "StopBurnSession"));

		menu.run(); 
	}
	
	public static void main(String[]args)
	{		
		Burner demo = new Burner();	
	
		demo.InitTest();
		demo.RunTest();
		demo.EndTest();
	}
}