// 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 "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()

	{

	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)

	}

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;

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

			{

			continue;

			}

		else

			{

			smsRxParameterGsm.iPdu.Zero();

			ConvertAsciiSms(smsPdu,smsRxParameterGsm.iPdu);

			}

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

		if(ret!=KErrNone)

			{

			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) )

				{

				}

			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;

	}

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)

			{

			continue;

			}

		else

			{			

			smsTxParametersGsm.iPdu.Zero();

			ConvertAsciiSms(smsTx,smsTxParametersGsm.iPdu);

			}

		//get Sca

		TPtrC8 sca;

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

		if (ret!=KErrNone)

			{

			continue;

			}

		else

			{			

			smsTxParametersGsm.iSca.Copy(sca);				

			}

		//get reference

		TInt reference;

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

		if(ret!=KErrNone)

			{

			smsTxParametersGsm.iRef=KNoMessageReferenceInCofigurationFile;	

			}

		else

			{	

			smsTxParametersGsm.iRef=reference;				

			}

		//get submit report pdu

		TPtrC8 submitReportPdu;

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

		if(ret!=KErrNone)

			{

			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)

			{

			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)

			{

			continue;

			}

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

		if(ret==KErrNone)

			constraint.iIpcCnt=noBefore;

		else

			{

			continue;

			}

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

		if(ret==KErrNone)

			constraint.iRxCnt=noAfter;

		else

			{

			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)

			{

			continue;

			}

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

		if(ret!=KErrNone)

			{

			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

			{

			continue;

			}

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

		if(ret==KErrNone)

			entry.iText.Copy(smspName);

		else

			{

			continue;

			}

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

		if(ret==KErrNone)

			{

			entry.iProtocolId=TUint8(pid);

			entry.iValidParams |= RMobileSmsMessaging::KProtocolIdIncluded;

			}

		else

			{

			continue;

			}

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

		if(ret==KErrNone)

			{

			entry.iDcs=TUint8(dcs);

			entry.iValidParams |= RMobileSmsMessaging::KDcsIncluded;

			}

		else

			{

			continue;

			}

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

		if(ret==KErrNone)

			{

			entry.iValidityPeriod=TUint8(validityPeriod);

			entry.iValidParams |= RMobileSmsMessaging::KValidityPeriodIncluded;

			}

		else

			{