// Copyright (c) 1997-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:

// Serial IO Functions

// 

//

#include "ATIO.H"

#include "mSLOGGER.H"

#include "ATERROR.H"

//

// CCompletionEntry

//

CCompletionEntry* CCompletionEntry::NewL(CCommChatString* aCs,	CATBase* aAtCommand)

	{

	return new(ELeave) CCompletionEntry(aCs,aAtCommand);

	}

CCompletionEntry::CCompletionEntry(CCommChatString* aCs, CATBase* aAtCommand) : iCs(aCs), iAtCommand(aAtCommand)

	{}

CCompletionEntry::~CCompletionEntry()

	{}

//

// CATIo

//

CATIO* CATIO::NewL(TFileName& aCsy, TName& aPort,TPortAccess& aPortAccess)

	{

	CATIO* atIo=new(ELeave) CATIO(aPortAccess);

	CleanupStack::PushL(atIo);

	atIo->ConstructL(aCsy,aPort);

	CleanupStack::Pop();

	LOGTEXT2(_L8("CATIO::NewL returns 0x%x"),atIo);

	return atIo;

	}

CATIO::CATIO(TPortAccess& aPortAccess)

	: iPortAccess(aPortAccess)

	{

	iExpectList.SetOffset(_FOFF(CCompletionEntry,iLink));

	}

void CATIO::ConstructL(TFileName& aCsy, TName& aPort)

	{

	iCsy=aCsy;

	CommConstructL(KCommReadPriority,KCommWritePriority);

	iChat = new (ELeave) CCommChatter(this, KChatterPriority);

	iChat->CreateL(KChatBufferSize);

	{		// Braces scope the lifetime of tmpCsy and tmpPort

	TBuf8<KMaxFileName> tmpCsy;

	TBuf8<KMaxName> tmpPort;

	tmpCsy.Copy(aCsy);		// Convert parameter to 8 bit string

	tmpPort.Copy(aPort);	// Convert parameter to 8 bit string

	LOGTEXTREL3(_L8("CATIO::ConstructL Attempting open csy:%S port:%S"),&tmpCsy,&tmpPort);

	}

	TInt ret = CommOpen(aCsy, aPort, ECommShared);

	if(ret == KErrAccessDenied || ret == KErrInUse)

		iPortAccess=EPortAccessDenied;

	else

		(void)User::LeaveIfError(ret);

	LOGTEXTREL(_L8("CATIO::ConstructL Open successful"));

	iChatStringFound= new(ELeave) CArrayFixFlat<CCommChatString*>(5);

	}

CATIO::~CATIO()

	{

	delete iChatStringFound;

	delete iChat;

	}

TInt CATIO::ConfigurePort(TCommConfig aConfiguration)

	{

	if (iPortAccess==EPortAccessAllowed)

		{

		TInt ret;

		TCommConfig cbuf;

		TCommConfigV01 &cfg=cbuf();

		iCommPort.Config(cbuf);							// Get the Configuration

		TCommConfigV01 &newCfg=aConfiguration();

		cfg.iRate=newCfg.iRate;

		cfg.iDataBits=newCfg.iDataBits;

		cfg.iStopBits=newCfg.iStopBits;

		cfg.iParity=newCfg.iParity;

		cfg.iHandshake=newCfg.iHandshake;

		ret = iCommPort.SetConfig(cbuf);				// Set the Configuration

		if(ret!=KErrNone)

			{

			LOGTEXT2(_L8("CATIO:\tError %d configuring port"),ret);

			return ret;

			}

		}

	return KErrNone;

	}

TInt CATIO::GetPortShutdownTimeout()

	{

	if (iPortAccess==EPortAccessAllowed)

		{

		TCommConfig2 cbuf;

		TCommConfigV02& cfg=cbuf();

		iCommPort.Config(cbuf);				// Get the Configuration

		return (cfg.iTxShutdownTimeout);

		}

	else

		return (0);

	}

TInt CATIO::SetPortShutdownTimeout(TInt aTimeout)

	{

	if (iPortAccess==EPortAccessAllowed)

		{

		TCommConfig2 cbuf;

		TCommConfigV02 &cfg=cbuf();

		iCommPort.Config(cbuf);				// Get the Configuration

		cfg.iTxShutdownTimeout = aTimeout;

		return (iCommPort.SetConfig(cbuf));	// Set the Configuration

		}

	else

		return KErrAccessDenied;

	}

void CATIO::Start(CATBase* aCompletionClass)

	{

	CommReadReady();

	StartWrite(aCompletionClass);

	}

void CATIO::StartWrite(CATBase* aCompletionClass)

	{

	if (iPortAccess==EPortAccessAllowed)

		{

		iWriteCommand=aCompletionClass;

		CommWriteReady();

		iWritePending=ETrue;

		}

	}

TPtrC8 CATIO::Buffer() const

	{

	return iChat->Buffer();

	}

TInt CATIO::BufferFindF(const TDesC8& aDes) const

	{

	return iChat->Buffer().FindF(aDes);

	}

TPtrC8 CATIO::CurrentLine() const

	{

	return iChat->CurrentLine();

	}

void CATIO::ClearBuffer()

	{

	if(!iPreserveBuffer)

		iChat->ClearBuffer();

	}

void CATIO::ClearCurrentLine()

	{

	iChat->ClearCurrentLine();

	}

void CATIO::CommReadComplete(TInt aStatus)

	{

	LOGTEXT(_L8("Read Completion"));

	__ASSERT_ALWAYS(iReadPending,Panic(EATCommand_IllegalCompletionReadNotExpected));

	if (aStatus==KErrCommsLineFail)

		{

		if (iSecondChanceForCommsError++!=1)	

			aStatus=KErrNone;		// only signal error if get 2 KErrCommsLineFail's in succession

		else

			iSecondChanceForCommsError=0;

		}

	if (aStatus!=KErrNone)

		{

		SignalCommandsWithError(aStatus);

		return;

		}

	iReadPending = EFalse;

	TRAPD(ret,ProcessReadCharsL());

	if(ret!=KErrNone)

		{

		Cancel();	// This error cannot be related to a command - so they'll all be cleaned up.

		iChat->DeleteAllAndStop();

		}

	}

void CATIO::SignalCommandsWithError(TInt aStatus)

//

//	Complete all current AT commands with the error and call the error handler

//

	{	

	LOGTEXT2(_L8("Received an error of %d"),aStatus);

	Cancel();

	CCompletionEntry* ce;

	TDblQueIter<CCompletionEntry> iter(iExpectList);

	while (ce = iter, ce!=NULL)

		{

		ce->iAtCommand->GenericEventSignal(EReadCompletion,aStatus);

		iter.SetToLast();

		CCompletionEntry* removeSimilar;

		while (removeSimilar=iter--, removeSimilar!=ce)

			{

			if(removeSimilar && removeSimilar->iAtCommand==ce->iAtCommand)

				{

				iChat->RemoveString(removeSimilar->iCs);

				delete removeSimilar->iCs;

				removeSimilar->iLink.Deque();

				delete removeSimilar;

				}

			}

		iChat->RemoveString(ce->iCs);

		delete ce->iCs;

		ce->iLink.Deque();

		delete ce;

		iter.SetToFirst();

		}

	// Reset TSY status, complete notifications and re-add some expect strings

	iErrorHandler->CleanUp(aStatus);

	}

void CATIO::ProcessReadCharsL()

	{

	LOGTEXT2(_L8("Received %d"),iRxBuf.Length());

	LOGTEXTREL2(_L8("Rx:\t%S"),&iRxBuf);

	TBool hitFlag=EFalse;

	TInt len;

	for (iRxBufOffset=0; iRxBufOffset<iRxBuf.Length(); iRxBufOffset++)

		{

		iChat->AddCharL(iRxBuf[iRxBufOffset]);

// Check for hits and one up-call per hit NOW

		if((len=iChatStringFound->Count())>0)

			{

			for(TInt i=0;i<len;i++)

				{

				hitFlag=ETrue;

// Find the AT Command to complete

				CCompletionEntry* ce;

				TDblQueIter<CCompletionEntry> iter(iExpectList);

				TBool aFoundFlag=EFalse;

				while (ce = iter++, ce!=NULL)

					{

					if(ce->iCs==iChatStringFound->At(i))

						{

						iCurrentFoundChatString=ce->iCs;

						ce->iAtCommand->GenericEventSignal(EReadCompletion,KErrNone);

						aFoundFlag=ETrue;

						break;

						}

					}

				if(!aFoundFlag)

					{

					LOGTEXT(_L8("Internal Error - Chat String signalled, but not found"));

					User::Leave(KErrGeneral);

					}

				}

			iChatStringFound->Delete(0,iChatStringFound->Count());

			}

		}

	if(hitFlag)

		{

		//iReadPending=EFalse;

		Read();							// Queue Another...

		}

	else

		{

		iReadPending = ETrue;

		CommReadOneOrMore(iRxBuf);

		}

	}

void CATIO::SetPreserveBufferFlag(TBool aFlg)

//

// Set Preserve Buffer Flag

//

	{

	iPreserveBuffer=aFlg;

	}

CCommChatString* CATIO::FoundChatString()

	{

	return iCurrentFoundChatString;

	}

CCommChatString* CATIO::AddExpectString(CATBase* aATBase, const TDesC8& aString, TBool aPartLine)

	{

	CCommChatString* cs=NULL;

	TRAPD(err,cs=DoAddExpectStringL(aATBase,aString,aPartLine));

	if(err==KErrNone)

		LOGTEXT2(_L8("CATIO::AddExpectString added %S"),&aString);

	else

		{

		cs=NULL;

		LOGTEXT2(_L8("CATIO::AddExpectString FAILED TO ADD %S"),&aString);

		}

	return cs;

	}

CCommChatString* CATIO::DoAddExpectStringL(CATBase* aATBase, const TDesC8& aString, TBool aPartLine)

	{

	CCommChatString* cs=iChat->AddStringL(aString, aPartLine);		

	CCompletionEntry* completionEntry=CCompletionEntry::NewL(cs,aATBase);

	iExpectList.AddLast(*completionEntry);

	return cs;

	}

void CATIO::RemoveExpectString(CCommChatString* aExpectString)

	{

// Find the AT Command to complete

	CCompletionEntry* ce;

	TDblQueIter<CCompletionEntry> iter(iExpectList);

	while (ce = iter++, ce!=NULL)

		{

		if(ce->iCs==aExpectString)

			{

			iChat->RemoveString(ce->iCs);

			delete ce->iCs;

			ce->iLink.Deque();

			delete ce;

			break;

			}

		}

	}

void CATIO::RemoveExpectStrings(CATBase* aATBase)

	{

// Find the AT Command to complete

	CCompletionEntry* ce;

	TDblQueIter<CCompletionEntry> iter(iExpectList);

	while (ce = iter++, ce!=NULL)

		{

		if(ce->iAtCommand==aATBase)

			{

			iChat->RemoveString(ce->iCs);

			delete ce->iCs;

			ce->iLink.Deque();

			delete ce;

			}

		}

	}

void CATIO::CommWriteComplete(TInt aStatus)

	{

	LOGTEXT(_L8("Comm Write Completion"));

	iChat->StopTimer();

	__ASSERT_ALWAYS(iWritePending,Panic(EATCommand_IllegalCompletionWriteNotExpected));

//	if(!iWritePending)

//		aStatus=KErrIllegalWriteComplete;						// No Write Queued!

	iWritePending=EFalse;

	iWriteCommand->GenericEventSignal(EWriteCompletion,aStatus);

	}

void CATIO::ChatStringMatchL(CCommChatString* aCs)

	{

	iStringFound=ETrue;

	iChatStringFound->AppendL(aCs);

	}

void CATIO::ChatTimeout()

	{

	LOGTEXT(_L8("Chat Time-out Completion"));

	if(iWaitTimerPending)

		{

		iWaitTimerPending=EFalse;

		iTimeOutCommand->GenericEventSignal(ETimeOutCompletion,KErrNone);

		}

	else

		Panic(EATCommand_IllegalWaitCompletion);

	}

void CATIO::SetTimeOut(CATBase* aCompletionClass, TUint aTimePeriodMillisec)

	{

	iTimeOutCommand=aCompletionClass;

	iChat->StartTimer(aTimePeriodMillisec*1000);

	iWaitTimerPending=ETrue;

	}

void CATIO::Read()

 	{

	if (iPortAccess==EPortAccessAllowed && iReadPending==FALSE)

		{

 		iReadPending=ETrue;

		iStringFound=EFalse;

		CommReadOneOrMore(iRxBuf);

		iRxBufOffset = 0;

		LOGTEXT(_L8("Queued a Read"));

		}

	}

void CATIO::Write(CATBase* aCompletionClass, const TDesC8& aString)

	{

	if (iPortAccess==EPortAccessAllowed)

		{

		ClearBuffer();	// assume previous responses fully processed

		iWriteCommand=aCompletionClass;

		iWritePending=ETrue;

		CommWrite(aString);

		if (aString.Length() > 350)

			{	

			LOGTEXT2(_L8("CATIO:\taString too big! Length:%d"), aString.Length());

			}	

		else

			{

			LOGTEXTREL2(_L8("Tx:\t%S"),&aString);

			}

		LOGTEXT(_L8("Queued a Transmission"));

		}

	}

TBool CATIO::ReadPending()

	{

	return iReadPending;

	}

void CATIO::Disconnect()

	{

	if (iPortAccess == EPortAccessAllowed)

		{

		TCommConfig cbuf;

		TCommConfigV01 &cfg=cbuf();

		iCommPort.Config(cbuf);

		cfg.iHandshake = KConfigFreeRTS	| KConfigFreeDTR;

		TInt ret=iCommPort.SetConfig(cbuf);

		if (ret == KErrNone)

			iCommPort.SetSignalsToSpace(KSignalRTS | KSignalDTR);

		}

	CommClose();

	iPortAccess = EPortAccessDenied;

	}

void CATIO::Cancel()

	{

	LOGTEXT(_L8("CATIO:\tCancel called"));

	CommCancel();

	iReadPending = EFalse;

	iWritePending = EFalse;

	iChat->StopTimer();

	}

void CATIO::ReadCancel()

	{

	LOGTEXT(_L8("CATIO:\tReadCancel called"));

	CommReadCancel();

	iReadPending = EFalse;

	}

void CATIO::WriteAndTimerCancel(CATBase* aATBase)

	{

	if (aATBase==iWriteCommand)

		{

		CommWriteCancel();

		}

	if (aATBase==iTimeOutCommand)

		{

		iChat->StopTimer();

		}

	}

void CATIO::DropDtr()

	{

	if (iPortAccess==EPortAccessAllowed)

		{

		LOGTEXT(_L8("CATIO::DropDtr Dropping DTR"));

		iCommPort.SetSignals(0,KSignalDTR);

		}

	}

void CATIO::RaiseDTR()

	{

	if (iPortAccess==EPortAccessAllowed)

		{

		LOGTEXT(_L8("CATIO::RaiseDTR Raising DTR"));

		iCommPort.SetSignals(KSignalDTR,0);

		}

	}

void CATIO::ResetReadAndWriteBuffers()

	{

	iCommPort.ResetBuffers();

	}

TInt CATIO::GetSizeOfRxBuffer()

	{

	return iCommPort.QueryReceiveBuffer();

	}

TUint CATIO::Signals()

	{

	return iCommPort.Signals();

	}

void CATIO::DropRTS()

	{

	if (iPortAccess==EPortAccessAllowed)

		{

		LOGTEXT(_L8("Dropping RTS"));

		iCommPort.SetSignals(0,KSignalRTS);

		}

	}

void CATIO::RaiseRTS()

	{