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

// Implements the SMS Store manipulation code.

// 

//

/**

 @file

*/

#include <mmlist.h>

#include <mmretrieve.h>

#include <testconfigfileparser.h>

#include "CSimSmsStore.h"

#include "csimsmsmess.h"

#include "Simlog.h"

#include "CSimTsyMode.h"

const TInt KSmsStoreGranularity=2;

const TInt KCorruptPDU=9999;

_LIT(KNullTelephoneNumber,"0");

CListReadAllAttempt* CListReadAllAttempt::NewL(RMobilePhone::TClientId& aId, TTsyReqHandle aReqHandle)

/**

 * Standard two phase constructor.

 * @param aId The client ID (session and sub-session handles) that uniquely identifies a client performing a two phase read.

 * @param aReqHandle The TSY request handle of the client request associated with a two phase read.

 * @return CListReadAllAttempt* The newly created object.

 */

	{

	CListReadAllAttempt* read=new(ELeave) CListReadAllAttempt(aId, aReqHandle);

	CleanupStack::PushL(read);

	read->ConstructL();

	CleanupStack::Pop();

	return read;

	}

CListReadAllAttempt::CListReadAllAttempt(RMobilePhone::TClientId& aId, TTsyReqHandle aReqHandle)

		: iListBuf(NULL),iReqHandle(aReqHandle)

/**

 * Trivial first phase constructor.

 * @param aId The client ID (session and sub-session handles) that uniquely identifies a client performing a two phase read.

 * @param aReqHandle The TSY request handle of the client request associated with a two phase read.

 */

	{

	iClient.iSessionHandle=aId.iSessionHandle;

	iClient.iSubSessionHandle=aId.iSubSessionHandle;

	iReqHandle=aReqHandle;

	iListBuf = NULL;

	}

void CListReadAllAttempt::ConstructL()

/**

 * Trivial second phase constructor.

 */

	{

	}

CListReadAllAttempt::~CListReadAllAttempt()

/**

 * Trivial destructor.

 */

	{

	delete iListBuf;

	}

//

// CSimSmsStore

//

void CSimSmsStore::ClosePhone(TAny* aObj)

/**

 * A utility function for cleaning up the stack.

 */

	{

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

	}

CSimSmsStore* CSimSmsStore::NewL(CSimSmsMessaging* aSimSmsMess, const TDesC8& aName, TInt aMaxNumSlots, CSimPhone* aPhone)

/**

 * Standard two phase constructor.

 * @param aSimSmsMess	The SMS Messaging object from which this SMS Store was opened.

 * @param aName			The name of the created SMS Store.

 * @param aMaxNumSlots	The maximum number of slots in the SMS Store.

 * @return CSimSmsStore* The newly created object.

 */

	{

	CSimSmsStore* store=new(ELeave) CSimSmsStore(aSimSmsMess, aPhone);

	TCleanupItem newObjClose(ClosePhone,store);

	CleanupStack::PushL(newObjClose);

	store->ConstructL(aName,aMaxNumSlots);

	CleanupStack::Pop();

	return store;

	}

CSimSmsStore::CSimSmsStore(CSimSmsMessaging* aSmsMess, CSimPhone* aPhone)

		: iSmsMessaging(aSmsMess), iEvOutstandingReq(EFalse), iPhone(aPhone)

/**

 * Trivial first phase constructor.

 * @param aSimSmsMess	The SMS Messaging object from which this SMS Store was opened.

 */

	{}

void CSimSmsStore::ConstructL(const TDesC8& aName, TInt aMaxNumSlots)

/**

 * Second phase constructor that allocates memory for the SMS store, batch read buffer and

 * a delayed completion timer.  The constructor also reads the individual and batch read

 * delays from the configuration file.

 * 

 * @param aName			The name of the created SMS Store.

 * @param aMaxNumSlots	The maximum number of slots in the SMS Store.

 */

	{

	iGsmSmsStoreEntries=new(ELeave) RMobileSmsStore::TMobileGsmSmsEntryV1[aMaxNumSlots+1];//index 0 is not used

	iSmsMaxNumSlots=aMaxNumSlots;

	iSmsStoreName.Copy(aName);

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

	LOGSMS1("Starting to parse SMS Store config parameters...");

	iSmsIndividualPause=CfgFileSection()->ItemValue(KSmsStoreIndividualReqPause,KDefaultSmsStoreIndividualReqPause);

	iSmsBatchPause=CfgFileSection()->ItemValue(KSmsStoreBatchReqPause,KDefaultSmsStoreBatchReqPause);

	const CTestConfigItem* item0=NULL;

	item0=CfgFileSection()->Item(KSmsPhoneStoreCaps,0);

	if (item0)

		{

		TPtrC8 value0;

		TInt ret0=CTestConfig::GetElement(item0->Value(),KStdDelimiter,0,value0);

		if(ret0!=KErrNone)

			{

			LOGPARSERR("value0",ret0,0,&KSmsPhoneStoreCaps);

			iSmsStoreCaps=KDefaultSmsPhoneStoreCaps+KDefaultSmsOnlySmsCaps;

			}

		else

			{

			TUint32 intValue;

			TInt ret = AsciiToNum(value0, intValue);

			if(ret!=KErrNone)

				iSmsStoreCaps=KDefaultSmsPhoneStoreCaps+KDefaultSmsOnlySmsCaps;

			else

				iSmsStoreCaps = intValue+KDefaultSmsOnlySmsCaps;

			}

		}

	else

		iSmsStoreCaps=KDefaultSmsPhoneStoreCaps+KDefaultSmsOnlySmsCaps;

	LOGSMS1("...Finished parsing SMS Store config parameters");

	iTimer=CSimTimer::NewL(iSmsMessaging->iPhone);

	iIncomingTimer=CSimTimer::NewL(iSmsMessaging->iPhone);

	}

void CSimSmsStore::PopulateStoreFromConfigFile()

/**

 * Populate the SMS Store from information in the configuration file.  This is performed

 * after the standard SMS Store construction in order to prevent reseting the configuation

 * file accessor class' pointers while possibly multiple SMS Stores are created.

 *

 * The store entries comply to the following format:

 * "SmsStoreEntry = <store name>, <slot number>, <entry status>, <pdu>"

 */

	{

	LOGSMS1("Starting reading SMS Store entries...");

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

	const CTestConfigItem* item=NULL;

	TInt ret=KErrNone;

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

		{

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

		if(!item)

			break;

		TPtrC8 storeName;

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

		if(ret!=KErrNone)

			{

			LOGPARSERR("storeName",ret,0,&KSmsStoreEntry);

			continue;

			}

		if(storeName.MatchF(iSmsStoreName)!=0)

			continue;						// Not this store

		TInt index,stat;

		TPtrC8 pdu;

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

		if((ret!=KErrNone)||(index>=iSmsMaxNumSlots))

			{

			LOGPARSERR("index",ret,1,&KSmsStoreEntry);

			continue;

			}

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

		if(ret!=KErrNone)

			{

			LOGPARSERR("stat",ret,2,&KSmsStoreEntry);

			continue;

			}

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

		if(ret!=KErrNone)

			{

			LOGPARSERR("pdu",ret,3,&KSmsStoreEntry);

			continue;

			}

		TPtrC8 sca;

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

		if(ret!=KErrNone)

			{

			LOGPARSERR("sca",ret,4,&KSmsStoreEntry);

			continue;

			}

		iGsmSmsStoreEntries[index].iIndex=index;

		iGsmSmsStoreEntries[index].iMsgStatus=(RMobileSmsStore::TMobileSmsStoreStatus)stat;

		ConvertAsciiSms(pdu,iGsmSmsStoreEntries[index].iMsgData);

		RecordSca(sca, index);

		}

	LOGSMS1("...Finished reading SMS Store entries");

	}

void CSimSmsStore::RecordSca(const TDesC8& aAsciiAddr, TInt aIndex)

/**

 * Used to set the sca number

 * 

 *

 * @param aAsciiSca Ascii representation of a telephone number such as the one found in the configuration file

 * @param aType specifies whether aAsciiAddres should be used to fill in the sca or destination field of the smsp entry

 * @param aIndex specifies at which index in the smsp list the number should be filled in

 */

	{

	if(aAsciiAddr.Length()>0)//only support for international numbers

		{

		iGsmSmsStoreEntries[aIndex].iServiceCentre.iNumberPlan=RMobilePhone::EIsdnNumberPlan;

		iGsmSmsStoreEntries[aIndex].iServiceCentre.iTypeOfNumber=RMobilePhone::EInternationalNumber;

		iGsmSmsStoreEntries[aIndex].iServiceCentre.iTelNumber.Copy(aAsciiAddr);

		}

	}

CSimSmsStore::~CSimSmsStore()

/**

 * Standard destructor.  Any objects created by the ::ConstructL() function

 * will be destroyed here.

 */

	{

	delete[] iGsmSmsStoreEntries;

	if (iSmsReadAll)

		{

		iSmsReadAll->ResetAndDestroy();

		delete iSmsReadAll;

		}

	delete iTimer;

	delete iIncomingTimer;

	}

#ifdef _DEBUG

void CSimSmsStore::LogRequest(TBool aEntering, TInt aIpc, TInt aError)

#else

void CSimSmsStore::LogRequest(TBool aEntering, TInt aIpc, TInt /*aError*/)

#endif

/**

 * This method logs client requests to the t_reg.txt

 * @param aEntering Tells if the request is entering into simtsy tsy or completing

 * @param aIpc IPC number of request

 * @param aError Error code that the request has

 */

 	{

	TBuf8<64> ipcBuf;

	switch (aIpc)

		{

		case EMobilePhoneStoreGetInfo:

			ipcBuf = _L8("GetInfo");

			break;

		case EMobilePhoneStoreNotifyStoreEvent:

			ipcBuf = _L8("NotifyStoreEvent");

			break;

		case EMobilePhoneStoreRead:

			ipcBuf = _L8("Read");

			break;

		case EMobilePhoneStoreWrite:

			ipcBuf = _L8("Write");

			break;

		case EMobilePhoneStoreDelete:

			ipcBuf = _L8("Delete");

			break;

		case EMobilePhoneStoreReadAllPhase1:

			ipcBuf = _L8("ReadAllPhase1");

			break;

		case EMobilePhoneStoreReadAllPhase2:

			ipcBuf = _L8("ReadAllPhase2");

			break;

		case EMobilePhoneStoreDeleteAll:

			ipcBuf = _L8("DeleteAll");

			break;		

		default:

			ipcBuf = _L8("OTHER");

			break;

		}

	if (aEntering!=EFalse)

		{

		LOGSMS3(">>%d,CSimSmsStore::%S",aIpc, &ipcBuf );

		}

	else

		{

		LOGSMS4("<<%d,CSimSmsStore::%S with error %d",aIpc, &ipcBuf, aError);

		}

	}

TInt CSimSmsStore::ExtFunc(const TTsyReqHandle aReqHandle,const TInt aIpc, const TDataPackage& aPckg)

/**

 * Dispatch function for all SMS Store requests.

 * @param aReqHandle	The TSY request handle for this request.

 * @param aIpc			The IPC number of this request.

 * @param aPckg			The parameter package related to this request.

 * @return TInt			The return error condition.

 */

	{

// The following requests can be completed even if the completion of another request is pending.

	TInt ret=KErrNone;//error is only used with LogRequest when at the end of ExtFunc

	LogRequest(ETrue, aIpc, ret);

	switch(aIpc)

		{

	case EMobilePhoneStoreGetInfo:

		ret = GetInfo(aReqHandle,aPckg.Des1n());

		LogRequest(EFalse, aIpc, ret);

		return ret;

	case EMobilePhoneStoreNotifyStoreEvent:

		ret =  NotifyStoreEvent(aReqHandle,aPckg.Des1n(),aPckg.Des2n());

		LogRequest(EFalse, aIpc, ret);

		return ret;

	default:

		break;

		}

// The TSY can only process one of the following requests at a time.  If a second is received

// while processing the first, then it will be errored with KErrInUse.  This restriction will

// be removed later, by inserting a request queuing mechanism.  Note that the standard TSY

// "flow control" mechanism works phone-wide and so is not suitable.

	if(iTimer->IsActive())

		{

		ReqCompleted(aReqHandle,KErrInUse);

		return KErrNone;

		}

	switch(aIpc)

		{

	case EMobilePhoneStoreRead:

		ret = Read(aReqHandle,aPckg.Des1n());

		break;

	case EMobilePhoneStoreWrite:

		ret = Write(aReqHandle,aPckg.Des1n());

		break;

	case EMobilePhoneStoreDelete:

		ret = Delete(aReqHandle,aPckg.Des1n());

		break;

	case EMobilePhoneStoreReadAllPhase1:

		ret = ReadAllPhase1(aReqHandle,aPckg.Des1n(),aPckg.Des2n());

		break;

	case EMobilePhoneStoreReadAllPhase2:

		ret = ReadAllPhase2(aReqHandle,aPckg.Des1n(),aPckg.Des2n());

		break;

	case EMobilePhoneStoreDeleteAll:

		ret = DeleteAll(aReqHandle);

		break;

	default:

		return KErrNotSupported;

		}

	LogRequest(EFalse, aIpc, ret);

	return ret;

	}

CTelObject* CSimSmsStore::OpenNewObjectByNameL(const TDesC& /*aName*/)

/**

 * The API does not support any objects that could be opened from this one.

 */

	{

	User::Leave(KErrNotSupported);

	return NULL;

	}

CTelObject* CSimSmsStore::OpenNewObjectL(TDes&)

/**

 * The API does not support any objects that could be opened from this one.

 */

	{

	User::Leave(KErrNotSupported);

	return NULL;

	}

CTelObject::TReqMode CSimSmsStore::ReqModeL(const TInt aIpc)

/**

 * This function returns the Request Mode for the request with the passed IPC value.

 * @param aIpc		The IPC number of the request.

 * @return TReqMode	The request mode.

 */

	{

	CTelObject::TReqMode ret=0;	

	switch(aIpc)

		{

	case EMobilePhoneStoreGetInfo:

	case EMobilePhoneStoreRead:

	case EMobilePhoneStoreWrite:

	case EMobilePhoneStoreDelete:

	case EMobilePhoneStoreReadAllPhase1:

	case EMobilePhoneStoreReadAllPhase2:

	case EMobilePhoneStoreDeleteAll:

		break;

	case EMobilePhoneStoreNotifyStoreEvent:

		ret=KReqModeMultipleCompletionEnabled | KReqModeRePostImmediately;

		break;

	default:

		User::Leave(KErrNotSupported);

		break;

		}

	return ret;

	}

TInt CSimSmsStore::RegisterNotification(const TInt /*aIpc*/)

/**

 * The ETel Server calls this function when the first client makes a notification

 * request.  If supported by the underlying protocol controlling the

 * signalling stack, this can be used to start requesting updates for the relevant

 * service.

 */

	{

	return KErrNone;

	}

TInt CSimSmsStore::DeregisterNotification(const TInt /*aIpc*/)

/**

 * The ETel Server calls this function when the last client that had previously

 * made a notification request closes its ETel Server handle.  If supported by

 * the underlying protocol controlling the	signalling stack, this can be used

 * to stop requesting updates for the relevant service.

 */

	{

	return KErrNone;

	}

TInt CSimSmsStore::NumberOfSlotsL(const TInt /*aIpc*/)

/**

 * Return the number of slots that the ETel Server should allocate for buffering requests

 * of the given IPC number.

 */

	{

	return KDefaultNumberOfSlots;

	}

TInt CSimSmsStore::CancelService(const TInt aIpc,const TTsyReqHandle /*aTsyReqHandle*/)

/**

 * Cancel an outstanding request.