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

//

/**

 @file

*/

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "csimsmsmessTraces.h"

#endif

#include "csimsmsmess.h"

#include <testconfigfileparser.h>

#include <etelmm.h>

#include "CSimTsyMode.h"

//macro

#define UNPACK_PCKG(target,source,datatype)  datatype& target=  (*(TPckg<datatype>*)(source))()

const TInt KSmsSettingGranularity=5;	// < Granularity of SMS parameter list arrays.

const TInt KSmsStoreGranularity=2;	// < Granularity of SMS store list array.

const TInt KNoMessageReferenceInCofigurationFile=0;//the reference number returned to the client is 0 if

													//no value is found in the configuration file

//

// CSimSmsMessaging

//

void CSimSmsMessaging::CloseSmsObj(TAny* aObj)

/**

 *	A utility function for cleaning up the stack.

 */

	{

	((CObject*)aObj)->Close();

	}

CSimSmsMessaging* CSimSmsMessaging::NewL(CSimPhone* aPhone)

/**

 *	Standard two phase constructor.

 */

	{

	CSimSmsMessaging* smsMess=new(ELeave) CSimSmsMessaging(aPhone);

	TCleanupItem newObjClose(CloseSmsObj,smsMess);

	CleanupStack::PushL(newObjClose);

	smsMess->ConstructL();

	CleanupStack::Pop();

	return smsMess;

	}

CSimSmsMessaging::CSimSmsMessaging(CSimPhone* aPhone)

		: iPhone(aPhone), iSmspBusy(EFalse)

	{}

void CSimSmsMessaging::ConstructL()

/**

 * Retrieve the SMS-related tags from the configuration file.

 *

 * 

 * If there are no constraints any SMS specified in the configuration file and the "incoming SMS event" timer will

 * be started.

 */

    {

    InitializeL();

    }

void CSimSmsMessaging::InitializeL()

	{

	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSMSMESSAGING_INITIALIZEL_1, "Starting to Load and Parse Sms Messaging Config ");

	iRxTimer=CSimTimer::NewL(iPhone);

	iTxTimer=CSimTimer::NewL(iPhone);

	iSmspTimer=CSimTimer::NewL(iPhone);

	iSmsRxParameterListGsm=new(ELeave) CArrayFixFlat<TSmsRxParametersGsm>(KSmsSettingGranularity);	

	FindAndCreateRxAttributesL();

	iSmsTxParametersListGsm=new(ELeave) CArrayFixFlat<TSmsTxParametersGsm>(KSmsSettingGranularity);		

	FindAndCreateTxAttributesL();

	iSmsStores=new(ELeave) CArrayFixFlat<CSimSmsStore*>(KSmsStoreGranularity);

	FindAndCreateSmsStoresL(iPhone);

	FindAndCreateConstraints();

	iSmspReadAll=new(ELeave) CArrayPtrFlat<CListReadAllAttempt>(KSmsStoreGranularity);

	FindAndCreateSmsParamsL();

	// NOTE - no need to start iRxTimer; this will be started once a EMobileSmsMessagingReceiveMessage

	// request is received and/or Send Sms contrainst satisfied (see CompleteTxPendingReq)

	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSMSMESSAGING_INITIALIZEL_2, "Finished parsing SMS Messaging config parameters");

	}

void CSimSmsMessaging::Reset()

    {

 	if(iSmsRxParameterListGsm)

		{

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

		delete iSmsRxParameterListGsm;

        iSmsRxParameterListGsm = NULL;

		}

	if(iSmsTxParametersListGsm)

		{

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

		delete iSmsTxParametersListGsm;

        iSmsTxParametersListGsm = NULL;

		}

    delete iSmspEntries;

    iSmspEntries = NULL;

    if (iSmsStores)

        {

        TInt storeCount=iSmsStores->Count();    

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

            {

            iSmsStores->At(i)->Close();

            }

        delete iSmsStores;

        iSmsStores = NULL;

        }

    if (iSmspReadAll)

        {

        iSmspReadAll->ResetAndDestroy();

        delete iSmspReadAll;

        iSmspReadAll = NULL;

        }

    iConstraints.Reset();

    iSmsTxCnt = 0;

    iSmsRxCnt = 0;

    iCurrentConstraint = 0;

    iConstraintRxCnt = 0;

    iSmspBusy   = EFalse;

    iRxState    = ESmsRxStateIdle;

    iTxState    = ESmsTxStateIdle;

    delete iRxTimer;

    iRxTimer = NULL;

    delete iTxTimer;

    iTxTimer = NULL;

    delete iSmspTimer;

    iSmspTimer = NULL;

    }

CSimSmsMessaging::~CSimSmsMessaging()

/**

 *	Standard destructor.  Any objects created by the ::ConstructL() function should be destroyed here.

 */

	{

	Reset();

	}

void CSimSmsMessaging::FindAndCreateRxAttributesL()

/**

 * Extract values from the tags

 * SmsRx, SmsRxPeriod, SmsAckNackPause, SmsResumePause, SmsDeliveryReport

 *

 */	{

	TInt ret=KErrNone;

	TInt count=CfgFileSection()->ItemCount(KSmsRx);

	const CTestConfigItem* item=NULL;

	TInt i;

	TSmsRxParametersGsm smsRxParameterGsm;

	OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSMSMESSAGING_FINDANDCREATERXATTRIBUTESL_1, "CSimSmsMessaging::FindAndCreateRxAttributesL IN [count=%d]", count);

	// Need to do this *before* entering the loop (so that we know 

	// whether or not to read a delivery report pdu off the config file).

	iSmsControlCaps=RMobileSmsMessaging::TMobileSmsControlCaps(CfgFileSection()->ItemValue(KSmsControlCaps,KDefaultSmsControlCaps));

	for(i=0;i<count;i++)

		{

		item=CfgFileSection()->Item(KSmsRx,i);

		if(!item)

			break;

		TPtrC8 smsPdu,sca;

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,smsPdu);

		if(ret!=KErrNone)

			{

			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSMSMESSAGING_FINDANDCREATERXATTRIBUTESL_2, "WARNING - CONFIGURATION FILE PARSING - Reading element SMSPDU returned %d (element no. %d) from tag %s.",ret,0,KSmsRx);

			continue;

			}

		else

			{

			smsRxParameterGsm.iPdu.Zero();

			ConvertAsciiSms(smsPdu,smsRxParameterGsm.iPdu);

			}

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,sca);

		if(ret!=KErrNone)

			{

			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSMSMESSAGING_FINDANDCREATERXATTRIBUTESL_3, "WARNING - CONFIGURATION FILE PARSING - Reading element SCA returned %d (element no. %d) from tag %s.",ret,1,KSmsRx);

			continue;

			}

		else

			{

			smsRxParameterGsm.iSca=sca;

			}

		//get delivery report pdu 

		smsRxParameterGsm.iDeliveryReport.Zero(); 	

		if (!(iSmsControlCaps & RMobileSmsMessaging::KCapsReceiveUnstoredClientAck))

			{

			TPtrC8 deliveryReportPdu;

			ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,deliveryReportPdu);

			if( (ret!=KErrNone) && (ret!=KErrGeneral) )

				{

				OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSMSMESSAGING_FINDANDCREATERXATTRIBUTESL_4, "WARNING - CONFIGURATION FILE PARSING - Reading element DELIVERYREPORTPDU returned %d (element no. %d) from tag %s.",ret,2,KSmsRx);

				}

			else

				{

				if (CSimTsyMode::GetMode() != CSimTsyMode::ECdmaV1)			

					{

  					ConvertAsciiSms(deliveryReportPdu,smsRxParameterGsm.iDeliveryReport); 

  					}

				}

			}

		// add to list of params

		iSmsRxParameterListGsm->AppendL(smsRxParameterGsm);	

		}// for

	iSmsRxPeriod=CfgFileSection()->ItemValue(KSmsRxPeriod,KDefaultSmsRxPeriod);

	iAckNackCompletePause=CfgFileSection()->ItemValue(KSmsAckNackPause,KDefaultSmsAckNackPause);

	iResumeCompletePause=CfgFileSection()->ItemValue(KSmsResumePause,KDefaultSmsResumePause);

	if (iSmsControlCaps & RMobileSmsMessaging::KCapsReceiveUnstoredClientAck)

		iSmsReceiveMode=RMobileSmsMessaging::EReceiveUnstoredClientAck;

	else iSmsReceiveMode=RMobileSmsMessaging::EReceiveModeUnspecified;

	OstTraceDefExt4(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSMSMESSAGING_FINDANDCREATERXATTRIBUTESL_5, "iSmsRxPeriod =%d, iAckNackCompletePause=%d, iResumeCompletePause=%d, iSmsControlCaps=%d",iSmsRxPeriod, iAckNackCompletePause, iResumeCompletePause, iSmsControlCaps);

	OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSMSMESSAGING_FINDANDCREATERXATTRIBUTESL_6, "iSmsModeCaps =%d, iSmsRxStartDelay = %d, iSmsReceiveMode = %d",iSmsModeCaps , iSmsRxStartDelay, iSmsReceiveMode);

	OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSMSMESSAGING_FINDANDCREATERXATTRIBUTESL_7, "CSimSmsMessaging::FindAndCreateRxAttributesL OUT [count=%d]", iSmsRxParameterListGsm->Count());

	}

void CSimSmsMessaging::FindAndCreateTxAttributesL()

/**

 * Extract values from the tags

 * SmsTx, SmsTxPause

 *

 */

	{

	TInt ret=KErrNone;

	TInt count=CfgFileSection()->ItemCount(KSmsTx);

	TSmsTxParametersGsm   smsTxParametersGsm;

	const CTestConfigItem* item=NULL;

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

		{

		item=CfgFileSection()->Item(KSmsTx,i);//Tx

		if(!item)

			break;

		//get pdu

		TPtrC8 smsTx;

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,smsTx);

		if(ret!=KErrNone)

			{

			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSMSMESSAGING_FINDANDCREATETXATTRIBUTESL_1, "WARNING - CONFIGURATION FILE PARSING - Reading element SMSTX returned %d (element no. %d) from tag %s.",ret,0,KSmsTx);

			continue;

			}

		else

			{			

			smsTxParametersGsm.iPdu.Zero();

			ConvertAsciiSms(smsTx,smsTxParametersGsm.iPdu);

			}

		//get Sca

		TPtrC8 sca;

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,sca);

		if (ret!=KErrNone)

			{

			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSMSMESSAGING_FINDANDCREATETXATTRIBUTESL_2, "WARNING - CONFIGURATION FILE PARSING - Reading element SCA returned %d (element no. %d) from tag %s.",ret,1,KSmsTx);

			continue;

			}

		else

			{			

			smsTxParametersGsm.iSca.Copy(sca);				

			}

		//get reference

		TInt reference;

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,reference);

		if(ret!=KErrNone)

			{

			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSMSMESSAGING_FINDANDCREATETXATTRIBUTESL_3, "WARNING - CONFIGURATION FILE PARSING - Reading element REFERENCE returned %d (element no. %d) from tag %s.",ret,2,KSmsTx);

			smsTxParametersGsm.iRef=KNoMessageReferenceInCofigurationFile;	

			}

		else

			{	

			smsTxParametersGsm.iRef=reference;				

			}

		//get submit report pdu

		TPtrC8 submitReportPdu;

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,submitReportPdu);

		if(ret!=KErrNone)

			{

			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSMSMESSAGING_FINDANDCREATETXATTRIBUTESL_4, "WARNING - CONFIGURATION FILE PARSING - Reading element SUBMITREPORTPDU returned %d (element no. %d) from tag %s.",ret,3,KSmsTx);

			continue;

			}

		else

			{			

			smsTxParametersGsm.iSubmitReport.Zero(); 	

			ConvertAsciiSms(submitReportPdu,smsTxParametersGsm.iSubmitReport); 

			}

		//get expected error code

		TInt errorCode;

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,errorCode);

		if(ret!=KErrNone)

			{

			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSMSMESSAGING_FINDANDCREATETXATTRIBUTESL_5, "WARNING - CONFIGURATION FILE PARSING - Reading element ERRORCODE returned %d (element no. %d) from tag %s.",ret,4,KSmsTx);

			continue;

			}

		else

			{		

			smsTxParametersGsm.iExpectedError=errorCode;					

			}		

		iSmsTxParametersListGsm->AppendL(smsTxParametersGsm);			

		} //end for SmsTx Tag

	iSmsTxPause=CfgFileSection()->ItemValue(KSmsTxPause,KDefaultSmsTxPause);

	}

void CSimSmsMessaging::FindAndCreateConstraints()

/**

 * Extract values from the tags

 * SmsStartRxDelay

 *

 */

	{

	TInt ret=KErrNone;

	TInt count=CfgFileSection()->ItemCount(KSmsStartRxDelay);

	const CTestConfigItem* item=NULL;

	TConstraintEntry constraint;

	for(TInt i=0;i<count;i++)//Rx delay

		{

		item=CfgFileSection()->Item(KSmsStartRxDelay,i);

		if(!item)

			break;

		TInt ipc,noBefore,noAfter;

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,ipc);//only :SendMessage() is supported

		if(ret!=KErrNone || ipc!=4207)

			{

			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSMSMESSAGING_FINDANDCREATECONSTRAINTS_1, "WARNING - CONFIGURATION FILE PARSING - Reading element IPC returned %d (element no. %d) from tag %s.",ret,0,KSmsStartRxDelay);

			continue;

			}

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,noBefore);

		if(ret==KErrNone)

			constraint.iIpcCnt=noBefore;

		else

			{

			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSMSMESSAGING_FINDANDCREATECONSTRAINTS_2, "WARNING - CONFIGURATION FILE PARSING - Reading element NOBEFORE returned %d (element no. %d) from tag %s.",ret,1,KSmsStartRxDelay);

			continue;

			}

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,noAfter);

		if(ret==KErrNone)

			constraint.iRxCnt=noAfter;

		else

			{

			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSMSMESSAGING_FINDANDCREATECONSTRAINTS_3, "WARNING - CONFIGURATION FILE PARSING - Reading element NOAFTER returned %d (element no. %d) from tag %s.",ret,2,KSmsStartRxDelay);

			continue;

			}

		__ASSERT_ALWAYS(iConstraints.Append(constraint) == KErrNone,SimPanic(EGeneral));

		}

	}

void CSimSmsMessaging::FindAndCreateSmsStoresL(CSimPhone* aPhone)

/**

 *	Creates sms stores as defined in the comfiguation files

 *	Extract values from the tags

 *	SmsStore, SmsStoreEntry, SmsStoreIndividualReqPause, SmsStoreBatchReqPause

 */

	{

	TInt count=CfgFileSection()->ItemCount(KSmsStore);

	const CTestConfigItem* item=NULL;

	TInt ret=KErrNone;

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

		{

		item=CfgFileSection()->Item(KSmsStore,i);

		if(!item)

			break;

		TPtrC8 storeName;

		TInt maxNumSlots;

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,storeName);

		if(ret!=KErrNone)

			{

			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSMSMESSAGING_FINDANDCREATESMSSTORESL_1, "WARNING - CONFIGURATION FILE PARSING - Reading element STORENAME returned %d (element no. %d) from tag %s.",ret,0,KSmsStore);

			continue;

			}

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,maxNumSlots);

		if(ret!=KErrNone)

			{

			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSMSMESSAGING_FINDANDCREATESMSSTORESL_2, "WARNING - CONFIGURATION FILE PARSING - Reading element MAXNUMSLOTS returned %d (element no. %d) from tag %s.",ret,1,KSmsStore);

			continue;

			}

		CSimSmsStore* smsStore=CSimSmsStore::NewL(this,storeName,maxNumSlots,aPhone);

		TCleanupItem newObjClose(CloseSmsObj,smsStore);

		CleanupStack::PushL(newObjClose);

		iSmsStores->AppendL(smsStore);

		CleanupStack::Pop();

		}

	for(TInt j=0;j<iSmsStores->Count();j++)

		{

		iSmsStores->At(j)->PopulateStoreFromConfigFile();

		}

	}

void CSimSmsMessaging::FindAndCreateSmsParamsL()

/**

 *Populates the sms parameter List as defined in the configuration file

 *Extract values from the tags

 *SmsParamEntry, SmsParamEntry, SmsParamBatchReqPause, SmsParamMaxNumSlots

 */

	{

	iSmspEntries= CMobilePhoneSmspList::NewL();

	const TInt maxSlots = CfgFileSection()->ItemValue(KSmspMaxNumSlots ,KDefaultSmspMaxNumSlots);

	iSmspEntries->SetMaxNumberEntries(maxSlots);

	iSmspBatchPause = CfgFileSection()->ItemValue(KSmspBatchReqPause,KDefaultSmspBatchReqPause);

	const TInt numberOfSmspEntries = Min(CfgFileSection()->ItemCount(KSmsParamEntry), maxSlots);

	const CTestConfigItem* item=NULL;

	TInt ret=KErrNone;

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

		{

		item=CfgFileSection()->Item(KSmsParamEntry,i);

		if(!item)

			break;

		RMobileSmsMessaging::TMobileSmspEntryV1 entry = RMobileSmsMessaging::TMobileSmspEntryV1();

		TInt index, pid, dcs, validityPeriod;

		TPtrC8 destAddress, sca, smspName;

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,0,index);

		if((ret==KErrNone)&&(index < maxSlots))

			entry.iIndex=index;

		else

			{

			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSMSMESSAGING_FINDANDCREATESMSPARAMSL_1, "WARNING - CONFIGURATION FILE PARSING - Reading element INDEX returned %d (element no. %d) from tag %s.",ret,0,KSmsParamEntry);

			continue;

			}

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,1,smspName);

		if(ret==KErrNone)

			entry.iText.Copy(smspName);

		else

			{

			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSMSMESSAGING_FINDANDCREATESMSPARAMSL_2, "WARNING - CONFIGURATION FILE PARSING - Reading element SMSPNAME returned %d (element no. %d) from tag %s.",ret,1,KSmsParamEntry);

			continue;

			}

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,2,pid);

		if(ret==KErrNone)

			{

			entry.iProtocolId=TUint8(pid);

			entry.iValidParams |= RMobileSmsMessaging::KProtocolIdIncluded;

			}

		else

			{

			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSMSMESSAGING_FINDANDCREATESMSPARAMSL_3, "WARNING - CONFIGURATION FILE PARSING - Reading element PID returned %d (element no. %d) from tag %s.",ret,2,KSmsParamEntry);

			continue;

			}

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,3,dcs);

		if(ret==KErrNone)

			{

			entry.iDcs=TUint8(dcs);

			entry.iValidParams |= RMobileSmsMessaging::KDcsIncluded;

			}

		else

			{

			OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSIMSMSMESSAGING_FINDANDCREATESMSPARAMSL_4, "WARNING - CONFIGURATION FILE PARSING - Reading element DCS returned %d (element no. %d) from tag %s.",ret,3,KSmsParamEntry);

			continue;

			}

		ret=CTestConfig::GetElement(item->Value(),KStdDelimiter,4,validityPeriod);

		if(ret==KErrNone)