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

// This file contains utility functions used by the SMS test steps.  The actual SMS test steps are 

// declared in Te_SMSTestSteps.h and are defined in their own file with appropriate name.

// These utilities proved quite extensive functionality.  If a SMS test step you need is not 

// available, before creating a new one, check through these functions;  You might find something

// you can simply plug into your new test step.

// 

//

/**

 @file

*/

#include "Te_SmsTestSteps.h"

#include "TE_smsprtbase.h"

#include <sacls.h>

#include <smspver.h>

#if defined (__WINS__)

#define PDD_NAME _L("ECDRV")

#define PDD_NAME2 _L("ECDRV")

#define LDD_NAME _L("ECOMM")

#else

#define PDD_NAME _L("EUART1")

#define LDD_NAME _L("ECOMM")

#endif

// Here are the section names

_LIT8(KSetupTelNumbers,           "Defaults");

// Here are the item names

_LIT8(KServiceCenter,               "ServiceCenter");

_LIT8(KTelefoneNumber,              "TelephoneNumber");

// Location of directory for reserving disk space

_LIT(KTempDiskSpaceDirName, "C:\\sms\\temp\\");

// Location and name of the RSC file.

_LIT(KSMSUResourceDir, "C:\\private\\101f7989\\sms\\");

_LIT(KSMSUResourceFile, "C:\\private\\101f7989\\sms\\smsu.rsc");

CSMSTestSteps::~CSMSTestSteps()

{

	iFs.Close();			

}

/**

	Creates the file server session and marks the heap

*/

TVerdict CSMSTestSteps::doTestStepPreambleL()

	{

	RDebug::Print(_L("%S"), &TestStepName());

	User::LeaveIfError(iFs.Connect());	

	__UHEAP_MARK;

	return TestStepResult();

	}

/**

	Closes file server session and unmarks the heap	

*/

TVerdict CSMSTestSteps::doTestStepPostambleL()

	{

	__UHEAP_MARKEND;

	iFs.Close();	

	return TestStepResult();

	}

void CSMSTestSteps::ParseSettingsFromFileL()

	{

	CTestConfig* configFile = CTestConfig::NewLC(iFs,KGmsSmsConfigFileDir,KGmsSmsConfigFileName);

	const CTestConfigSection* cfgFile = configFile->Section(KSetupTelNumbers);

	if (cfgFile == NULL)

		{

		User::Leave(KErrNotFound);

		}

	const CTestConfigItem* item = cfgFile->Item(KServiceCenter,0);

	if (item == NULL)

		{

		User::Leave(KErrNotFound);

		}

	iServiceCenterNumber.Copy(item->Value());

	item = cfgFile->Item(KTelefoneNumber,0);

	if (item == NULL)

		{

		User::Leave(KErrNotFound);

		}

	iTelephoneNumber.Copy(item->Value());

	// beginning of the destruction

	CleanupStack::PopAndDestroy(configFile);//configFile

	}

void CSMSTestSteps::SetSimTSYTestNumberL(TInt aTestNumber)

/**

	Set the SIM TSY Test number 

	@param aTestNumber is the test number in SIM TSY config file

*/

	{	

	INFO_PRINTF2(_L("Setting SIMTSY test number to %d"), aTestNumber);

	//

	// Set the property...

	//

	User::LeaveIfError(RProperty::Set(KUidPSSimTsyCategory,KPSSimTsyTestNumber,aTestNumber));

	//

	// Check the property is set...

	//

	TInt  testNumberCheck;

	User::LeaveIfError(RProperty::Get(KUidPSSimTsyCategory,KPSSimTsyTestNumber,testNumberCheck));

	if (aTestNumber != testNumberCheck)

		{

	    INFO_PRINTF3(_L("Test number property set to %d, but value returned is %d"),aTestNumber,testNumberCheck);

		User::Leave(KErrNotFound);

		}

	}

//-----------------------------------------------------------------------------

void CSMSTestSteps::WaitForInitializeL()

/**

 *  Initialize the phone for the tsy. IF this is not called, message sends will complete with KErrNotReady

 */

	{

#ifdef SYMBIAN_NON_SEAMLESS_NETWORK_BEARER_MOBILITY

	CMDBSession* db = CMDBSession::NewL(KCDVersion1_2);

#else

	CMDBSession* db = CMDBSession::NewL(KCDVersion1_1);

#endif

	CleanupStack::PushL(db);

	TName tsy;

	TUint32 modemId = 0;

	CMDBField<TUint32>* globalSettingsField = new(ELeave) CMDBField<TUint32>(KCDTIdModemPhoneServicesSMS);

	CleanupStack::PushL(globalSettingsField);

	globalSettingsField->SetRecordId(1);

	globalSettingsField->LoadL(*db);

	modemId = *globalSettingsField;

	CleanupStack::PopAndDestroy(globalSettingsField);

	CMDBField<TDesC>* tsyField = new(ELeave) CMDBField<TDesC>(KCDTIdTsyName);

	CleanupStack::PushL(tsyField);

	tsyField->SetRecordId(modemId);

	tsyField->SetMaxLengthL(KMaxTextLength);

	tsyField->LoadL(*db);

	tsy = *tsyField;

	CleanupStack::PopAndDestroy(tsyField);

	CleanupStack::PopAndDestroy(db);

	INFO_PRINTF2(_L("Using TSY \"%S\"Loading RTelServer..."), &tsy);

	RTelServer server;

	User::LeaveIfError(server.Connect());

	CleanupClosePushL(server);

	User::LeaveIfError(server.LoadPhoneModule(tsy));

	// Find the phone corresponding to this TSY and open a number of handles on it

	TInt numPhones;

	User::LeaveIfError(server.EnumeratePhones(numPhones));

	RPhone phone;

	TBool found=EFalse;

	while (numPhones--)

		{

		TName phoneTsy;

		User::LeaveIfError(server.GetTsyName(numPhones,phoneTsy));

		if (phoneTsy.CompareF(tsy)==KErrNone)

			{

			INFO_PRINTF1(_L("Found RPhone..."));

			found = ETrue;

			RTelServer::TPhoneInfo info;

			User::LeaveIfError(server.GetPhoneInfo(numPhones,info));

			User::LeaveIfError(phone.Open(server,info.iName));

			CleanupClosePushL(phone);

			INFO_PRINTF1(_L("Initializing..."));

			const TInt err = phone.Initialise();

			TTimeIntervalMicroSeconds32 InitPause=9000000;  //Required Pause to Allow SMSStack to Complete its Async Init

			User::After(InitPause);							//call to the TSY and finish its StartUp.

			INFO_PRINTF2(_L("Completed Initialize [err=%d]"), err);

			User::LeaveIfError(err);

			CleanupStack::PopAndDestroy(&phone);

			break;

			}

		}

	TEST(found);

	CleanupStack::PopAndDestroy(&server);

	}

void CSMSTestSteps::PrepareRegTestLC(RSocketServ& aSocketServer, TInt aTestNumber)

/**

 *  Run a specified test.

 *  The test number is passed via property KUidPSSimTsyCategory. This will notify the SIM tsy

 *  SIM tsy uses test number to parse correct script from config.txt

 *  @param aTestNumber The test number corresponding the test case

 */

	{

	//

	// Set the SIM.TSY test number...

	//

	RProperty testNumberProperty;

	User::LeaveIfError(testNumberProperty.Attach(KUidPSSimTsyCategory, KPSSimTsyTestNumber));

	CleanupClosePushL(testNumberProperty);

	TRequestStatus status;

	testNumberProperty.Subscribe(status);

	INFO_PRINTF2(_L("Setting Sim.Tsy test number to %d"), aTestNumber);

	User::LeaveIfError(testNumberProperty.Set(KUidPSSimTsyCategory,KPSSimTsyTestNumber,aTestNumber));

	User::WaitForRequest(status);

	TEST(status.Int() == KErrNone);

	TInt testNumberCheck;

	User::LeaveIfError(testNumberProperty.Get(testNumberCheck));

	if (aTestNumber != testNumberCheck)

		{

	    INFO_PRINTF3(_L("Test number property set to [%d], but value returned is [%d]"),aTestNumber,testNumberCheck);

		User::Leave(KErrNotFound);

		}

	CleanupStack::PopAndDestroy(&testNumberProperty);

	//

	// Connect to the Socket Server...

	//

	TInt  ret = aSocketServer.Connect(KSocketMessageSlots);

    TESTL(ret == KErrNone);

	CleanupClosePushL(aSocketServer);

	//

	// Delete segmentation and reassembly store files before the test...

	//

	_LIT(KReassemblyStoreName,"C:\\Private\\101F7989\\sms\\smsreast.dat");

	_LIT(KSegmentationStoreName,"C:\\Private\\101F7989\\sms\\smssegst.dat");

	_LIT(KWapReassemblyStoreName,"C:\\Private\\101F7989\\sms\\wapreast.dat");

	iFs.Delete(KWapReassemblyStoreName);

	iFs.Delete(KReassemblyStoreName);

	iFs.Delete(KSegmentationStoreName);

	}

CSmsMessage* CSMSTestSteps::CreateSmsMessageL(const TDesC& aDes, TSmsDataCodingScheme::TSmsAlphabet aAlphabet, CSmsPDU::TSmsPDUType aType)

/**

 *  Create a uninitialised SMS message

 *  @param aDes contains text that will be inserted to the pdu

 *  @param aAlphabet describes the alphabet of the pdu

 *  @return CSmsMessage* :Pointer to the created CSmsMessage object.

 */

	{

	CSmsBuffer* buffer=CSmsBuffer::NewL();

	CSmsMessage* smsMessage=CSmsMessage::NewL(iFs, aType, buffer);

	CleanupStack::PushL(smsMessage);

	TSmsUserDataSettings smsSettings;

	smsSettings.SetAlphabet(aAlphabet);

	smsSettings.SetTextCompressed(EFalse);

	smsMessage->SetUserDataSettingsL(smsSettings);

	smsMessage->SetToFromAddressL(iTelephoneNumber);

	smsMessage->SmsPDU().SetServiceCenterAddressL(iServiceCenterNumber);

	buffer->InsertL(0,aDes);

	CleanupStack::Pop(smsMessage);

	return smsMessage;

	}

CSmsMessage* CSMSTestSteps::CreateSmsWithStatusReportReqL(const TDesC& aDes, TSmsDataCodingScheme::TSmsAlphabet aAlphabet)

/**

 *  Create a uninitialised SMS message with Status Report request

 *  @param aDes contains text that will be inserted to the pdu

 *  @param aAlphabet describes the alphabet of the pdu

 *  @return CSmsMessage* :Pointer to the created CSmsMessage object.

 */

	{

	CSmsMessage* smsMessage=CreateSmsMessageL(aDes, aAlphabet);

	CleanupStack::PushL(smsMessage);

	//Set Status report request

	CSmsSubmit& submitPdu=(CSmsSubmit&)smsMessage->SmsPDU();

	submitPdu.SetStatusReportRequest(ETrue);

	CleanupStack::Pop(smsMessage);

	return smsMessage;

	}

CSmsMessage* CSMSTestSteps::RecvSmsL(RSocket& aSocket, TInt aIoctl)

/**

 *  Receive an Sms

 *  @param aSocket is used to stream the sms message from the socket server

 *  @return CSmsMessage* :Sms message from Sms stack

 *  @leave Leaves if streaming the message from the socket server doesn't succeed

 */

	{

	CSmsBuffer* buffer=CSmsBuffer::NewL();

	CSmsMessage* smsMessage=CSmsMessage::NewL(iFs, CSmsPDU::ESmsSubmit,buffer);

	CleanupStack::PushL(smsMessage);

	RSmsSocketReadStream readstream(aSocket);

	TRAPD(ret,readstream >> *smsMessage);

	INFO_PRINTF2(_L("Return from streaming message over socket %d"),ret );

	TPckgBuf<TUint> sbuf;

	TRequestStatus status;

	if(ret==KErrNone)

		{

		aSocket.Ioctl(aIoctl, status, &sbuf, KSolSmsProv);

		User::WaitForRequest(status);

		CleanupStack::Pop(smsMessage);	

		}

	//An error has occured, No message has been received, so return a NULL

	else

		{

		aSocket.Ioctl(KIoctlReadMessageFailed, status, &sbuf, KSolSmsProv);

		User::WaitForRequest(status);

		TEST(status.Int() == KErrNone);

		User::Leave(ret);

		}	

	return smsMessage;	

	}

CSmsMessage* CSMSTestSteps::RecvSmsFailedL(RSocket& aSocket)

/**

 *  Receive an Sms, first nack the receive several times before succeeding

 *  @param aSocket is used to stream the sms message from the socket server

 *  @return CSmsMessage* :Sms message from Sms stack

 *  @leave Leaves if streaming the message from the socket server doesn't succeed

 *  @leave Leaves if nack of receiving is completed with error code

 *  @leave Leaves if ack of receiving is completed with error code

 */

	{

	CSmsBuffer* buffer=CSmsBuffer::NewL();

	CSmsMessage* smsMessage=CSmsMessage::NewL(iFs, CSmsPDU::ESmsSubmit,buffer);

	CleanupStack::PushL(smsMessage);

	RSmsSocketReadStream readstream(aSocket);

	TPckgBuf<TUint> sbuf;

	TRequestStatus status;

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

		{

		TRAPD(ret,readstream >> *smsMessage);

		TEST(ret == KErrNone);

		aSocket.Ioctl(KIoctlReadMessageFailed, status, &sbuf, KSolSmsProv);

		User::WaitForRequest(status);

		TEST(status.Int() == KErrNone);

		}

	TRAPD(ret,readstream >> *smsMessage);

	TEST(ret == KErrNone);

	aSocket.Ioctl(KIoctlReadMessageSucceeded, status, NULL, KSolSmsProv);

	User::WaitForRequest(status);

	TEST(status.Int() == KErrNone);

	CleanupStack::Pop(smsMessage);

	return smsMessage;

	}

void CSMSTestSteps::SendSmsL(const CSmsMessage* aSms, RSocket& aSocket)

/**

 *  Stream aSms out to the socket server

 *  @param aSms contains the sms tpdu that will be streamed to the sms stack

 *  @param aSocket is used to stream the aSms to the sms stack

 *  @leave Leaves if streaming the message to the socket server doesn't succeed

 *  @leave Leaves if sending is completed with error code

 */

	{

	TBool tryAgain = ETrue;

	TInt sendTry (0);

	TRequestStatus status = KErrNone;

	while (tryAgain && sendTry < 3)

		{

		RSmsSocketWriteStream writestream(aSocket);

		TRAPD(ret,writestream << *aSms);

		TRAP(ret,writestream.CommitL());

		TPckgBuf<TUint> sbuf;

		aSocket.Ioctl(KIoctlSendSmsMessage,status,&sbuf, KSolSmsProv);

		User::WaitForRequest(status);

		INFO_PRINTF2(_L("SendSmsL - sendSmsMessage returned %d"), status.Int());

		if (status.Int() != KErrNone)

			{

			tryAgain = ETrue;

			INFO_PRINTF1(_L("Try again... "));

			sendTry++;

			}

		else tryAgain = EFalse;

		}

	TEST(status.Int() == KErrNone);

	PrintMessageL(aSms);

	if (status.Int() != KErrNone)

		{

		User::Leave(status.Int());

		}

	}

void CSMSTestSteps::SendSmsCancelL(CSmsMessage* aSms, RSocket& aSocket1, RSocket& aSocket2)

/**

 *  Stream Sms out to the socket server by two RSmsSocketWriteStream object.

 *  The first request is canceled and then the second request is completed with error code.

 *  @param aSms contains the sms tpdu that will be streamed to the sms stack

 *  @param aSocket1 The socket used with message that will be canceled

 *  @param aSocket2 The socket used with message that will be completed with error code

 *  @leave Leaves if streaming the message to the socket server doesn't succeed

 *  @leave Leaves if sending is completed with KErrNone

 */

	{

	RSmsSocketWriteStream writestream(aSocket1);

	TRAPD(ret,writestream << *aSms);

	TEST(ret == KErrNone);

	TRAP(ret,writestream.CommitL());

	TEST(ret == KErrNone);

	TPckgBuf<TUint> sbuf;

	TRequestStatus status1,status2;

	//stream to socket2

	RSmsSocketWriteStream writestream2(aSocket2);

	TRAP(ret,writestream2 << *aSms);

	TEST(ret == KErrNone);

	TRAP(ret,writestream2.CommitL());

	TEST(ret == KErrNone);

	aSocket1.Ioctl(KIoctlSendSmsMessage,status1,&sbuf, KSolSmsProv);

	aSocket2.Ioctl(KIoctlSendSmsMessage,status2,&sbuf, KSolSmsProv);

	User::After(2000000);

	// Test cancel first

	aSocket1.CancelIoctl();

	User::WaitForRequest(status1);

	TEST(status1.Int()==KErrCancel);

	User::After(50000);

	User::WaitForRequest(status2);

	INFO_PRINTF2(_L("SendSmsL - sendSmsMessage returned %d"),status2.Int());

	PrintMessageL(aSms);

	//Ensure the request is completed with error code ;)

	TEST(status2.Int() != KErrNone);

	INFO_PRINTF2(_L("Sending failed! %d"), status2.Int());

	}

TInt CSMSTestSteps::SendSmsErrorL(CSmsMessage* aSms, RSocket& aSocket)

/**

 *  Stream aSms out to the socket server. Sending is completed with error code.

 *  @param aSms contains the sms tpdu that will be streamed to the sms stack

 *  @param aSocket is used to stream the aSms to the sms stack

 *  @return error code

 *  @leave Leaves if streaming the message to the socket server doesn't succeed

 *  @leave Leaves if sending is completed with KErrNone

 */

	{

	RSmsSocketWriteStream writestream(aSocket);

	TRAPD(ret,writestream << *aSms);

	TEST(ret == KErrNone);

	TRAP(ret,writestream.CommitL());

	TEST(ret == KErrNone);

	TPckgBuf<TUint> sbuf;

	TRequestStatus status;

  	User::After(50000);

	// test cancel first

	aSocket.Ioctl(KIoctlSendSmsMessage,status,&sbuf, KSolSmsProv);

	aSocket.CancelIoctl();

	User::WaitForRequest(status);

	TEST(status.Int()==KErrCancel);

	//Now send again, completed with error

	TRAP(ret,writestream << *aSms);

	TEST(ret == KErrNone);

	TRAP(ret,writestream.CommitL());

	TEST(ret == KErrNone);

	aSocket.Ioctl(KIoctlSendSmsMessage,status,&sbuf, KSolSmsProv);

	User::WaitForRequest(status);

	INFO_PRINTF2(_L("SendSmsL - sendSmsMessage returned %d"), status.Int());

	PrintMessageL(aSms);

	INFO_PRINTF2(_L("Sending failed! %d"), status.Int());

	TEST(status.Int() != KErrNone);

	return status.Int();

	}

void CSMSTestSteps::SendCommandSmsL(CSmsMessage* aSms, RSocket& aSocket)

/**

 *  Stream command message out to the socket server and wait for the return status

 *  @param aSms contains the sms tpdu that will be streamed to the sms stack

 *  @param aSocket is used to stream the aSms to the sms stack

 *  @leave Leaves if streaming the message to the socket server doesn't succeed