test.java

JRemoteControl is a simple Java&#8482 driven bluetooth remote control.It allows you to initiate virt

/*
 * Copyright (C) 2007 Filippo Di Vattimo - See LICENSE
 *
 */

package fildiv.jremcntl.server.test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Vector;

import javax.bluetooth.DeviceClass;
import javax.bluetooth.RemoteDevice;

import fildiv.jremcntl.client.core.JRemClientProtocol;
import fildiv.jremcntl.client.core.ServerResponse;
import fildiv.jremcntl.client.core.ServerResponseListener;
import fildiv.jremcntl.client.core.ServerResponseReader;
import fildiv.jremcntl.common.core.Config;
import fildiv.jremcntl.common.core.JRemClientConnectionListener;
import fildiv.jremcntl.common.core.JRemClientConnector;
import fildiv.jremcntl.common.core.PlainTextCmdResult;
import fildiv.jremcntl.server.core.JRemConfigReader;
import fildiv.jremcntl.server.core.JRemEnv;
import fildiv.jremcntl.server.core.JRemServerProtocol;
import fildiv.jremcntl.server.gui.core.ConsoleLogger;
import fildiv.jremcntl.server.gui.model.JRemConfigDoc;
import fildiv.jremcntl.server.gui.model.JRemContextDoc;

public class Test {
	
	private RemoteDevice rd;
	
	private static class ThreadTest {
		
		Thread t = null;
		
		public ThreadTest() {
			
			t = new Thread() {
				public void run() {
					test();
				}
			};
			
			t.start();
		}
		
		private void test() {

			while(true) {
				System.out.print("kkk");
				try {
					Thread.currentThread().sleep(2000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		
	}
	
	public static void main(String[] args) {
		try {
			
			//ThreadTest t = new ThreadTest();
			
	        JRemEnv env = JRemEnv.createEnvironment(
	        		"/home/fildiv/workspacesf/jremcntl/config/jrem.properties", 
	        		new ConsoleLogger(), false);
			
			testProto();
			
//			testModel();			
//			new Test().testClient();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	private void testClient() throws InterruptedException {

		final RemoteDevice remoteDevice;
		
		final JRemClientConnector c = new JRemClientConnector();
		c.setConnectorListener(new JRemClientConnectionListener() {

			public void connected(boolean success) {

				System.out.print("Success = " + success);
			}

			public void deviceDiscovered(RemoteDevice rd, DeviceClass dc) {

				try {
					System.out.println("Device discovered = " + rd.getFriendlyName(false));
					Test.this.rd = rd;
					
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}				
			}

			public void discoveryCompleted(Vector devices, boolean error) {
				System.out.println("Discovery Completed");
				
				synchronized (c) {
					c.notify();
				}
				
			}

			public void discoveryStarted() {
				System.out.println("Discovery Started");
				
			}

			public void serviceOpening() {
				System.out.println("serviceOpeningd");				
			}

			public void exceptionOccurred(Exception e) {
				System.out.println("exceptionOccurred");								
			}

			public void inProgress() {
				
			}

			public void interrupt() {				
			}
			
		});
		
		c.findDevices();
		
		synchronized (c) {
			c.wait();
		}

		if (this.rd != null)
			c.connect(this.rd);
	}

	private static void testModel() {
		JRemConfigReader r = new JRemConfigReader(
				"/home/fildiv/workspacesf/jremcntl/config/config.xml");
		
		JRemConfigDoc conf = (JRemConfigDoc) r.getConfig();
		
		JRemContextDoc context = (JRemContextDoc) conf.getContexts().get(1);
		
		context.setSilentMode(true);
		
		context.setDesc(Math.random() + "XX");
		context.setDesc(Math.random() + "XX");
		context.setDesc(Math.random() + "XX");
		
		context.setSilentMode(false);
		
		
	}

	private static void testProto() {
		
		JRemConfigReader r = new JRemConfigReader(
		"/home/fildiv/workspacesf/jremcntl/config/linux/config.xml");
		
		Config conf = r.getConfig();
		
		FileInputStream fin = null;
		FileOutputStream fout = null;
		
		ServerResponseListener srl = new ServerResponseListener() {

			public void connectionClosed() {
				System.out.println("connectionClosed()");
			}

			public void connectionLost() {
				System.out.println("connectionLost()");				
			}

			public void receivedCommandResponse(ServerResponse response) {
				System.out.println("receivedCommandResponse() " + response.toString());			
			}
		};
		
		try {
			File fl = new File("test.bin");	
			fout = new FileOutputStream(fl);
			fin = new FileInputStream(fl);
			
			JRemServerProtocol serverProt = new JRemServerProtocol(fin, fout);
			serverProt.sendConfig(conf);
			
			JRemClientProtocol clientProt = new JRemClientProtocol(fin, fout, null);
			Config readConf = clientProt.retrieveConfig();

			serverProt.sendCmdResponse(new PlainTextCmdResult("MEssaggio"));
			serverProt.closeClientConnection();
			
			ServerResponseReader srr = new ServerResponseReader(clientProt, srl);
			srr.close();
			
			int cmd = serverProt.retrieveCommandID();
			System.out.println(cmd);

			serverProt.close();
			
		} catch (Exception e) {
			e.printStackTrace();
		
		}
		
	}
}