/*

* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*/

import gnu.io.CommPort;

import gnu.io.CommPortIdentifier;

import gnu.io.SerialPort;

import gnu.io.SerialPortEvent;

import gnu.io.SerialPortEventListener;

import java.util.logging.Logger;

import org.apache.commons.cli.Options;

import org.apache.commons.cli.Option;

import org.apache.commons.cli.OptionBuilder;

import org.apache.commons.cli.CommandLineParser;

import org.apache.commons.cli.PosixParser;

import org.apache.commons.cli.CommandLine;

import org.apache.commons.cli.HelpFormatter;

public class UartEchoServer implements SerialPortEventListener

	{

	//	Command line options

	private static final String	OPTION_HELP			="help";

	private static final String	OPTION_PORT			="port";

	private static final String	OPTION_BAUD			="baud_rate";

	private static final String	OPTION_DATA			="data_bits";

	private static final String	OPTION_STOP			="stop_bits";

	private static final String	OPTION_PARITY		="parity";

	private static final String	OPTION_FLOW			="flow_control";

	//	Default settings for serial port

	private static final String	DEFAULT_PORT_NAME	= "COM1";

	private static final int	DEFAULT_BAUD_RATE	= 9600;

	private static final int	DEFAULT_DATA_BITS	= SerialPort.DATABITS_8;

	private static final int	DEFAULT_STOP_BITS	= SerialPort.STOPBITS_1;

	private static final int	DEFAULT_PARITY		= SerialPort.PARITY_NONE;

	private static final int	DEFAULT_FLOW_CONTROL= SerialPort.FLOWCONTROL_NONE;

	//	Command format limiters

	private static final byte	BYTE_IGNORE			= '\0'; // Null

	private static final byte	BYTE_CLEARBI		= '\1'; // Ctrl A

	private static final byte	BYTE_QUERYBI		= '\2'; // Ctrl B

	private static final byte	BYTE_RESET			= '\3'; // Ctrl C

	private static final byte	BYTE_BLOCK_START	= '[';

	private static final byte	BYTE_BLOCK_END		= ']';

	private static final String	BLOCK_ASSIGN		= "=";

	private static final String	BLOCK_SEPERATOR		= ",";

	//	Supported commands

	private static final String	CMD_BAUD_RATE		= "baud_rate";

	private static final String	CMD_DATA_BITS		= "data_bits";

	private static final String	CMD_DELAY			= "delay";

	private static final String	CMD_DISCONNECT		= "disconnect";

	private static final String	CMD_ECHO			= "echo";

	private static final String	CMD_FLOW_CONTROL	= "flow_control";

	private static final String	CMD_LOG				= "log";

	private static final String	CMD_PARITY			= "parity";

	private static final String	CMD_STOP_BITS		= "stop_bits";

	//	Supported data bits

	private static final String	DATA_BITS_5			= "5";

	private static final String	DATA_BITS_6			= "6";

	private static final String	DATA_BITS_7			= "7";

	private static final String	DATA_BITS_8			= "8";

	//	Supported flow control

	private static final String	FLOWCONTROL_NONE	= "none";

	private static final String	FLOWCONTROL_RTSCTS	= "rtscts";

	private static final String	FLOWCONTROL_XONXOFF	= "xonxoff";

	//	Supported parity

	private static final String	PARITY_NONE			= "none";

	private static final String	PARITY_EVEN			= "even";

	private static final String	PARITY_ODD			= "odd";

	private static final String	PARITY_MARK			= "mark";

	private static final String	PARITY_SPACE		= "space";

	//	Supported stop bits

	private static final String	STOP_BITS_1			= "1";

	private static final String	STOP_BITS_1_5		= "1.5";

	private static final String	STOP_BITS_2			= "2";

	//	Constants

	private static final int	BUFFER_SIZE			= 1024;

	private static final int	SLEEP_PERIOD		= 200000;

	private enum EStatus

		{

		EStatusEcho,

		EStatusCommandStart,

		};

	private Thread				iMainThread;

	private int					iRestartingDelay;

	private boolean				iRestarting;

	private boolean				iRunning;

	private Logger				iLogger;

	private byte[]				iBuffer;

	private EStatus				iStatus;

	private String				iCommand;

	private String				iPortName;

	private byte				iBI;

	private int					iBaudRate;

	private int					iDataBits;

	private int					iStopBits;

	private int					iParity;

	private int					iFlowControl;

	private int					iStartupBaudRate;

	private int					iStartupDataBits;

	private int					iStartupStopBits;

	private int					iStartupParity;

	private int					iStartupFlowControl;

	private CommPortIdentifier	iPortIdentifier;

	private SerialPort			iSerialPort;

	/*

	 *	Constructor

	 */

	protected UartEchoServer() throws Exception

		{

		iRestartingDelay=0;

		iRestarting=true;

		iRunning=true;

		iLogger=Logger.getLogger("UartEchoServer");

		iBuffer=new byte[BUFFER_SIZE];

		iStatus = EStatus.EStatusEcho;

		iCommand = "";

		iBI=0;

		iPortName=DEFAULT_PORT_NAME;

		iBaudRate=DEFAULT_BAUD_RATE;

		iDataBits=DEFAULT_DATA_BITS;

		iStopBits=DEFAULT_STOP_BITS;

		iParity=DEFAULT_PARITY;

		iFlowControl=DEFAULT_FLOW_CONTROL;

		}

	/*

	 *	Second pahse constructor

	 *

	 *	@param	aCommandLine	Command line parameters

	 */

	protected void Construct(final CommandLine aCommandLine) throws Exception

		{

		/*

		 *	Set port name if passed in command line

		 */

		if ( aCommandLine.hasOption(OPTION_PORT) )

			{

			iPortName=aCommandLine.getOptionValue(OPTION_PORT);

			iLogger.info("PortName:" + iPortName);

			}

		/*

		 *	Set baud rate if passed in command line

		 */

		if ( aCommandLine.hasOption(OPTION_BAUD) )

			{

			setBaudRate(aCommandLine.getOptionValue(OPTION_BAUD));

			iLogger.info("Baud Rate:" + iBaudRate);

			}

		/*

		 *	Set data bits if passed in command line

		 */

		if ( aCommandLine.hasOption(OPTION_DATA) )

			{

			setDataBits(aCommandLine.getOptionValue(OPTION_DATA));

			iLogger.info("Data Bits:" + iDataBits);

			}

		/*

		 *	Set stop bits if passed in command line

		 */

		if ( aCommandLine.hasOption(OPTION_STOP) )

			{

			setStopBits(aCommandLine.getOptionValue(OPTION_STOP));

			iLogger.info("Stop Bits:" + iStopBits);

			}

		/*

		 *	Set parity if passed in command line

		 */

		if ( aCommandLine.hasOption(OPTION_PARITY) )

			{

			setParity(aCommandLine.getOptionValue(OPTION_PARITY));

			iLogger.info("Parity:" + iParity);

			}

		/*

		 *	Set flow control if passed in command line

		 */

		if ( aCommandLine.hasOption(OPTION_FLOW) )

			{

			setFlowControl(aCommandLine.getOptionValue(OPTION_FLOW));

			iLogger.info("Flow Control:" + iFlowControl);

			}

		/*

		 *	Save startup values. Used by reset command

		 */

		iStartupBaudRate=iBaudRate;

		iStartupDataBits=iDataBits;

		iStartupStopBits=iStopBits;

		iStartupParity=iParity;

		iStartupFlowControl=iFlowControl;

		/*

		 *	Make sure port is not in use

		 */

		iPortIdentifier=CommPortIdentifier.getPortIdentifier(iPortName);

		if ( iPortIdentifier.isCurrentlyOwned() )

			{

			throw new Exception("Error: Port is currently in use");

			}

		/*

		 *	Port not in use so open it

		 */

		CommPort	commPort=iPortIdentifier.open(this.getClass().getName(), 2000);

		/*

		 *	Save thread

		 */

		iMainThread=Thread.currentThread();

		/*

		 *	Make sure the port is of type serial

		 */

		if ( commPort instanceof SerialPort )

			{

			iSerialPort = (SerialPort) commPort;

			iFlowControl=iSerialPort.getFlowControlMode();

			while ( iRunning )

				{

				initPort();

				iRestarting=false;

				while ( iRunning && !iRestarting )

					{

					try

						{

						iMainThread.sleep(SLEEP_PERIOD);

						}

					catch ( InterruptedException e )

						{

						}

					}

				iSerialPort.close();

				if ( iRestarting )

					{

					iLogger.finest("Restarting");

					iMainThread.sleep(iRestartingDelay);

					commPort=iPortIdentifier.open(this.getClass().getName(), 2000);

					iSerialPort = (SerialPort) commPort;

					}

				}

			}

		else

			{

			throw new Exception("Error: Only serial ports are handled by this example.");

			}

		}

	/*

	 *	Initialise the port

	 */

	private void initPort() throws Exception

		{

		iSerialPort.setSerialPortParams(iBaudRate, iDataBits, iStopBits, iParity);

		iSerialPort.setFlowControlMode(iFlowControl);

		iSerialPort.addEventListener(this);

		iSerialPort.notifyOnBreakInterrupt(true);

		iSerialPort.notifyOnCarrierDetect(true);

		iSerialPort.notifyOnCTS(true);

		iSerialPort.notifyOnDataAvailable(true);

		iSerialPort.notifyOnDSR(true);

		iSerialPort.notifyOnFramingError(true);

		iSerialPort.notifyOnOutputEmpty(true);

		iSerialPort.notifyOnOverrunError(true);

		iSerialPort.notifyOnParityError(true);

		iSerialPort.notifyOnRingIndicator(true);

		iSerialPort.setInputBufferSize(BUFFER_SIZE);

		}

	/*

	 *	Set the baud rate

	 *

	 *	@param	aValue	String representation of the baud rate

	 */

	private void setBaudRate(final String aValue)

		{

		try

			{

			iBaudRate=Integer.parseInt(aValue);

			}

		catch (Exception e)

			{

			iLogger.severe("convertToBaudRate(" + aValue + "):exception" + e);

			}

		}

	/*

	 *	Set the data bits

	 *

	 *	@param	aValue	String representation of the data bits

	 */

	private void setDataBits(final String aValue)

		{

		try

			{

			if ( aValue.compareTo(DATA_BITS_5)==0 )

				{

				iDataBits=SerialPort.DATABITS_5;

				}

			else if ( aValue.compareTo(DATA_BITS_6)==0 )

				{

				iDataBits=SerialPort.DATABITS_6;

				}

			else if ( aValue.compareTo(DATA_BITS_7)==0 )

				{

				iDataBits=SerialPort.DATABITS_7;

				}

			else if ( aValue.compareTo(DATA_BITS_8)==0 )

				{

				iDataBits=SerialPort.DATABITS_8;

				}

			else

				{

				iLogger.severe("setDataBits(" + aValue + ")");

				}

			}

		catch (Exception e)

			{

			iLogger.severe("setDataBits(" + aValue + "):excpetion" + e);

			}

		}

	/*

	 *	Set the flow control

	 *

	 *	@param	aValue	String representation of the flow control

	 */

	private void setFlowControl(final String aValue)

		{

		try

			{

			if ( aValue.compareTo(FLOWCONTROL_NONE)==0 )

				{

				iFlowControl=SerialPort.FLOWCONTROL_NONE;

				}

			else if ( aValue.compareTo(FLOWCONTROL_RTSCTS)==0 )

				{

				iFlowControl=SerialPort.FLOWCONTROL_RTSCTS_IN | SerialPort.FLOWCONTROL_RTSCTS_OUT;

				}

			else if ( aValue.compareTo(FLOWCONTROL_XONXOFF)==0 )

				{

				iFlowControl=SerialPort.FLOWCONTROL_XONXOFF_IN | SerialPort.FLOWCONTROL_XONXOFF_OUT;

				}

			else

				{

				iLogger.severe("setFlowControl(" + aValue + ")");

				}

			}

		catch (Exception e)

			{

			iLogger.severe("setFlowControl(" + aValue + "):exception" + e);

			}

		}

	/*

	 *	Set the parity

	 *

	 *	@param	aValue	String representation of the parity

	 */

	private void setParity(final String aValue)

		{

		try

			{

			if ( aValue.compareTo(PARITY_NONE)==0 )

				{

				iParity=SerialPort.PARITY_NONE;

				}

			else if ( aValue.compareTo(PARITY_EVEN)==0 )

				{

				iParity=SerialPort.PARITY_EVEN;

				}

			else if ( aValue.compareTo(PARITY_ODD)==0 )

				{

				iParity=SerialPort.PARITY_ODD;

				}

			else if ( aValue.compareTo(PARITY_MARK)==0 )

				{

				iParity=SerialPort.PARITY_MARK;

				}

			else if ( aValue.compareTo(PARITY_SPACE)==0 )

				{

				iParity=SerialPort.PARITY_SPACE;

				}

			else

				{

				iLogger.severe("setParity(" + aValue + ")");

				}

			}

		catch (Exception e)

			{

			iLogger.severe("setParity(" + aValue + "):exception" + e);

			}

		}

	/*

	 *	Set the stop bits

	 *

	 *	@param	aValue	String representation of the stop bits

	 */

	private void setStopBits(final String aValue)

		{

		try

			{

			if ( aValue.compareTo(STOP_BITS_1)==0 )

				{

				iStopBits=SerialPort.STOPBITS_1;

				}

			else if ( aValue.compareTo(STOP_BITS_1_5)==0 )

				{

				iStopBits=SerialPort.STOPBITS_1_5;

				}

			else if ( aValue.compareTo(STOP_BITS_2)==0 )

				{

				iStopBits=SerialPort.STOPBITS_2;

				}

			else

				{

				iLogger.severe("setStopBits(" + aValue + ")");

				}

			}

		catch (Exception e)

			{

			iLogger.severe("setStopBits(" + aValue + "):exception" + e);

			}

		}

	/*

	 *	Process a command from the input

	 */

	private void processCommand() throws Exception

		{

		final String	values[] = iCommand.split(BLOCK_SEPERATOR);

		iSerialPort.getOutputStream().flush();

		for ( int i=0; i<values.length; i++ )

			{

			/*

			 *	Commands should be of the type variable=value

			 */

			final String	parts[]=values[i].split(BLOCK_ASSIGN);

			if ( parts.length==2 )

				{

				/*

				 *	Set baud rate command

				 */

				if ( parts[0].compareTo(CMD_BAUD_RATE)==0 )

					{

					setBaudRate(parts[1]);

					iSerialPort.setSerialPortParams(iBaudRate, iDataBits, iStopBits, iParity);

					}

				/*

				 *	Set data bits command

				 */

				else if ( parts[0].compareTo(CMD_DATA_BITS)==0 )

					{

					setDataBits(parts[1]);

					iSerialPort.setSerialPortParams(iBaudRate, iDataBits, iStopBits, iParity);

					}

				/*

				 *	Delay command

				 */

				else if ( parts[0].compareTo(CMD_DELAY)==0 )

					{

					final int	delay=Integer.parseInt(parts[1]);

					Thread.sleep(delay);

					}

				/*

				 *	Disconnect command

				 */

				else if ( parts[0].compareTo(CMD_DISCONNECT)==0 )

					{

					iRestartingDelay=Integer.parseInt(parts[1]);

					iRestarting=true;

					}

				/*

				 *	Echo command

				 */

				else if ( parts[0].compareTo(CMD_ECHO)==0 )

					{

					final int		length=parts[1].length();

					for ( int index=0; index<length; ++index )

						{

						final byte	out=(byte)(parts[1].charAt(index));

						iLogger.finest("<< " + out);

						iSerialPort.getOutputStream().write(out);

						}

					}

				/*

				 *	Set flow control command

				 */

				else if ( parts[0].compareTo(CMD_FLOW_CONTROL)==0 )

					{

					setFlowControl(parts[1]);

					iSerialPort.setFlowControlMode(iFlowControl);

					}