/*

* 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:  

*

*/

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

// STATSerial.cpp

// Implementation of the serial comms transport

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

#include "stdafx.h"

#include "statserial.h"

#include "assert.h"

#include "../../../../Common/inc/SerialPacketSize.h"

#define SP_COMMANDSIZE	4

#define SP_LENGTHSIZE	4

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

// Constructor

CSTATSerial::CSTATSerial(STATCONNECTTYPE eConnect)

: hComPort((HANDLE)0), 	pBuffer(NULL), iBufferLength(0), iMaxPacketSize(0)

{

	switch(eConnect)

	{

		case SymbianSerial:

		case SymbianInfrared:

			iMaxPacketSize = KMaxPacketSize;

			break;

		case SymbianBluetooth:

			iMaxPacketSize = KMaxBluetoothPacketSize;

			break;

		default:

			assert(0);

			break;

	};

	assert(0 != iMaxPacketSize);

}

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

// Destructor

CSTATSerial::~CSTATSerial()

{

	Disconnect();

	Release();

}

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

// Initialisation stuff

int CSTATSerial::Initialise(void)

{

	return ITS_OK;

}

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

// Open a connection

int CSTATSerial::Connect(const char *pAddress)

{

	// already connected

	if (hComPort)

		return ITS_OK;

	if (OpenComPort(pAddress))

	{

		SetError("Connected to port %s Speed %d Bytes %d Parity %d Stop %d",

			pAddress, STAT_BAUDRATE, STAT_BYTESIZE, STAT_PARITY, STAT_STOPBITS);

		return ITS_OK;

	}

	return E_CONNECTIONFAILED;

}

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

// Send a command and associated data

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

int CSTATSerial::Send(const char cIdentifier, const char *pCommand, const unsigned long ulLength)

{

	DWORD dwBytes = 0;

	int ret = E_WRITEFAILED;

	// prepare command

	STATCOMMAND STATSendCommand;

	memset(&STATSendCommand, 0, sizeof(STATCOMMAND));

	STATSendCommand.cIdentifier = cIdentifier;

	STATSendCommand.ulLength = ulLength;

	int result = 0;

	if (result = WriteFile(hComPort, (LPVOID)&STATSendCommand, sizeof(STATCOMMAND), &dwBytes, NULL))

	{

		if (dwBytes == sizeof(STATCOMMAND))

		{

			// only send data if it will fit into our buffer

			if (pCommand && STATSendCommand.ulLength && STATSendCommand.ulLength <= iMaxPacketSize)

			{

				if (WriteFile(hComPort, (LPVOID)pCommand, STATSendCommand.ulLength, &dwBytes, NULL))

				{

					if (dwBytes == STATSendCommand.ulLength)

					{

						SetError("Sent successfully %ld bytes", STATSendCommand.ulLength);

						ret = ITS_OK;

					}

					else

					{

						SetError("Incorrect number of bytes written - expected %ld sent %ld", STATSendCommand.ulLength, dwBytes);

						ret = E_BADNUMBERBYTES;

					}

				}

				else

					SetError("Write data to port failed");

			}

			else

			{

				SetError("Sent successfully");

				ret = ITS_OK;

			}

		}

		else

		{

			int err = ::GetLastError();

			SetError("Incorrect number of bytes written - expected %ld sent %ld", sizeof(STATCOMMAND), dwBytes);

			ret = E_BADNUMBERBYTES;

		}

	}

	else

		SetError("Write command to port failed");

	return ret;

}

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

// Receive a command and associated data

//

// Tries to read a STATCOMMAND structure from the port.  If successful, the length

// of any data following will be specified in the structure.  If extra data, try to

// read this.  If all successful, set the pointers to point to it

//

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

int CSTATSerial::ReceiveBytes( char *buff, unsigned long size )

{

	int ret;

	int err;

	unsigned long bytes_read = 0;

	unsigned long bytes_read_this_iteration = 0;

	// make sure size > 0 otherwise the following semantics fail

	assert( size > 0 );

	// loop until either all bytes have been received or an error occurs

	for( bytes_read = 0; bytes_read < size; bytes_read += bytes_read_this_iteration ) { 

		ret = ReadFile( hComPort, &(buff[bytes_read]), (size - bytes_read), &bytes_read_this_iteration, NULL );

		if( bytes_read_this_iteration == 0 ) {

			return NO_DATA_AT_PORT;

		}

		if( ret == 0 ) {

			err = ::GetLastError();

			SetError( "Error while receiving command - %ld", err );

			return err;

		}

	}

	// everything is OK

	return 0;

}

int CSTATSerial::Receive( char *cIdentifier, char **ppData, unsigned long *pLength )

{

	int ret;

	unsigned long command;

	unsigned long data_length;

	// initialise parameters

	*cIdentifier = 0;

	*ppData = NULL;

	*pLength = 0;

	// get command

	ret = ReceiveBytes( (char*)&command, SP_COMMANDSIZE );

	if( ret != 0 ) {

		return ret;

	}

	static const int MAX_COMMAND = 127;

	if( command > MAX_COMMAND ){

		return INVALID_COMMAND_FORMAT;

	}

	// get length

	ret = ReceiveBytes( (char*)&data_length, SP_LENGTHSIZE );

	if( ret != 0 ) {

		return ret;

	}

	// put these values into the return slots

	*cIdentifier = (char)command;

	*pLength = data_length;

	// if the length is zero then there is no more to do

	if( data_length == 0 ) {

		return ITS_OK;

	}

	// if the length is greater than the buffer size then this is a header packet and we are not

	// supposed to actually read any data from it.

	// if( data_length > SP_BUFFERSIZE ) {

	if( data_length > iMaxPacketSize ) {

		SetError( "Received command ID: %c successfully length %d", (*cIdentifier), (*pLength) );

		return ITS_OK;

	}

	// Otherwise we are about to read some data. We first have to setup the memory management

	// which is done in a pretty ugly way IMAO.

	if( data_length > iBufferLength )

	{

		if( pBuffer ) {

			delete [] pBuffer;

			pBuffer = NULL;

			iBufferLength = 0;

		}

		pBuffer = new char [data_length];

		if( pBuffer == NULL ) {

			SetError( "Unable to allocate %ld bytes of memory to hold data", data_length );

			return E_OUTOFMEM;

		}

		iBufferLength = data_length;

	}

	// now read the data

	ret = ReceiveBytes( pBuffer, data_length );

	if( ret != 0 ) {

		return ret;

	}

	*ppData = pBuffer;

	return ITS_OK;

}

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

// Disconnect from the port

int CSTATSerial::Disconnect(void)

{

	// release previous resources

	if (pBuffer)

	{

		delete [] pBuffer;

		pBuffer = NULL;

		iBufferLength = 0;

	}

	// disconnect

	if (hComPort)

	{

		CloseHandle(hComPort);

		hComPort = (HANDLE)0;

	}

	SetError("Disconnected successfully");

	return ITS_OK;

}

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

// Release resources

int CSTATSerial::Release(void)

{

	Disconnect();

	return ITS_OK;

}

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

//	PRIVATE FUNCTIONS

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

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

// 

bool CSTATSerial::OpenComPort(const char *pAddress)

{

	TCHAR szAddress[256] = {0};

#ifdef UNICODE

	szAddress[0] = (TCHAR)0;

    // Convert to UNICODE.

    MultiByteToWideChar(CP_ACP,					// conversion type

						 0,							// flags

						 pAddress,					// source

						 -1,						// length

						 szAddress,					// dest

						 256);						// length

#else

	strcpy(szAddress, pAddress);

#endif

	// Use device naming for COM port.

	CString port;

	CString address(pAddress);	// Local variable to cope with 

								// wide UNICODE characters.

	port.Format(_T("\\\\.\\%s"), address.operator LPCTSTR());

	if (INVALID_HANDLE_VALUE == (hComPort = CreateFile(port,

					 GENERIC_READ | GENERIC_WRITE,

					 0,

					 NULL,

					 OPEN_EXISTING,

					 FILE_FLAG_WRITE_THROUGH,

					 NULL)))

	{

		SetError("Port [%s] could not be opened", pAddress);

		int err = ::GetLastError();

		hComPort = (HANDLE)0;

		return false;

	}

	COMMTIMEOUTS CommTimeOuts;

	CommTimeOuts.WriteTotalTimeoutMultiplier	= STAT_WRITETOTALTIMEOUTMULTIPLIER; 

	CommTimeOuts.WriteTotalTimeoutConstant		= STAT_WRITETOTALTIMEOUTCONSTANT;

	CommTimeOuts.ReadIntervalTimeout			= STAT_READINTERVALTIMEOUT;

	CommTimeOuts.ReadTotalTimeoutMultiplier		= STAT_READTOTALTIMEOUTMULTIPLIER;

	CommTimeOuts.ReadTotalTimeoutConstant		= STAT_READTOTALTIMEOUTCONSTANT;

	if (!SetCommTimeouts(hComPort, &CommTimeOuts))

	{

		SetError("Comm port timeouts could not be set");

		CloseHandle(hComPort);

		hComPort = (HANDLE)0;

		return false;

	} 

	// Configure the COM port 

	DCB dcb;

	GetCommState(hComPort, &dcb);

	dcb.DCBlength			= sizeof(dcb); 

	dcb.BaudRate			= STAT_BAUDRATE;

	dcb.fBinary				= TRUE;

	dcb.fParity				= STAT_PARITY;

	dcb.fOutxCtsFlow		= TRUE;

	dcb.fOutxDsrFlow		= FALSE;

	dcb.fDtrControl			= DTR_CONTROL_ENABLE;	

	dcb.fDsrSensitivity		= FALSE;

	dcb.fTXContinueOnXoff	= TRUE;

	dcb.fOutX				= FALSE;

	dcb.fInX				= FALSE;

	dcb.fErrorChar			= FALSE;

	dcb.fNull				= FALSE;

	dcb.fRtsControl			= RTS_CONTROL_HANDSHAKE;

	dcb.fAbortOnError		= TRUE;

	dcb.XonLim				= 4096;

	dcb.XoffLim				= 1024;

	dcb.ByteSize			= STAT_BYTESIZE;

	dcb.Parity				= STAT_PARITY;

	dcb.StopBits			= STAT_STOPBITS;

	dcb.XonChar				= 17;

	dcb.XoffChar			= 19;

//	dcb.fRtsControl		= RTS_CONTROL_ENABLE;

//	dcb.BaudRate		= STAT_BAUDRATE;

//	dcb.fOutxCtsFlow	= FALSE;

//	dcb.XonLim			= STAT_XONLIMIT;

//	dcb.XoffLim			= STAT_XOFFLIMIT;

	if (!SetCommState(hComPort, &dcb))

	{

		SetError("Comm port state could not be set");

		CloseHandle(hComPort);

		hComPort = (HANDLE)0;

		return false;

	} 

	return true;

}