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

// Phase 1 - variable name change only - still compiles

// 

//

/**

 @file

*/

#include <e32test.h>

#include <etelmm.h>

#include <mpbutil.h>	

#include "Te_LoopBackcphoneBook.h"

#include "../../hayes/TSYCONFG.H" // for KInternetAccessPoint

// Entries to write to the iPhone book

_LIT(KMuddyWatersText,"MuddyW");

_LIT(KArethaFText,"ArethaF");

_LIT(KMuddyWatersPhoneNum,"02220111");

_LIT(KArethaFPhoneNum,"03334567");

//

// Test-side class

// With the assistance of the base class, this class must start the emulator

// and drive the ETel API.

//

CTestDrivePhoneBook* CTestDrivePhoneBook::NewL(const TScriptList aScriptListEntry)

	{

	CTestDrivePhoneBook* phBk=new(ELeave) CTestDrivePhoneBook(aScriptListEntry);

	CleanupStack::PushL(phBk);

	phBk->ConstructL();

	CleanupStack::Pop();

	return phBk;

	}

CTestDrivePhoneBook::CTestDrivePhoneBook(const TScriptList aScriptListEntry) : 

	iMESupported(EFalse), iScriptListEntry(aScriptListEntry)

	{}

TInt CTestDrivePhoneBook::RunTestL()

	{

	iCurrentScript=iScriptListEntry;

	return StartEmulatorL();

	}

TInt CTestDrivePhoneBook::DriveETelApiL()

//

// This function contains the real meat of the Client-side test code

//

	{

 	_LIT(KMmPhoneName,"GsmPhone1");

	// Open and Initialise the iPhone

 	TESTL(iMmPhone.Open(iServer,KMmPhoneName)==KErrNone);

	TRequestStatus reqStatus;

	RMobilePhone::TMMTableSettings tableSettings;

	tableSettings.iLocId=KInternetAccessPoint;

	RMobilePhone::TMMTableSettingsPckg tableSettingsPckg(tableSettings);

	iMmPhone.InitialiseMM(reqStatus , tableSettingsPckg); 	

	User::WaitForRequest(reqStatus);

	TESTL(reqStatus == KErrNone);

 	ERR_PRINTF1(_L("Phone Id, Available Phone books and Get Info"));

 	GetPhoneInfoL();

 	ERR_PRINTF1(_L("Get PhoneBook Capabilities and Information"));

  	testGetPhBkCapsAndInfoL(); 

 	ERR_PRINTF1(_L("Deleting the 1st 5 entries in the SM and ME (if supported) phonebooks"));

 	TInt ret;

 	ret=testClearPhBkL(KETelIccAdnPhoneBook);

 	TESTL(ret==KErrNone);

 	if (iMESupported)

		{

 		ret=testClearPhBkL(KETelMeAdnPhoneBook);

 		TESTL(ret==KErrNone);

		}

 	ERR_PRINTF1(_L("Phone book Read and Write"));

 	testPhoneBookReadAndWrite(); // New method using CPhoneBookBuffer

 	ERR_PRINTF1(_L("Advanced Phone book tests"));

	testAdvancedPhoneBook();  // New method using CPhoneBookBuffer

	ERR_PRINTF1(_L("Phone book Notifications"));

 	testPhoneBookNotifications(); // New method using CPhoneBookBuffer

	ERR_PRINTF1(_L("Phone book Read Cancel Requests"));

	testPhoneBookReadCancel(); // New method using CPhoneBookBuffer

	ERR_PRINTF1(_L("Phone book Read & Write International Numbers"));

	testPhoneBookReadAndWriteInternationalL();

	ERR_PRINTF1(_L("Phone book Multithread Write"));

	testPhoneBookMultiWriteL();

	iMmPhone.Close();

	return KErrNone;

	}

void CTestDrivePhoneBook::GetPhoneInfoL()

/**

 * Retrieve iPhone Information

 */

	{

	TRequestStatus stat;

	RMobilePhone::TMobilePhoneIdentityV1 phoneId;

	iMmPhone.GetPhoneId(stat,phoneId);

	User::WaitForRequest(stat);

	TESTL(stat == KErrNone);

	// check version id ?

	INFO_PRINTF2(_L("Extension ID : %d"), phoneId.ExtensionId());

	INFO_PRINTF2(_L("\nManufacturer ID : %S"), &phoneId.iManufacturer);

	INFO_PRINTF2(_L("Model ID : %S"), &phoneId.iModel);

	INFO_PRINTF2(_L("Revision ID : %S"), &phoneId.iRevision);

	INFO_PRINTF2(_L("Serial number : %S\n"), &phoneId.iSerialNumber);

	// common mode

	TInt numAvail=0;  // counts number of phonebooks

	IsPhoneBookAvailable (KETelMeAdnPhoneBook, numAvail);

	IsPhoneBookAvailable (KETelMeDialledPhoneBook, numAvail);

	IsPhoneBookAvailable (KETelMeMissedPhoneBook, numAvail);

	IsPhoneBookAvailable (KETelMeReceivedPhoneBook, numAvail);

	IsPhoneBookAvailable (KETelCombinedAdnPhoneBook, numAvail);

	IsPhoneBookAvailable (KETelIccAdnPhoneBook, numAvail);

	IsPhoneBookAvailable (KETelIccFdnPhoneBook, numAvail);

	IsPhoneBookAvailable (KETelIccSdnPhoneBook, numAvail);

	// gsm mode

	IsPhoneBookAvailable (KETelTaAdnPhoneBook, numAvail);

	IsPhoneBookAvailable (KETelIccBdnPhoneBook, numAvail);

	IsPhoneBookAvailable (KETelIccVoiceMailBox, numAvail);

	INFO_PRINTF2(_L("%d Phonebooks available.\n"), numAvail);

}

TRequestStatus CTestDrivePhoneBook::IsPhoneBookAvailable(const TDesC& aPhoneBook,

                                                         TInt &aCount)

	{

	TRequestStatus stat;

	RMobilePhoneStore::TMobilePhoneStoreInfoV1 info;

	RMobilePhoneStore::TMobilePhoneStoreInfoV1Pckg infoPkg(info);

	iMmPhone.GetPhoneStoreInfo(stat,infoPkg,aPhoneBook);

	User::WaitForRequest(stat);

	if (stat == KErrNone)	// available

		{

		INFO_PRINTF2(_L("%S Phone Book is available.\n"), &aPhoneBook);

		aCount++;

		}

	else

		{

		INFO_PRINTF3(_L("%S Phone Book is NOT available. Status %d.\n"), &aPhoneBook, stat.Int());

		}

	return stat;

	}

void CTestDrivePhoneBook::testGetPhBkCapsAndInfoL()

/**

 * This function:

 *		Gets the SIM and ME iPhone books static capabilities,

 *		Information associated with the iPhone books,

 *		and also Validates the obtained information.

 */

	{

	// SIM iPhone book - mandatory

	TInt ret=KErrNone;

	RMobilePhoneBookStore simPhBk;

	ret=simPhBk.Open(iMmPhone,KETelIccAdnPhoneBook);

	TESTL(ret==KErrNone);

	// Get SM Phone book Capabilities

	TRequestStatus stat=0;

	RMobilePhoneStore::TMobilePhoneStoreInfoV1 info;

	RMobilePhoneStore::TMobilePhoneStoreInfoV1Pckg infoPkg(info);

	simPhBk.GetInfo(stat,infoPkg);

	User::WaitForRequest(stat);

	TESTL(stat == KErrNone);

	info = infoPkg();

	// Need to Read entries 

	TESTL((info.iCaps & RMobilePhoneStore::KCapsWriteAccess)!=0);

	TESTL(info.iName == KETelIccAdnPhoneBook);

	TESTL(info.iType == RMobilePhoneStore::EPhoneBookStore); 

	TESTL(info.iTotalEntries > 0);

	simPhBk.Close();

	RMobilePhoneBookStore mePhBk;

	ret=mePhBk.Open(iMmPhone,KETelMeAdnPhoneBook);

	if (ret==KErrNone)

		{

		INFO_PRINTF1(_L("ME phonebook supported\n"));

		iMESupported=ETrue;

		mePhBk.GetInfo(stat,infoPkg);

		User::WaitForRequest(stat);

		TESTL(stat == KErrNone);

		info = infoPkg();

		TESTL((info.iCaps & RMobilePhoneStore::KCapsWriteAccess)!=0);

		// Need to read entries

		TESTL(info.iName == KETelMeAdnPhoneBook);

		TESTL(info.iType == RMobilePhoneStore::EPhoneBookStore);

		TESTL(info.iTotalEntries > 0);

		// GetInfo Cancel Request

		INFO_PRINTF1(_L("GetInfo Cancel Request..."));

		mePhBk.GetInfo(stat,infoPkg);

		mePhBk.CancelAsyncRequest(EMobilePhoneStoreGetInfo);

		User::WaitForRequest(stat);

		INFO_PRINTF2(_L("GetInfo Cancel Status = %d"), stat.Int());

		TESTL(stat==KErrNone || stat==KErrCancel);

		mePhBk.Close();

		}

	else 

		INFO_PRINTF1(_L("ME phonebook is NOT supported"));

	}

TInt CTestDrivePhoneBook::testClearPhBkL(const TDesC& aPhoneBookName)

/**

 * This function deletes the first 5 entries in the SM and ME (if supported) phonebooks.

 */

	{	

	TInt ret=KErrNone;

	RMobilePhoneBookStore thePhBk;

	TRequestStatus stat;

	// Open the SM iPhone book

	ret=thePhBk.Open(iMmPhone,aPhoneBookName);

	TESTL(ret==KErrNone);

	INFO_PRINTF2(_L("Deleting %S phonebook entries..."), &aPhoneBookName);

	TInt i;

	for (i=1; i<=5; i++)

		{

		thePhBk.Delete(stat,i);

		User::WaitForRequest(stat);

		if (stat!=KErrNone && stat!=KErrNotFound)

			break;

		}

// Check that KErrNotFound is returned when reading an empty phonebook.

	TBuf8<50> buf;

	thePhBk.Read(stat,1,99,buf);

	User::WaitForRequest(stat);

	TESTL(stat==KErrNotFound);

	thePhBk.Close();

	return ret;

	}

void CTestDrivePhoneBook::ReadAndWriteL()

/**

 * This function writes a few entries to the SM phonebook and then reads them back.

 */

	{

	TInt ret=KErrNone;

	RMobilePhoneBookStore simPhBk;

	// Open the SM iPhone book

	ret=simPhBk.Open(iMmPhone,KETelIccAdnPhoneBook);

	TESTL(ret==KErrNone);

	simPhBk.Close();

	}

void CTestDrivePhoneBook::testAdvancedPhBkL() 

/**

 * This function opens an Advanced GSM ME PhoneBook, writes a few entries to it, and then

 * deletes these entries.

 */

	{

	TInt ret=KErrNone;

	RMobilePhoneBookStore mePhBk;

	ret=mePhBk.Open(iMmPhone,KETelMeAdnPhoneBook);

	TESTL(ret==KErrNone);

	mePhBk.Close();

	}

 void CTestDrivePhoneBook::testPhBkNotificationsL()

/**

 * This function opens the ME phonebook and posts a request for notification when an 

 * entry is modified.

 */

	{

	RMobilePhoneBookStore mePhBk;

	const TInt Pause=2000000;		// 2 second pause

	TRequestStatus writeStatus = KErrNone;

	TESTL(mePhBk.Open(iMmPhone,KETelMeAdnPhoneBook)==KErrNone);

	TRequestStatus status;

	TInt index=KErrNone;

	TUint32 eventChange;

	// Post a notification request

	//mePhBk.EntryChangedNotification(status,index);

	mePhBk.NotifyStoreEvent(status,eventChange,index);

	if (writeStatus==KErrCancel)

		{

		INFO_PRINTF1(_L("This is unexpected!!!. If the test carries on, this means that\n"));

		INFO_PRINTF1(_L("the Write request has been transmitted to the iPhone regardless of\n"));		

		INFO_PRINTF1(_L("of the apparent success of the Write cancel request.\n\n"));

		}

	else

		TESTL(writeStatus==KErrNone);	// The Cancel request was not successful

	// Completion of the notification request posted earlier

	User::WaitForRequest(status);

	TESTL(status==KErrNone);

	TESTL(index==1);

	// Post another notification request

	mePhBk.NotifyStoreEvent(status,eventChange,index);

	// Delete and DeleteCancel Request. Wait 2 seconds before posting the Cancel request.

	// Enables the request to get through to the TSY (simplifies the script).

	INFO_PRINTF1(_L("Delete Cancel Request..."));

	TRequestStatus deleteStatus;

	mePhBk.Delete(deleteStatus,index);

	User::After(Pause);		// Wait 2s, give the request time to get through to the TSY.

	mePhBk.CancelAsyncRequest(EMobilePhoneStoreDelete);

	User::WaitForRequest(deleteStatus);

	INFO_PRINTF2(_L("Delete Cancel Status = %d"), deleteStatus.Int());

	if (deleteStatus==KErrCancel)

		{

		INFO_PRINTF1(_L("This is unexpected!!!. If the test carries on, this means that"));

		INFO_PRINTF1(_L("the Delete request has been transmitted to the iPhone regardless"));

		INFO_PRINTF1(_L("of the apparent success of the Delete cancel request."));

		}

	else

		{

		TESTL(deleteStatus==KErrNone);	// The Cancel request was not successful

		}

	// Completion of the 2nd notification request posted, (dependent on the Delete request above)

	User::WaitForRequest(status);

	TESTL(status==KErrNone);

	TESTL(index==1);

	// EntryChangedNotificationCancel Request

	mePhBk.NotifyStoreEvent(status,eventChange,index);

	mePhBk.CancelAsyncRequest(EMobilePhoneStoreNotifyStoreEvent);

	User::WaitForRequest(status);

	TESTL(status==KErrCancel || status==KErrNone);

	INFO_PRINTF2(_L("EntryChangedNotificationCancel Status = %d"), status.Int());

	mePhBk.Close();

	}		

void CTestDrivePhoneBook::testPhBkReadCancelL()

/**

 * This function writes a few entries to the SM phonebook, and then does some Read Requests

 * which are cancelled.

 */

	{

	TInt ret=KErrNone;

	RMobilePhoneBookStore simPhBk;

	// Open the SM iPhone book

	ret=simPhBk.Open(iMmPhone,KETelIccAdnPhoneBook);

	TESTL(ret==KErrNone);

	// Close the iPhone book

	simPhBk.Close();

	}

//****************************************************************************

//						NEW Methods based on CPhoneBookBuffer class

//****************************************************************************

// testing the PhoneBook ReadAndWrite

void CTestDrivePhoneBook::testPhoneBookReadAndWrite()

	{

	TRAP_IGNORE(DotestPhoneBookReadAndWriteL());		// trap but ignore error

	}

void CTestDrivePhoneBook::DotestPhoneBookReadAndWriteL()

	{

	TInt ret=KErrNone;

	TRequestStatus aStatus;

	RMobilePhoneBookStore simPhBk;

	TBuf8<(RMobileSmsMessaging::KGsmTpduSize*3)> pbData, pbReadData1;

	TInt requestedIndex(0), numOfEntries(1);

	TESTL(simPhBk.Open(iMmPhone,KETelIccAdnPhoneBook()) == KErrNone);

	const TText16* names[]={(TText16*)KMuddyWatersText.iBuf, (TText16*)KArethaFText.iBuf};

	const TText16* numbers[]={(TText16*)KMuddyWatersPhoneNum.iBuf, (TText16*)KArethaFPhoneNum.iBuf};

	const TInt KBufSize=20;

	TBuf16<KBufSize> entryNumber(numbers[0]);

	TBuf16<KBufSize> entryName(names[0]);

	CPhoneBookBuffer* pbBuffer = new(ELeave) CPhoneBookBuffer();

	pbBuffer->Set(&pbData); // Set it to point to the Client buffer

	// Write the entries to the SIM Phone Book

	TInt writeIndex(0);

	TUint i(0), size(2); // Only entries are written

	for (i=1; i<=size; ++i)

		{

		//first reset the following three local buffers to delete any existing data

		entryNumber.FillZ();

		entryNumber.Zero();

		entryName.FillZ();

		entryName.Zero();

		pbData.FillZ();

		pbData.Zero();

		entryNumber=numbers[i-1];

		entryName=names[i-1];

		// First specify starting index and set iNumofEntries to 1, since it is only

		// possible to write one entry at a time

		writeIndex = i; // Note that TSY will overwrite any existing data. It is up to

						// the Sync to check whether it is the first available entry

		// convert number into TLV format and append it to allocated buffer

		ret=pbBuffer->PutTagAndValue((TUint8)RMobilePhoneBookStore::ETagPBNumber, entryNumber);

		TESTL(ret == KErrNone) ;

		// convert type into TLV format and append it to allocated buffer

 		ret=pbBuffer->PutTagAndValue((TUint8)RMobilePhoneBookStore::ETagPBTonNpi, (TUint8)129/****RMobilePhone::EUnknownNumber***/);

 		TESTL(ret == KErrNone) ;

		// convert text into TLV format and append it to allocated buffer

		ret=pbBuffer->PutTagAndValue((TUint8)RMobilePhoneBookStore::ETagPBText, entryName);

		TESTL(ret == KErrNone) ;

		simPhBk.Write(aStatus,pbData,writeIndex);

		User::WaitForRequest(aStatus);

		TESTL(aStatus==KErrNone);

		}

		/* Read the entries back */

		TPtrC16 number(NULL,0);

		TPtrC16 text(NULL,0);

		TUint8 aTagValue(0);

		CPhoneBookBuffer::TPhBkTagType aDataType;

		TPtrC16 field(NULL,0);

		TInt counter(0);

		/* Reads Forwards and to read all entries individually */

		for(i=1; i<=size; ++i)

			{

			//first reset the following three local buffers to delete any existing data

			entryNumber.FillZ();

			entryNumber.Zero();

			entryName.FillZ();

			entryName.Zero();

			pbData.FillZ();

			pbData.Zero();

			// reset all loop variables

			counter = 0;

			aTagValue = 0;

			requestedIndex = i;

			simPhBk.Read(aStatus, requestedIndex, numOfEntries, pbReadData1);

			User::WaitForRequest(aStatus);

			TESTL(aStatus.Int()== KErrNone) ;

			entryNumber=numbers[i-1];

			entryName=names[i-1];

			// now decode PB data received in TLV format

			pbBuffer->Set(&pbReadData1); // Set pbBuffer to point to received phonebook data

			pbBuffer->StartRead();       // Start reading received phonebook data

			while(counter < pbReadData1.Length())

				{

				TInt ret = pbBuffer->GetTagAndType(aTagValue, aDataType);

				if(ret==KErrNotFound) // Reached the end of phonebook data

					break;

				TESTL(ret == KErrNone) ;

				switch(aDataType)

					{

				case CPhoneBookBuffer::EPhBkTypeInt8:

					{

					TUint8 int8(0);

					counter = counter + 1; // add tag-field only in case that is beginning of new field

					if(aTagValue == RMobilePhoneBookStore::ETagPBAdnIndex)

						{

						pbBuffer->GetValue(int8); //

						counter = counter + 1; // 1-byte integer

						}

					}

					break;