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

#include <etelmm.h>				// for RMobileSmsMessaging::TMobileSmsReceiveAttributesV1
#include "mSLOGGER.H"			// for LOGTEXT2 and other logging utilities
#include "ATIO.H"			
#include "Matstd.h"
#include "cmt_unstored.h"		// header file for this cpp file
#include "sms_rx_queue.h"		// for CReceiveSmsQueue

#ifdef __LOGDEB__
_LIT8(KLogEntry,"CATSmsWaitForAndHandleCMTUnstored::%S\t%S");
#define LOCAL_LOGTEXT(function,text) {_LIT8(F,function);_LIT8(T,text);LOGTEXT3(KLogEntry,&F,&T);}
#else
#define LOCAL_LOGTEXT(function,text)
#endif


CATSmsWaitForAndHandleCMTUnstored* CATSmsWaitForAndHandleCMTUnstored::NewL(CATIO* aIo,CTelObject* aTelObject, CPhoneGlobals* aGlobals,
									                                     CReceiveSmsQueue& aReceiveQueue)
	{
	CATSmsWaitForAndHandleCMTUnstored* wait=new(ELeave) CATSmsWaitForAndHandleCMTUnstored(aIo,aTelObject,aGlobals,aReceiveQueue);
	// Currently no need for a ConstructL call
	return wait;
	}

CATSmsWaitForAndHandleCMTUnstored::CATSmsWaitForAndHandleCMTUnstored(CATIO* aIo, CTelObject* aTelObject,
												   CPhoneGlobals* aGlobals, CReceiveSmsQueue& aReceiveQueue) 
	:CATBase(aIo,aTelObject,aGlobals)
	,iReceiveQueue(aReceiveQueue)
	{}


CATSmsWaitForAndHandleCMTUnstored::~CATSmsWaitForAndHandleCMTUnstored()
	{
	iIo->RemoveExpectStrings(this);	
	// We do not need to NULL iCMTExpectString and iCDSExpectString
	// as this object is about to de destroyed
	}

void CATSmsWaitForAndHandleCMTUnstored::Enable()
	{
	LOCAL_LOGTEXT("Enable","Enabled listening for CMT & CDS");

	if (iState==ENoState)
		{
		iState=EWaitForCMT;
		
		// Add +CMT:* expect string
		if (!iCMTExpectString)
			iCMTExpectString=iIo->AddExpectString(this,KCMTMatchString);

		// Add +CDS:* expect string
		if (!iCDSExpectString)
			iCDSExpectString=iIo->AddExpectString(this,KCDSMatchString);
		}
	}

void CATSmsWaitForAndHandleCMTUnstored::Disable()
	{
	LOCAL_LOGTEXT("Disable","Disabled listening for CMT & CDS");
	
	if (iState!=EWaitForCmtSecondLine)
		{
		iIo->RemoveExpectStrings(this);		
		iCMTExpectString=NULL;
		iCDSExpectString=NULL;
		iState=ENoState;
		}
	else
		{
		// wait to receive message we're half-way through before disabling
		iState=EWaitForCmtSecondLineThenDisable;
		}
	}


void CATSmsWaitForAndHandleCMTUnstored::EventSignal(TEventSource aSource)
/**
 * Called when a '+CMT:' or '+CDS:' is received.
 * +CMT: [<alpha>],<length><CR><LF><pdu>
 * +CDS: <length><CR><LF><pdu>
 *
 * This is a two state machine that first waits for the +CMT: [<alpha>],<length><CR><LF>
 * and then waits for the final <pdu>
 *
 * When a PDU has been read from the phone, it is pushed into the CReceiveSmsQueue.
 */
	{
	TInt ret(KErrNone);
	iIo->WriteAndTimerCancel(this);
	LOCAL_LOGTEXT("EventSignal","Enter function");
		
	switch(iState)
		{
	case EWaitForCMT:
		LOCAL_LOGTEXT("EventSignal","EWaitForCMT");
		__ASSERT_ALWAYS(aSource == EReadCompletion, Panic(EATCommand_IllegalCompletionReadExpected));
		
		TRAP(ret,ParseFirstCMTLineL(iPduLen));
		if(ret!=KErrNone)
			{
			LOCAL_LOGTEXT("EventSignal","Failed to parse 1st line");
			// No need for more error handling - just wait for next CMT
			}
		else
			{
			//
			// Add the expect string * so that we receive whatever is on the next line
			// (the conditional expression below ensures no memory leak if "+CMT:"
			// is found on consecutive lines)
			if(!iWaitForAnything)
				iWaitForAnything=iIo->AddExpectString(this,KAsterisk);
		
			//
			// We need to keep the buffered data so we...
			iIo->SetPreserveBufferFlag(ETrue);			

			//
			// Wait for the reception of the second line
			iState=EWaitForCmtSecondLine;
			}
		break;

	case EWaitForCmtSecondLine:
	case EWaitForCmtSecondLineThenDisable:

		LOCAL_LOGTEXT("EventSignal","EWaitForCmtSecondLine");
		__ASSERT_ALWAYS(aSource == EReadCompletion,Panic(EATCommand_IllegalCompletionReadExpected));
		iIo->RemoveExpectString(iWaitForAnything);
		iWaitForAnything=NULL;
		iIo->SetPreserveBufferFlag(EFalse);			// We've got the PDU, and will delete the buffer when the line is parsed

		{		// Curly brackets used to scope pdu and attr local data
		//
		// Parse and Push received message into CReceiveSmsQueue
		RMobileSmsMessaging::TMobileSmsGsmTpdu pdu;
		RMobileSmsMessaging::TMobileSmsReceiveAttributesV1 attr;
		TRAPD(ret,ParseSecondCMTLineL(pdu,attr));
		if(ret!=KErrNone)
			{
			LOCAL_LOGTEXT("EventSignal","Failed to parse 2nd line");
			}
		else
			{
			LOCAL_LOGTEXT("EventSignal","Adding SMS to iReceiveQueue");
			iReceiveQueue.Push(pdu,attr);
			}
		}

		//
		// We are done, but there is no client request to complete
		// we just return and wait until we get our next CMT command
		// unless we should disable now
		if (iState==EWaitForCmtSecondLineThenDisable)
			Disable();
		else
			iState=EWaitForCMT;
		break;

	case ENoState:
	default:
		// We should never get here, but we don't need to panic in release code.
		__ASSERT_DEBUG(EFalse,Panic(EATWaitForCMTNoState));
		break;
		} 
	}



void CATSmsWaitForAndHandleCMTUnstored::ParseFirstCMTLineL(TInt& aPduLen)
/**
 * Parse 1st line of CMT response, of the format: "+CMT: [<alpha>], <pdu_len>"
 * Stores the <pdu_len> in aPduLen
 */
	{
	ParseLineLC();

	CATParamListEntry* entry;
	CATParamListEntry* alpha;
	TDblQueIter<CATParamListEntry> iter(iRxResults);

	entry=iter++;
	if (entry==NULL || (entry->iResultPtr!=KCMTResponseString && entry->iResultPtr!=KCDSResponseString))
		{
		LOCAL_LOGTEXT("ParseFirstCMTLineL","Failed to find response +CMT: or +CDS:");
		User::Leave(KErrGeneral);
		}

	//
	// Get the <alpha> token, optional this token may return the message length token
	alpha=iter++;
	if(alpha==NULL)
		{
		LOCAL_LOGTEXT("ParseFirstCMTLineL","Failed with 1st argument");
		User::Leave(KErrGeneral);
		}

	//
	// Get the message length token
	entry=iter++;
	if(entry==NULL)
		entry=alpha;	// The alpha token must have been missing and thus alpha holds the message length

	if(entry==NULL)		
		{
		LOCAL_LOGTEXT("ParseFirstCMTLineL","Failed with 2nd argument");
		User::Leave(KErrGeneral);
		}

	//
	// Process the message length
	aPduLen=CATParamListEntry::EntryValL(entry);
	LOGTEXT2(_L8("New SMS detected of length %d"),iPduLen);

	CleanupStack::PopAndDestroy();		// ParseLineLC pushed object
	}


void CATSmsWaitForAndHandleCMTUnstored::ParseSecondCMTLineL(RMobileSmsMessaging::TMobileSmsGsmTpdu& aPdu,RMobileSmsMessaging::TMobileSmsReceiveAttributesV1& aAttr)
/**
 * Parse second line of CMT or DS response, of the format: "<pdu>"
 * The <pdu> is saved to aPdu. If the <pdu> is found to have a prefixed SCA
 * then that is removed before the save to aPdu.
 */
	{
	LOCAL_LOGTEXT("ParseSecondCMTLineL","Enter funciton");

	// Intiailise the attributes
	aAttr.iFlags=0;
	//
	// Copy the received pdu to local storage so that we can process
	// and modify it.
	// Buffer size calculated as follows;
	//   (max pdu size + max prefixed SCA size) * number of ASCII chars used to code an octet
	TBuf8<(RMobileSmsMessaging::KGsmTpduSize+12)*2> localPdu;	
	{
	ParseLineLC();
	TDblQueIter<CATParamListEntry> iter(iRxResults);
	CATParamListEntry* entry=iter++;			// Have to increment iter so it returns a pointer
	if(entry==NULL)
		User::Leave(KErrGeneral);		// Would prefer not to leave and return an error
		                                // but this function has to be trapped as we 
										// have the ParseLineLC() call.
	localPdu.Copy(entry->iResultPtr);
	CleanupStack::PopAndDestroy();		// ParseLineLC pushed object
	}

	// Nokia 9210 sometimes aborts the CMT frame in the middle of pdu.
	// Worst, it is sometimes contains odd number of nibbles which
	// causes panic in ConvertAsciiToBinary() method. This type of
	// frames will simply be discarded.
	if(localPdu.Length()<(iPduLen*2))
		User::Leave(KErrUnderflow);
	
	//
	// Check if we have a prefixed SCA on our pdu.
	// If we do then remove it.
	if(localPdu.Length()>(iPduLen*2))
		{
		if(CATSmsUtils::ReadAndRemoveAddressFromAscii(localPdu,aAttr.iGsmServiceCentre,ETrue)!=KErrNone)
			{
			LOCAL_LOGTEXT("ParseAndStoreCMGRResponseL","Failed to read and remove SCA from PDU");
			}
		else
			{
			aAttr.iFlags|=RMobileSmsMessaging::KGsmServiceCentre;
			}
		}

	//
	// Convert received pdu from ASCII into binary
	if (CATSmsUtils::ConvertAsciiToBinary(localPdu,aPdu)!=KErrNone)
		{
		LOCAL_LOGTEXT("ParseAndStoreCMGRResponseL","Failed to code PDU into binary");
		}
	else
		{
		aAttr.iDataFormat=RMobileSmsMessaging::EFormatGsmTpdu;
		aAttr.iFlags|=RMobileSmsMessaging::KSmsDataFormat;
		aAttr.iStatus=RMobileSmsMessaging::EMtMessageUnstoredPhoneAck;
		aAttr.iFlags|=RMobileSmsMessaging::KIncomingStatus;
		}
	}	
	


void CATSmsWaitForAndHandleCMTUnstored::CompleteWithIOError(TEventSource /*aSource*/,TInt aStatus)
	{
	LOCAL_LOGTEXT("CompleteWithIOError","Enter function");
	// CATIO removes expect strings in event of IO error so don't do it here
	iCMTExpectString=NULL;			
	iCDSExpectString=NULL;			
	// inform client of error so that it does not continue to wait for incoming SMS
	// now that this wait object has been disabled
	iReceiveQueue.CompleteClientReqWithError(aStatus);
	}