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

// AT Command Base Class

// 

//

#include "PHONE.H"

#include "ATIO.H"

#include "mSLOGGER.H"

#include "ATINIT.H"

#include "ATESCAPE.H"

#include "LINE.H"

#include "NOTIFY.H"

#include "sms_rx_queue.h"			// for CReceiveSmsQueue

// Specific GSM Error String Response

_LIT8(KCmsErrorString,"+CMS ERROR:*");

//

// CATParamListEntry

// A pointer to a meaningful result in the received buffer from the modem

//

CATParamListEntry::CATParamListEntry(const TDesC8& aDes) :

	iResultPtr(aDes)

	{

	}

CATParamListEntry::~CATParamListEntry()

	{}

void CATParamListEntry::Deque()

	{

	iLink.Deque();

	}

void CATParamListEntry::EntryValL(CATParamListEntry* aEntry,TInt& aValue)

	{

	if (aEntry==NULL)

		User::Leave(KErrGeneral);

	TLex8 lex(aEntry->iResultPtr);

	(void)User::LeaveIfError(lex.Val(aValue));

	aEntry->Deque();

	delete aEntry;

	}

TInt CATParamListEntry::EntryValL(CATParamListEntry* aEntry)

	{

	TInt val;

	EntryValL(aEntry,val);

	return val;

	}

//

// Async One Shot to call RelinquishOwnershipComplete(). 

// If RelinquishOwnershipComplete() is called synchronously, it destroys the CATIO object

// before the latter has finished processing.

//

CCompleteRelinquish* CCompleteRelinquish::New(CTelObject* aTelObject)

//

//	Create the Relinquish Complete async one shot

//

	{

	// The below TRAP is used to stop leavescan errors occurring.

	// This is not the best solution, but I am pressed for time ;-(

	CCompleteRelinquish* ptr=NULL;

	TRAP_IGNORE(ptr=new(ELeave)CCompleteRelinquish(aTelObject));

	return ptr;

	}

CCompleteRelinquish::CCompleteRelinquish(CTelObject* aTelObject)

//

// C'tor

//

	:CAsyncOneShot(CActive::EPriorityLow), iTelObject(aTelObject)

	{

	__DECLARE_NAME(_S("CCompleteRelinquish"));

	}

CCompleteRelinquish::~CCompleteRelinquish()

	{

	Cancel();

	}

void CCompleteRelinquish::RunL()

//

// Call RelinquishOwnershipCompleted() or RecoverDataPortAndRelinquishOwnershipCompleted()

// after CATIO has finished its processing

//

	{

	__ASSERT_ALWAYS(iPanicOccurred!=ENoPanicOccurred,Panic(EIllegalPanicOccurredValue));

	if (iPanicOccurred == EPanicOccurredWithoutDataPortLoan)

		{

		REINTERPRET_CAST(CCallBase*,iTelObject)->RelinquishOwnershipCompleted(KErrNone);

		}

	if (iPanicOccurred == EPanicOccurredDuringDataPortLoan)

		{

		REINTERPRET_CAST(CCallBase*,iTelObject)->RecoverDataPortAndRelinquishOwnershipCompleted(KErrNone);

		}

	delete this;

	}

//

// The Command Base Class

//

CATBase::CATBase(CATIO* aIo, CTelObject* aTelObject,CPhoneGlobals* aPhoneGlobals)

	: iIo(aIo),iPhoneGlobals(aPhoneGlobals),iComplete(NULL),iTelObject(aTelObject),iCallInfo(NULL)

	{

	iRxResults.SetOffset(_FOFF(CATParamListEntry,iLink));

	}

CATBase::~CATBase()

//

//	Assumes CATIO pointer is still valid

//

	{

	if(!iRxResults.IsEmpty())

		{

		CATParamListEntry* entry;

		TDblQueIter<CATParamListEntry> iter(iRxResults);

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

			{

			entry->Deque();

			delete entry;

			}

		}

	}

void CATBase::GenericEventSignal(TEventSource aEventSource, TInt aStatus)

//

//	If an IO error has occurred, complete this ATBase-object with the error. 

//

	{		

	if (aStatus!=KErrNone)

		{

		LOGTEXT2(_L8("EventSignal received error status %d"),aStatus);

		CompleteWithIOError(aEventSource,aStatus);

		}

	else

		{

		EventSignal(aEventSource);

		}

	}

void CATBase::AddStdExpectStrings()

	{

	if (!iOKExpectString)

		iOKExpectString=iIo->AddExpectString(this,KOkString);

	if (!iErrorExpectString)

		iErrorExpectString=iIo->AddExpectString(this,KErrorString);

	}

TInt CATBase::ValidateExpectString()

/**

 * New version ValidateExpectStringL which returns an error code

 * as opposed to leaving. 

 * Use of this new code should hopefully remove alot of 

 * unesseccary TRAP harness in the TSY.

 */

 	{

	TInt ret(KErrNone);

	if(iIo->FoundChatString()!=iOKExpectString)

		{

		if(iIo->FoundChatString()==iErrorExpectString)

			{

			LOGTEXT(_L8("Modem returned ERROR in response to command"));

			ret=KErrGeneral;

			}

		else

			{

			LOGTEXT(_L8("Modem returned unexpected response to command"));

			ret=KErrUnknown;

			}

		}

	return ret;

	}

void CATBase::RemoveStdExpectStrings()

	{

	LOGTEXT(_L8("RemoveStdExpectStrings()"));

	iIo->RemoveExpectString(iOKExpectString);

	iOKExpectString=NULL;

	iIo->RemoveExpectString(iErrorExpectString);

	iErrorExpectString=NULL;

	}

void CATBase::RemoveUnsolicitedStrings()

	{

	LOGTEXT(_L8("RemoveUnsolicitedStrings()"));

	_LIT8(KNetworkRegistration,"+CREG:");						// Network registration

	_LIT8(KIncomingCallIndication,"RING");						// Normal Ring

	_LIT8(KIncomingExtCallIndication,"+CRING:");				// Extended format call

		_LIT8(KIncomingExtNTCallParameter,"REL");				// Non-Transparent parameter

		_LIT8(KIncomingExtAlternatingCallParameter,"ALT");		// Unsupported Alternating parameter

		_LIT8(KIncomingExtVoiceRelCallParameter,"VOICE/REL");	// NT Voice parameter

	if(!iRxResults.IsEmpty())

		{

		TInt aQueueSteps = NULL;

		CATParamListEntry* entry;

		TDblQueIter<CATParamListEntry> iter(iRxResults);

		// Step along the queue looking for an unsolicited strings

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

			{

			TPtrC8 aResult(entry->iResultPtr);

			// If a match is found, we dequeue it and all its expected parameters

			if (aResult==KIncomingCallIndication) // 0 Params

				{

				// Remove the "RING"

				entry->Deque(); delete entry;

				LOGTEXT2(_L8("Unsolicited >%S< Removed"),&aResult);

				}

	        else if (aResult==KIncomingExtCallIndication) // 1/2 Params 			    

				{

				// Remove the "+CRING:"

				entry->Deque(); delete entry; entry = iter++;

				LOGTEXT2(_L8("Unsolicited >%S< Removed"),&aResult);

				// We know we should be getting at least one and maybee two parameters

				TPtrC8 aFirstParameterResult(entry->iResultPtr);

				if (aFirstParameterResult==KIncomingExtNTCallParameter

				 || aFirstParameterResult==KIncomingExtVoiceRelCallParameter

				 || aFirstParameterResult==KIncomingExtAlternatingCallParameter)

					{

					// We have an "ALT" or a "REL" so we have two parameters

					entry->Deque(); delete entry; entry = iter++;

					TPtrC8 aSecondParameterResult(entry->iResultPtr);

					entry->Deque(); delete entry;	// If recognised parameter - remove

					LOGTEXT3(_L8("Unsolicited Parameter >%S %S< Removed"),&aFirstParameterResult,&aSecondParameterResult); aSecondParameterResult==KIncomingCallIndication; // Quick fix to remove unused parameters make warning

					}

				else

					{

					// We only have one parameter

					entry->Deque(); delete entry;	// If recognised parameter - remove

					LOGTEXT2(_L8("Unsolicited Parameter >%S< Removed"),&aFirstParameterResult);

					}

				}

			else if (aResult==KNetworkRegistration) // 2 Params

				{

				// Remove the "+CREG:"

				entry->Deque(); delete entry; entry = iter++;

				LOGTEXT2(_L8("Unsolicited >%S< Removed"),&aResult);

				// Remove both parameters

				TPtrC8 aFirstParameterResult(entry->iResultPtr);

				entry->Deque(); delete entry; entry = iter++;

				TPtrC8 aSecondParameterResult(entry->iResultPtr);

				entry->Deque(); delete entry;

				LOGTEXT3(_L8("Unsolicited Parameters >%S,%S< Removed"),&aFirstParameterResult,&aSecondParameterResult); aFirstParameterResult==KIncomingCallIndication; aSecondParameterResult==KIncomingCallIndication; // Quick fix to remove unused parameters make warning

				}

			// Increment the queue step counter 

			else aQueueSteps++;

			}

		// Now we have to retrace the list, ignoring dequeued entries

		for (TInt aLoop=NULL;aLoop<aQueueSteps;aLoop++) 

			iter--;

		}

	}

void CATBase::CleanupRxResults(TAny *aCATBase)	// for TCleanupOperation

	{

	CATBase* p= reinterpret_cast<CATBase*>(aCATBase);

	TDblQueIter<CATParamListEntry> iter(p->iRxResults);

	CATParamListEntry* entry=iter++;

	while (entry!=NULL)

		{

		entry->Deque();

		delete entry;

		entry=iter++;

		}

	}

void CATBase::RxResultsPushLC()

	{

	TCleanupItem cleanup(CleanupRxResults,this);

	CleanupStack::PushL(cleanup);

	}

void CATBase::ParseBufferLC(TBool aReportLists, TUint aSeparatorChar)

//

//  Parses buffer.  Treats aSeparatorChar like a comma

//

	{

	LOGTEXT(_L8("Parse the Buffer List"));

	if (iIo->CurrentLine()==KOkString)

		iIo->ClearCurrentLine();	// remove trailing "OK"

	iBuffer.Set(iIo->Buffer());

	iIo->ClearBuffer();

	ParseLC(aReportLists, aSeparatorChar);

	}

void CATBase::ParseLineLC(TBool aReportLists, TUint aSeparatorChar)

//

//  Parses current line.  Treats aSeparatorChar like a comma

//

	{

	LOGTEXT(_L8("Parse the current line"));

	iBuffer.Set(iIo->CurrentLine());

	iIo->ClearCurrentLine();

	ParseLC(aReportLists, aSeparatorChar);

	}

void CATBase::AddParamL(const TDesC8 &aPtr)

	{

	CATParamListEntry* aParamListEntry = new (ELeave) CATParamListEntry(aPtr);

	iRxResults.AddLast(*aParamListEntry);

	}

void CATBase::ParseLC(TBool aReportLists, TUint aSeparatorChar)

// 

// Does the actual parsing of iBuffer, set up from ParseLineLC or ParseBufferLC

//

	{

_LIT8(KOpenBracket,  "(");

_LIT8(KCloseBracket, ")");

#ifdef __LOGDEB__

	TPtrC8 buf(iBuffer);

	if (buf.Length()>180) 

		{

		buf.Set(buf.Left(180));

		LOGTEXT2(_L8("buffer to parse >%S< and so on ..."),&buf);

		}

	else

		LOGTEXT2(_L8("buffer to parse >%S<"),&buf);

#endif

	RxResultsPushLC();

	TLex8 yyLex(iBuffer);

	//	Move cursor past any spaces or open brackets

	yyLex.SkipSpace();

	TChar peek=yyLex.Peek();

	if (peek=='(' || peek=='[' || peek=='{')

		yyLex.Inc();

	if (aReportLists && peek=='(')

		{

		AddParamL(KOpenBracket);

		LOGTEXT2(_L8("list separator >%S<"),&iRxResults.Last()->iResultPtr);

		}

	do

		{

		// Skip all space and opening brackets

		for (;;)

			{

			yyLex.SkipSpace();

			if (yyLex.Eos())

				return;

			peek = yyLex.Peek();

			if (peek!='(')

				break;

			if (aReportLists)

				{

				AddParamL(KOpenBracket);

				LOGTEXT2(_L8("list separator >%S<"),&iRxResults.Last()->iResultPtr);

				}

			yyLex.Inc();

			}

		if (peek=='"')		// start of quoted string

			{

			yyLex.Inc();	// step over the quote

			yyLex.Mark();

			while (!yyLex.Eos())

				{

				peek=yyLex.Peek();

				if (peek=='"')

					break;

				yyLex.Inc();

				}

			AddParamL(yyLex.MarkedToken());

			LOGTEXT2(_L8("quoted parameter >%S<"),&iRxResults.Last()->iResultPtr);

			if (yyLex.Eos())

				return;

			// Skip all space and closing brackets

			for (;;)

				{

				yyLex.Inc();

				yyLex.SkipSpace();

				if (yyLex.Eos())

					return;

				peek = yyLex.Peek();

				if (peek!=')')

					break;

				if (aReportLists)

					{

					AddParamL(KCloseBracket);

					LOGTEXT2(_L8("list separator >%S<"),&iRxResults.Last()->iResultPtr);

					}

				}

			// Skip any following separator

			if (peek==',' || peek==aSeparatorChar)

				{

				yyLex.Inc();

				yyLex.SkipSpace();

				if (yyLex.Eos())

					return;

				peek=yyLex.Peek();

				}

			}

		else // if (peek!=',' && peek !='(' && peek!='"' && peek!=aSeparatorChar)		

			{

			yyLex.Mark();

			while (peek!=',' && !peek.IsSpace() && peek!=')' && peek!=']' && peek!='}' && peek!=aSeparatorChar)

				{

				yyLex.Inc();

				if (yyLex.Eos())

					break;

				peek=yyLex.Peek();

				if ((peek==':')&&(aSeparatorChar!=':'))

					{

					yyLex.Inc();

					break;

					}

				}

			AddParamL(yyLex.MarkedToken());

			LOGTEXT2(_L8("normal parameter >%S<"),&iRxResults.Last()->iResultPtr);

			if (yyLex.Eos())

				return;

			// skip any whitespace and closing brackets

			for (;;)

				{

				yyLex.SkipSpace();

				if (yyLex.Eos())

					return;

				peek = yyLex.Peek();

				if (peek!=')')

					break;

				if (aReportLists)

					{

					AddParamL(KCloseBracket);

					LOGTEXT2(_L8("list separator >%S<"),&iRxResults.Last()->iResultPtr);

					}

				yyLex.Inc();

				}

			// Skip any following separator

			if (peek==',' || peek==aSeparatorChar)

				{

				yyLex.Inc();

				yyLex.SkipSpace();

				if (yyLex.Eos())

					return;

				peek=yyLex.Peek();

				}

			}

		} while (peek!=')'&& peek!=']'&& peek!='}');

	if (aReportLists && peek==')')

		{

		AddParamL(KCloseBracket);

		LOGTEXT2(_L8("list separator >%S<"),&iRxResults.Last()->iResultPtr);

		}

	}

void CATBase::ChangeCallStatus(RMobileCall::TMobileCallStatus aCallStatus)

//

//	This is called from a phone-based command as it is overloaded in CATCallAlterCommands.

//

	{

	if (iCallInfo->iMobileStatus != aCallStatus)

		{

		iCallInfo->iMobileStatus = aCallStatus;

		if (aCallStatus == RMobileCall::EStatusIdle)

			{

			iCallInfo->iHookStatus = RCall::EHookStatusOn;

			iPhoneGlobals->iNotificationStore->CheckNotification(iTelObject,EBecomeIdle);

			}

		else if (aCallStatus != RMobileCall::EStatusUnknown && aCallStatus != RMobileCall::EStatusRinging)

			{

			iCallInfo->iHookStatus = RCall::EHookStatusOff;

			}

		}

	}

void CATBase::ChangeLineStatus(RCall::TStatus aLineStatus)

	{

	iPhoneGlobals->iPhoneStatus.iLineStatus = aLineStatus;

	}

void CATBase::SetToNotInitialised()

	{

	iPhoneGlobals->iPhoneStatus.iMode = RPhone::EModeUnknown;

	iPhoneGlobals->iPhoneStatus.iDataAndFaxFlags = RPhone::KCapsUnknown;

	iPhoneGlobals->iPhoneStatus.iInitStatus = EPhoneNotInitialised;

	}

void CATBase::StandardWriteCompletionHandler(TEventSource aSource,TInt aTimeOut)

	{

	__ASSERT_ALWAYS(aSource==EWriteCompletion,Panic(EATCommand_IllegalCompletionWriteExpected));

	iIo->SetTimeOut(this,aTimeOut * KOneSecondPause);

	AddStdExpectStrings();

	}

void CATBase::Write(const TDesC8& aCommand,TInt aTimeOut)

	{

	iTxBuffer.Format(KStringFormatString,&aCommand);

	iIo->Write(this,iTxBuffer);

	iIo->SetTimeOut(this,aTimeOut * KOneSecondPause);

	}

void CATBase::Write(const TDesC8& aCommand,TInt aTimeOut,TInt aValue)

	{

	iTxBuffer.Format(KStringAndIntegerFormatString,&aCommand,aValue);

	iIo->Write(this,iTxBuffer);

	iIo->SetTimeOut(this,aTimeOut * KOneSecondPause);