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

// Retrieves information on ME <mem1>, <mem2> storage slots (total, used) ....AT+CPMS?

// Also tracks the number of preferred memories.

// 

//

#include "NOTIFY.H"

#include "mSMSMESS.H"

#include "mSMSMEM.H"

#include "mSLOGGER.H"

#include "ATIO.H"

#include "ATINIT.H"

#include "mSMSSTOR.H"

_LIT8(KOpenBracketCharacter,"(");

_LIT8(KCloseBracketCharacter,")");

CATSmsMemoryStorage* CATSmsMemoryStorage::NewL (CATIO* aIo, CTelObject* aTelObject, CATInit* aInit,

							CPhoneGlobals* aGsmStatus)

	{

	CATSmsMemoryStorage* self = new (ELeave) CATSmsMemoryStorage(aIo, aTelObject, aInit, aGsmStatus);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CATSmsMemoryStorage::CATSmsMemoryStorage(CATIO* aIo, CTelObject* aTelObject,

										 CATInit* aInit, CPhoneGlobals* aGsmStatus)

	:CATSmsCommands(aIo, aTelObject, aInit, aGsmStatus), 

	 iSmsStore(REINTERPRET_CAST(CMobileSmsStore*,aTelObject)), 

	 iCancelled(EFalse)

	{}

void CATSmsMemoryStorage::ConstructL()

	{

	CATCommands::ConstructL();

	iClientPreferredMem = 1;

	}

CATSmsMemoryStorage::~CATSmsMemoryStorage()

	{}

void CATSmsMemoryStorage::Start(TTsyReqHandle aTsyReqHandle, TAny* aParams)

//

// Start function called by CMobileSmsMessaging::GetMessageStoreInfo

//

	{

	iReqHandle = aTsyReqHandle;

	iCancelled=EFalse;

	if (aParams)

		iInfoPckg=static_cast<RMobilePhoneStore::TMobilePhoneStoreInfoV1Pckg*>(aParams);

	if (ComparePrefMem(iPeekPrevStorage[iClientPreferredMem].iStoreName))

		{

		// no need to set preferred memory as correct one is selected already

		iTxBuffer.Copy(KGetPrefMemTestCommand);	// Preferred Memory Storage cmd. ETSI std GSM 07.05, May 1996

		iIo->Write(this, iTxBuffer);

		iIo->SetTimeOut(this, 5000);

		iState = EATWaitForSendingCPMSRequestComplete;

		}

	else //ie: the compared memories are different, must change phone mem to temporary mem

		{

		iRequestedMem=iPeekPrevStorage[iClientPreferredMem].iStoreName;

		SetCurrentPrefMem(iRequestedMem);

		iState = EATWaitForSettingMem;

		}

	}

void CATSmsMemoryStorage::StartGetInfo(TTsyReqHandle aTsyReqHandle, TAny* aParams)

//

// Start function called by CMobileSmsStore::GetInfo

//

	{

	LOGTEXT(_L8("CATSmsMemoryStorage:\tClient has called a GetInfo"));

	iReqHandle = aTsyReqHandle;

	iCancelled=EFalse;

	if (aParams)

		iInfoPckg=static_cast<RMobilePhoneStore::TMobilePhoneStoreInfoV1Pckg*>(aParams);

	if (ComparePrefMem(iSmsStore->iStoreName))

		{

		// no need to set preferred memory as correct one is selected already

		iTxBuffer.Copy(KGetPrefMemTestCommand);	// Preferred Memory Storage cmd. ETSI std GSM 07.05, May 1996

		iIo->Write(this, iTxBuffer);

		iIo->SetTimeOut(this, 5000);

		iState = EATWaitForSendingCPMSRequestComplete;

		}

	else

		{

		iRequestedMem=iSmsStore->iStoreName;

		SetCurrentPrefMem(iRequestedMem);

		iState = EATWaitForSettingMem;

		}

	}

void CATSmsMemoryStorage::EventSignal(TEventSource aSource)

//

// Finite State Machine for handling events from the comm port

//

	{

	LOGTEXT2(_L8("CATSmsMemoryStorage:\tiState = %D"), iState);

	if (aSource == ETimeOutCompletion)

		{

		LOGTEXT(_L8("CATSmsMemoryStorage:\tTimeout Error during AT+CPMS query of ME"));

		iPhoneGlobals->iPhoneStatus.iModemDetected = RPhone::EDetectedNotPresent;

		Complete(KErrTimedOut, aSource);

		return;

		}

	TInt ret(KErrNone);

	switch (iState)

		{

	case EATWaitForSettingMem:

		iIo->WriteAndTimerCancel(this);

		StandardWriteCompletionHandler(aSource, 5);

		iState = EATWaitForSettingMemComplete;

		break;

	case EATWaitForSettingMemComplete:

		__ASSERT_ALWAYS(aSource == EReadCompletion, Panic(EATCommand_IllegalCompletionReadExpected));

		iIo->WriteAndTimerCancel(this);

		ret=ValidateExpectString();

		if (ret==KErrNone)

			{

			iPhoneGlobals->iPhonePrefMem=iRequestedMem;

			if (iCancelled)

				Complete(KErrCancel, aSource);

			else

				{

				iTxBuffer.Copy(KGetPrefMemTestCommand);	// Preferred Memory Storage cmd. ETSI std GSM 07.05, May 1996

				iIo->Write(this, iTxBuffer);

				iIo->SetTimeOut(this, 5000);

				iState = EATWaitForSendingCPMSRequestComplete;

				}

			}

		else

			Complete(ret, aSource);

		break;

	case EATWaitForSendingCPMSRequestComplete:

		iIo->WriteAndTimerCancel(this);

		StandardWriteCompletionHandler(aSource,5);

		iState = EATWaitForCPMSResponseComplete;

		break;

	case EATWaitForCPMSResponseComplete:

		__ASSERT_ALWAYS(aSource == EReadCompletion, Panic(EATCommand_IllegalCompletionReadExpected));

		iIo->WriteAndTimerCancel(this);

		TRAPD(ret2, CPMSResponseL());

		Complete(ret2,aSource);

		break;

	default:		// Catches illegal states

		LOGTEXT2(_L8("CATSmsMemoryStorage:\tiIllegal State = %D"), iState);

		break;

		}

	}

void CATSmsMemoryStorage::CPMSResponseL()

//

// Parse result of AT+CPMS? ....used by GetMessageStoreInfo()

//

	{

	ParseBufferLC();

	RemoveUnsolicitedStrings();    // Removes any unsolicited strings

	CATParamListEntry* entry;

	TDblQueIter<CATParamListEntry> iter(iRxResults);

	// +CPMS: <mem1>,<used1>,<total1>,<mem2>,<used2>,<total2>,<mem3>,<used3>,<total3>

	// but we don't care after <total1>

	entry = iter++;		

	if (!entry || entry->iResultPtr != KCPMSResponseString)

		User::Leave(KErrNotFound);

	entry = iter++;

	TPtrC8 name(entry->iResultPtr);

	entry=iter++;

	TInt used = CATParamListEntry::EntryValL(entry);

	entry=iter++;

	TInt total = CATParamListEntry::EntryValL(entry);

	RMobilePhoneStore::TMobilePhoneStoreInfoV1& storeInfo = (*iInfoPckg)();

	storeInfo.iType=RMobilePhoneStore::EShortMessageStore;

	storeInfo.iUsedEntries=used;

	storeInfo.iTotalEntries=total;

	if (name == KMEStorage)

		storeInfo.iName=KETelMeSmsStore;

	else if (name == KSMStorage)

		storeInfo.iName=KETelIccSmsStore; 

	else if (name == KMTStorage)

		storeInfo.iName=KETelCombinedSmsStore; 

	else

		User::Leave(KErrGeneral);

	storeInfo.iCaps=SMSStoreCaps(storeInfo.iName);   

	LOGTEXT3(_L8("CPMSResponseL\tPreferred store used=%d, total=%d"), used, total);

	CleanupStack::PopAndDestroy();

	}

void CATSmsMemoryStorage::EnumerateCPMSResponseL()

//

// Parse result of AT+CPMS=?

//

	{

	TInt count;

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

		{

		iPeekPrevStorage[count].iStoreName.Zero();

		iPeekPrevStorage[count].iMems = 0;

		}

	iStoreCounter = 0;

	ParseBufferLC(ETrue);		// we need the list separators

	RemoveUnsolicitedStrings(); // Ensure we remove any unsolicited messages

	CATParamListEntry* entry;

	TDblQueIter<CATParamListEntry> iter(iRxResults);

	// +CPMS: (list of supported mem1), (list of supported mem2), (list of supported mem3)

	entry=iter++;

	if (entry==NULL || entry->iResultPtr != KCPMSResponseString)

		User::Leave(KErrGeneral);

	TUint32 memtype = KMemTypeReadAndDeleted;

	TInt listCounter = 0;

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

		{

		TPtrC8 param(entry->iResultPtr);

		if (param == KOpenBracketCharacter)

			{

			if (listCounter>2)

				User::Leave(KErrGeneral);

			continue;

			}

		if (param == KCloseBracketCharacter)

			{

			listCounter++;

			memtype <<= 1;

			continue;

			}

		// Should be a known mem type

		if (param == KMTStorage)

			continue;			// Ignore MT storage

		if (param != KBMStorage &&

			param != KMEStorage &&

			param != KSMStorage &&

			param != KTAStorage)

			{

			continue;

			}

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

			{

			if (param == iPeekPrevStorage[count].iStoreName)

				break;

			}

		if (count == iStoreCounter) // ie: The current <mem> being looked at (param) has not been seen before

			{

			iPeekPrevStorage[count].iStoreName = param;

			iStoreCounter++;

			}

		iPeekPrevStorage[count].iMems |= memtype;

		}

	CleanupStack::PopAndDestroy();

	LOGTEXT2(_L8("CATSmsMemoryStorage\t%d memory stores found"), iStoreCounter);

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

		{

		LOGTEXT3(_L8("CATSmsMemoryStorage\t\tStore %S supports %x"), 

			&iPeekPrevStorage[count].iStoreName, iPeekPrevStorage[count].iMems);

		}

	}

TInt CATSmsMemoryStorage::GetNumberOfMessageStores()

//

// Returns to client, the number of different message stores (mem1, mem2 etc)

//

	{

	return iStoreCounter;

	}

TInt CATSmsMemoryStorage::WhichPreferredMem(TInt aIndex)

//

//	Information from Client, telling TSY which is the preferred memory.

//

	{

	TInt ret(KErrNone);

	iClientPreferredMem = aIndex;

	if (iClientPreferredMem > (iStoreCounter - 1))

		ret=KErrNotSupported;

	return ret;

	}

void CATSmsMemoryStorage::Stop(TTsyReqHandle aTsyReqHandle)

//

//	Attempts to halt the process

//

	{

	__ASSERT_ALWAYS(aTsyReqHandle == iReqHandle,Panic(EIllegalTsyReqHandle));		

	LOGTEXT(_L8("CATSmsMemoryStorage:\tCancelling Command"));

	LOGTEXT2(_L8("Current state TSY is cancelling from %d"), iState);

	// Wait for convenient place in state machine to cancel

	iCancelled=ETrue;

	}

void CATSmsMemoryStorage::Complete(TInt aError)

	{

	Complete(aError,EReadCompletion);

	}

void CATSmsMemoryStorage::Complete(TInt aError,TEventSource aSource)

	{

	iIo->WriteAndTimerCancel(this);

	iIo->RemoveExpectStrings(this);

	iOKExpectString = NULL;

	iErrorExpectString = NULL;

	CATCommands::Complete(aError,aSource);

	iTelObject->ReqCompleted(iReqHandle, aError);

	if (aSource==EWriteCompletion)

		iIo->Read();

	iState = EATNotInProgress; 

	}	

void CATSmsMemoryStorage::CompleteWithIOError(TEventSource /*aSource*/,TInt aStatus)

	{

	if (iState!=EATNotInProgress)

		{

		iIo->WriteAndTimerCancel(this);

		iTelObject->ReqCompleted(iReqHandle, aStatus);

		iState = EATNotInProgress;

		}

	}

void CATSmsMemoryStorage::CopyDataFromCATInit(CATInit* aInit)

//

// CATInit creates a separate instance of CATSmsMemoryStorage and uses this to get

// enumeratestore info during initialisation of the TSY. CMobileSmsMessaging creates another

// instance of CATSmsMemoryStorage, but this new instance requires a lot of the information

// contained within the CATInit instance. Due to iTelObject problems, we can't just do

// a iATSmsMemoryStorage = iInit->iEnumerate; during the ConstructL() of CMobileSmsMessaging.

//

	{

	iStoreCounter = aInit->iEnumerate->iStoreCounter;

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

		iPeekPrevStorage[i] = aInit->iEnumerate->iPeekPrevStorage[i];

	}

void CATSmsMemoryStorage::GetPrefMemL()

//

// Parse result of AT+CPMS?

// this will allocate the phone's pref'd memory to the iPhoneGlobals->iPhonePrefMem local storage.

//

	{

	ParseBufferLC();

	RemoveUnsolicitedStrings();    // Removes any unsolicited strings

	CATParamListEntry* entry;

	TDblQueIter<CATParamListEntry> iter(iRxResults);

	// +CPMS: <mem1>,<used1>,<total1>,<mem2>,<used2>,<total2>,<mem3>,<used3>,<total3>

	entry = iter++;		

	if (entry==NULL || entry->iResultPtr != KCPMSResponseString)

		User::Leave(KErrNotFound);

	entry = iter++;

	if (entry==NULL || 

	    (entry->iResultPtr != KBMStorage &&

		  entry->iResultPtr != KMEStorage &&

		  entry->iResultPtr != KSMStorage &&

		  entry->iResultPtr != KTAStorage))

		{

		User::Leave(KErrNotFound);

		}

	iPhoneGlobals->iPhonePrefMem = entry->iResultPtr;

	LOGTEXT2(_L8("CATSmsMemoryStorage:\tPreferred Memory %S"), &iPhoneGlobals->iPhonePrefMem);

	CleanupStack::PopAndDestroy();

	}

TInt CATSmsMemoryStorage::SMSStoreCaps(TDes& aName)

/**

 * This method returns the capabilities for a specific SMS store.

 */

	{

	TInt caps = 0;

	if ((aName.CompareF(KETelMeSmsStore)==KErrNone) ||

		(aName.CompareF(KETelIccSmsStore)==KErrNone))

		{

		caps |= RMobileSmsStore::KCapsUnreadMessages;

		caps |= RMobileSmsStore::KCapsReadMessages;

		caps |= RMobileSmsStore::KCapsUnsentMessages;

		caps |= RMobileSmsStore::KCapsSentMessages;

		caps |= RMobileSmsStore::KCapsGsmMessages;

		caps |= RMobilePhoneStore::KCapsIndividualEntry;

		caps |= RMobilePhoneStore::KCapsReadAccess;

		caps |= RMobilePhoneStore::KCapsWriteAccess;

		return caps;

		}

	return caps; // If the store was not found zero is returned

	}