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

// Multimode TSY Phone book Implementation file.

// This file contains the implementation of the CATPhoneBookCommands, CATPhoneBookInit,

// CATPhoneBookWrite and CATPhoneBookDelete classes. 

// 

//

/**

 @file

*/

#include "Mphbkcom.h"

#include "mSLOGGER.H"

#include "mPHBOOK.H"

#include "NOTIFY.H"

#include "ATIO.H"

#include "Matstd.h"

// AT commands

_LIT8(KPhoneBookReadAll,"AT+CPBR=");	// Modified from "AT+CPBR=1,n; 1 is not always the starting index

_LIT8(KPhoneBookReadResponse,"+CPBR:*");

_LIT8(KPhoneBookWriteWithIndex,"AT+CPBW=%d,\"%S\",%d,\"%S\"");

_LIT8(KPhoneBookWriteWithIndexPrependedPlus,"AT+CPBW=%d,\"+%S\",%d,\"%S\"");

_LIT8(KPhoneBookDelete,"AT+CPBW=%d");

_LIT8(KPhoneBookAlternativeDelete,"AT+CPBW=%d,\"\",,\"\"");

const TInt KPhoneBookTimeForExtraRxData=100;

// Time-outs

const TInt KPhoneBookReadTimeout=30;	//< Time-out used when reading the phone books (in seconds). For sizeable phonebooks, this can be large.

										//< The Siemens S25 is the slowest phone observed. The Nokia 8210 can take 14s to read an empty 200 entry phonebook.

//

// CATPhoneBookCommands definitions

//

CATPhoneBookCommands::CATPhoneBookCommands(CATIO* aIo,CTelObject* aTelObject,CATInit* aInit,CPhoneGlobals* aPhoneGlobals)

	: CATCommands(aIo,aTelObject,aInit,aPhoneGlobals), iState(EATPhoneBookCommandIdle)

	{}

CATPhoneBookCommands::~CATPhoneBookCommands()

/**

 * Destructor.

 */

	{

	iIo->RemoveExpectStrings(this);

	}

void CATPhoneBookCommands::EventSignal(TEventSource aEventSource)

/**

 * This function contains the State machine for the phonebook commands whose classes

 * inherit from the CATPhoneBookCommands class.

 *

 * Note: The cases EATPhoneBookCommandWaitForReadComplete & EATPhoneBookCommandWait-

 * ForAlternativeReadComplete are overriden by similar cases in CATPhoneBookInit::

 * EventSignal and CATPhoneBookRead::EventSignal.

 */

	{

	if (aEventSource==ETimeOutCompletion && iState!=EATPhoneBookCommandExtendedRead)

		{

		LOGTEXT(_L8("Timeout Error during phone book command"));

		RemoveStdExpectStrings();

		Complete(KErrTimedOut,aEventSource);

		return;

		}

	TInt ret=KErrNone;

	switch (iState)

		{

	case EATPhoneBookStorageSelectWaitForWriteComplete:

		__ASSERT_ALWAYS(aEventSource==EWriteCompletion,Panic(EATCommand_IllegalCompletionWriteExpected));

		AddStdExpectStrings();

		iIo->SetTimeOut(this);

		iState=EATPhoneBookStorageSelectWaitForReadComplete;

		return;

	case EATPhoneBookStorageSelectWaitForReadComplete:

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

			{

			ret=ValidateExpectString();

			RemoveStdExpectStrings();

			if (ret!=KErrNone)

				{

				Complete(ret,aEventSource);

				return;

				}

			CMobilePhonebookStore* phoneBook=REINTERPRET_CAST(CMobilePhonebookStore*,iTelObject);

			iPhoneGlobals->iPhoneStatus.iLastAccessedPhoneBook=phoneBook->StorageType();

			}

		StartThisCommand();

		return;

	case EATPhoneBookCommandWaitForWriteComplete:

		__ASSERT_ALWAYS(aEventSource==EWriteCompletion,Panic(EATCommand_IllegalCompletionWriteExpected));

		iIo->SetTimeOut(this); 

		AddStdExpectStrings();

		iState=EATPhoneBookCommandWaitForReadComplete;

		return;

	case EATPhoneBookCommandWaitForReadComplete:

	case EATPhoneBookCommandWaitForAlternativeReadComplete:

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

		ret=ValidateExpectString();

		RemoveStdExpectStrings();

		if (ret!=KErrNone)

			{

			Complete(ret,aEventSource);

			return;

			}

		iIo->SetTimeOut(this,KPhoneBookTimeForExtraRxData);

		iState=EATPhoneBookCommandExtendedRead;

		return;

	case EATPhoneBookCommandWaitForAlternativeWriteComplete:

		__ASSERT_ALWAYS(aEventSource==EWriteCompletion,Panic(EATCommand_IllegalCompletionWriteExpected));

		iIo->SetTimeOut(this,KPhoneBookReadTimeout*KOneSecondPause);

		AddStdExpectStrings();

		iState=EATPhoneBookCommandWaitForAlternativeReadComplete;

		return;

	case EATPhoneBookCommandExtendedRead:

		__ASSERT_ALWAYS(aEventSource==ETimeOutCompletion,Panic(EATCommand_IllegalCompletionWaitExpected));

		Complete(ret,aEventSource);

		return;

	case EATPhoneBookCommandIdle:

	default:

		return;

		}

	}

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

/**

 * This function is called if an error occurs. It cancels the relevant timer and 

 * completes the request before setting the state to Idle.

 */

	{

	if (iState!=EATPhoneBookCommandIdle)

		{

		iIo->WriteAndTimerCancel(this);

		iTelObject->ReqCompleted(iReqHandle,aStatus);

		iState=EATPhoneBookCommandIdle;

		}

	}

void CATPhoneBookCommands::StartStorageSelect()

/**

 * This function finds out which phone book memory to set and then transmits the 

 * set command ("AT+CPBS=xx") to the relevant phone book.

 */

	{

	LOGTEXT(_L8("Starting AT+CPBS= Command"));

	CMobilePhonebookStore* phoneBook=REINTERPRET_CAST(CMobilePhonebookStore*,iTelObject);

	if (iPhoneGlobals->iPhoneStatus.iLastAccessedPhoneBook==phoneBook->StorageType())

		{

		StartThisCommand();

		}

	else

		{

		TBuf8<KGenericBufferSize> buf;

		TStorageType storageType(phoneBook->StorageType());

		buf.Format(KPhoneBookStorageSet,&storageType);

		WriteExpectingResults(buf,3);

		__ASSERT_ALWAYS(iIo->AddExpectString(this,KNotifyMeIfErrorString) != NULL, Panic(EGeneral));

		iState=EATPhoneBookStorageSelectWaitForWriteComplete;

		}

	}

void CATPhoneBookCommands::Stop(TTsyReqHandle aTsyReqHandle)

/**

 * This function is used to prematurely stop the state machine.  This would usually 

 * occur following a client cancel request.

 */

	{

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

	LOGTEXT(_L8("Cancelling phone book command"));

	switch (iState)

		{

	case EATPhoneBookStorageSelectWaitForWriteComplete:

	case EATPhoneBookCommandWaitForWriteComplete:

	case EATPhoneBookCommandWaitForAlternativeWriteComplete:

		Complete(KErrCancel,EWriteCompletion);

		return;

	case EATPhoneBookStorageSelectWaitForReadComplete:

	case EATPhoneBookCommandWaitForReadComplete:

	case EATPhoneBookCommandWaitForAlternativeReadComplete:

		Complete(KErrCancel,EReadCompletion);

		return;

	case EATPhoneBookCommandExtendedRead:

		Complete(KErrCancel,ETimeOutCompletion);

		return;

	case EATPhoneBookCommandIdle:

	default:

		return;

		}

	}

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

/**

 * This function completes a client request. Sets the state machine to Idle.

 */

	{

	iIo->WriteAndTimerCancel(this);

	iIo->RemoveExpectStrings(this);

	if (aSource==EWriteCompletion)

		iIo->Read();

	iState=EATPhoneBookCommandIdle;

	CATCommands::Complete(aError,aSource);

	iTelObject->ReqCompleted(iReqHandle,aError);

	}

//

// CATPhoneBookRead definitions

//

CATPhoneBookRead::CATPhoneBookRead(CATIO* aIo,CTelObject* aTelObject,CATInit* aInit,CPhoneGlobals* aPhoneGlobals,CATPhoneBookInfo *aInfo)

	: CATPhoneBookCommands(aIo,aTelObject,aInit,aPhoneGlobals),

	  iInfo(aInfo)

/**

 * C++ constructor

 */

	{}

CATPhoneBookRead::~CATPhoneBookRead()

/** 

 * Destructor.

 */

	{

	delete iPbBuffer;

	}

CATPhoneBookRead* CATPhoneBookRead::NewL(CATIO* aIo,CTelObject* aTelObject,CATInit* aInit,CPhoneGlobals* aPhoneGlobals,CATPhoneBookInfo *aInfo)

/**

 * Standard 2 phase constructor.

 * This method creats an instance of the CATPhoneBookRead class. 

 */

	{

	CATPhoneBookRead* r=new(ELeave) CATPhoneBookRead(aIo,aTelObject,aInit,aPhoneGlobals,aInfo);

	CleanupStack::PushL(r);

	r->ConstructL();

	CleanupStack::Pop();

	return r;

	}

void CATPhoneBookRead::ConstructL()

/**

 * Standard 2nd phase constructor.

 * Creates phonebook buffer object used to populate client buffer

 */

	{

	CATCommands::ConstructL();

	iPbBuffer = new(ELeave) CPhoneBookBuffer();

	}

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

/**

 * Start function. Its calls the StartStorageSelect() function to select 

 * the phone book memory.

 */

	{

	iReqHandle=aTsyReqHandle;

	iRead = static_cast<RMobilePhoneBookStore::TPBIndexAndNumEntries*>(aParams);

	StartStorageSelect();

	}

void CATPhoneBookRead::StartThisCommand()

/**

 * This function starts the "AT+CPBR=minimum index, maximum index" command, i.e, 

 * Read one or a number of entries in the selected phone book. It constructs the command

 * using the starting index and the number of entries that are to be read. It

 * then sets the state machine going.

 */ 

	{

	LOGTEXT(_L8("Starting AT+CPBR=minIndex,maxIndex Command (Read one or more entries)"));

	// Construct the AT+CPBR=a,z command. The starting index is not necessarily 1

 	TBuf8<KGenericBufferSize> buf(KPhoneBookReadAll);

	buf.AppendNum(iRead->iIndex); // starting location in the phonebook from which to read

	if (iRead->iNumSlots>1)

		{

		// If more than one entry to be read also put finishing index

		buf.Append(KCommaChar);

		buf.AppendNum(iRead->iIndex + iRead->iNumSlots -1); // last location from which to read

		}

	iNumReadEntries=0;

	WriteExpectingResults(buf,3);

	__ASSERT_ALWAYS(iIo->AddExpectString(this,KNotifyMeIfErrorString) != NULL, Panic(EGeneral));

	iCPBRResponse=iIo->AddExpectString(this,KPhoneBookReadResponse);

	iState=EATPhoneBookCommandWaitForAlternativeWriteComplete;

	}

void CATPhoneBookRead::ParseResponseL()

/**

 * This function parses a line of response to the "AT+CBPR=minimum index, maximum index"

 * command and converts the phonebook data into the TLV format. Note that the minimum 

 * index of the phone book memory need not necessarily 

 * start at 1 (e.g the phonebook could use range [100 to 150].

 */

	{

	ParseBufferLC(EFalse, ':');

	TDblQueIter<CATParamListEntry> iter(iRxResults);

	CATParamListEntry* entry=iter++; //Assume discarded CPBR string

	if (entry==NULL)

		User::Leave(KErrGeneral);

	TInt ret(KErrNone);

	TBuf16<KGenericBufferSize> buffer;

	// new entry so append the new entry tag first

	if(iPbBuffer->AddNewEntryTag() == KErrNone)

		{	

		// convert index into TLV format and append it to the supplied buffer

		entry=iter++;

		if(!entry)

			User::Leave(KErrGeneral);

		TInt index=CATParamListEntry::EntryValL(entry);

		if (iInfo->Completed()) 

			{

			LOGTEXT(_L8("CATPhoneBookRead::ParseResponseL Mapping phone index to client index"));

			iInfo->MapPhoneIndexToClientIndex(index);

			}

		ret = iPbBuffer->PutTagAndValue(RMobilePhoneBookStore::ETagPBAdnIndex, static_cast<TUint16>(index));

		if(ret == KErrNone) // only continue if the previous field successfully appended

			{		

			// convert number into TLV format and append it to the supplied buffer

			entry=iter++;

			if (!entry)

				User::Leave(KErrGeneral);

			buffer.Copy(entry->iResultPtr);

// If the number has a leading "+" then remove it.  Note: in this case, we assume that the TON will be international.

			if((buffer.Length()>0)&&(buffer[0]=='+'))

				buffer.Delete(0,1);

			TPtrC16 numberPtr(buffer);

			ret=iPbBuffer->PutTagAndValue(RMobilePhoneBookStore::ETagPBNumber, numberPtr);

			if(ret == KErrNone)	// only continue if the previous field successfully appended

				{

				// convert type into TLV format and append it to the supplied buffer

				entry=iter++;

				TInt type=CATParamListEntry::EntryValL(entry);

				ret=iPbBuffer->PutTagAndValue(RMobilePhoneBookStore::ETagPBTonNpi, static_cast<TUint8>(type));

				if(ret == KErrNone) // only continue if the previous field successfully appended

					{

					// convert text into TLV format and append it to the supplied buffer

					entry=iter++;

					if (!entry)

						User::Leave(KErrGeneral);

					buffer.Copy(entry->iResultPtr);

					TPtrC16 textPtr(buffer);

					ret=iPbBuffer->PutTagAndValue(RMobilePhoneBookStore::ETagPBText, textPtr);

					if(ret==KErrNone)

						iNumReadEntries++;

					}

				}

			}	

		} // end if AddNewEntryTag

	// one of the fields could not be appended so remove previous fields from the buffer

	if(ret != KErrNone)

		{

		(void)iPbBuffer->RemovePartialEntry();

		}

	CleanupStack::PopAndDestroy();		// parsed buffer

	}

void CATPhoneBookRead::EventSignal(TEventSource aEventSource)

/**

 * State machine. Replaces CATPhoneBookCommands implementation to use second command 

 * state.

 */

	{

	if ((aEventSource!=ETimeOutCompletion) && (iState==EATPhoneBookCommandWaitForAlternativeReadComplete))

		{

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

		// may be a entry, OK, or ERROR

		if (iIo->FoundChatString()==iCPBRResponse)

			{

			TRAPD(ret,ParseResponseL());

			if (ret!=KErrNone)

				{

				Complete(ret,EReadCompletion);

				return;

				}

			// wait for another one

			iIo->SetTimeOut(this,KPhoneBookReadTimeout*KOneSecondPause);

			} 

		else

			{

			TInt ret(ValidateExpectString());

			RemoveStdExpectStrings();

			if((ret==KErrNone)&&(iNumReadEntries==0))

				{

// No entries read, so buffer will be empty and KErrNotFound must be returned.

				ret=KErrNotFound;

				}

			Complete(ret,EReadCompletion); 

			}

		} 

	else

		CATPhoneBookCommands::EventSignal(aEventSource);

	}

void CATPhoneBookRead::CompleteWithIOError(TEventSource,TInt aError)

/**

 * This function is called if an error occurs. It cancels the relevant timer and 

 * completes the request.

 */

	{

	if (iState!=EATPhoneBookCommandIdle)

		{

		iIo->WriteAndTimerCancel(this);

		iCPBRResponse=0;

		iState=EATPhoneBookCommandIdle;

		iTelObject->ReqCompleted(iReqHandle,aError);

		}

	}

//

// CATPhoneBookWrite definitions

//

CATPhoneBookWrite* CATPhoneBookWrite::NewL(CATIO* aIo,CTelObject* aTelObject,CATInit* aInit,CPhoneGlobals* aPhoneGlobals)

/**

 * Standard 2 phase constructor.

 * This method creats an instance of the CATPhoneBookWrite class. 

 */

	{

	CATPhoneBookWrite* r=new(ELeave) CATPhoneBookWrite(aIo,aTelObject,aInit,aPhoneGlobals);

	CleanupStack::PushL(r);

	r->ConstructL();

	CleanupStack::Pop();

	return r;

	}

CATPhoneBookWrite::CATPhoneBookWrite(CATIO* aIo,CTelObject* aTelObject,CATInit* aInit,CPhoneGlobals* aPhoneGlobals)

	: CATPhoneBookCommands(aIo,aTelObject,aInit,aPhoneGlobals)

/**

 * C++ constructor

 */

	{}

void CATPhoneBookWrite::ConstructL()

/**

 * Standard 2nd phase constructor.

 * Creates phonebook buffer object used to extract data from client buffer

 */

	{

	CATCommands::ConstructL();

	iPbBuffer = new(ELeave) CPhoneBookBuffer();

	}

CATPhoneBookWrite::~CATPhoneBookWrite()

/**

 * Destructor.

 */

	{

	delete iPbBuffer;

	}

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

/**

 * Start function. Its calls the StartStorageSelect() function to select 

 * the phone book memory.

 */

	{

	iReqHandle=aTsyReqHandle;

	iIndex = *(static_cast<TInt*>(aParams)); // aParams will contain an index 

	StartStorageSelect();

	}

void CATPhoneBookWrite::StartThisCommand()

/**

 * This function starts the Write command. It decodes the phonebook data supplied by the

 * client from the TLV format into the AT+CPBW= format, builds the command and 

 * starts the state machine to write the entry to the phone. It can only write 

 * one entry at a time.

 */

	{

	LOGTEXT(_L8("Starting AT+CPBW= Command"));

	TBuf8<KGenericBufferSize> atbuf;     // used for 8-bit AT command characters

	TBuf8<KGenericBufferSize> name;

	TBuf8<KGenericBufferSize> number;

	TBuf16<KGenericBufferSize> des16Buf;	  // used for 16-bit name field

	TPtrC16 des16Ptr(des16Buf);

	TUint8 tonNpi(0);

	TUint8 aTagValue(0);

	CPhoneBookBuffer::TPhBkTagType aDataType; 

	TInt ret=KErrNone;

	iPbBuffer->StartRead();

	while ((ret=iPbBuffer->GetTagAndType(aTagValue, aDataType))==KErrNone)

		{

		if (aTagValue==RMobilePhoneBookStore::ETagPBTonNpi)

			{