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

// GT Messaging Test Harness T_SmsSendRecv

// Test Harness: T_SmsSendRecv

// Component: SMS

// Owner: AA

// Brief Description: Sends and waits to receive SMS messages specified in sendrecv.script

// Detailed Description: As Above

// Input Files REQUIRED:

// <DRIVE>:\msgtest\sms\defaults.script

// <DRIVE>:\msgtest\sms\sendrecv.script

// Intermediate Files Produced: None

// Output files produced: <DRIVE>:\msglogs\T_SmsSendRecv.<PLATFORM>.<VARIANT>.log

// Building Instructions:

// cd \msg\smcm

// bldmake bldfiles

// abld test build

// Running Instructions:

// All Platforms:

// 1. Build T_DB test harness from COMMDB component:

// cd \commdb\group

// bldmake bldfiles

// abld test build t_db

// 2. Run T_DB and select the your modem (probably GSM Mobile Phone)

// 3. Build the test utilities:

// cd \msg\testutils\group\

// bldmake bldfiles

// abld test build

// 4. Edit \epoc32\wins\c\msgtest\sms\defaults.script. Replace the telephone number ("Recipients") with your mobile's number. You may also need to change the service centre ("SC") number (the default is for Vodafone UK).

// WINS Only:

// 1. Run T_DB.exe (if it has not already been run) and select your modem (GSM mobile phone).

// 2. \epoc32\release\wins\<VARIANT>\T_SmsSendRecv.exe can be used at the command prompt or executable can be run from Windows Explorer.

// Platform other than WINS:

// 1. Copy \epoc32\release\<PLATFORM>\<VARIANT>\T_SmsSendRecv.exe onto the other platform (or onto the CF card)

// 2. Copy \epoc32\release\<PLATFORM>\<VARIANT>\T_DB.exe onto the other platform (or onto the CF card)

// 3. Copy \epoc32\release\<PLATFORM>\<VARIANT>\MsvTestUtils.DLL into <DRIVE>:\system\libs on the other platform (or onto the CF card)

// 4. Copy \epoc32\release\<PLATFORM>\<VARIANT>\SmsTestUtils.DLL into <DRIVE>:\system\libs on the other platform (or onto the CF card)

// 5. Copy \epoc32\wins\c\msgtest\sms\sendrecv.script and defaults.script into <DRIVE>:\msgtest\sms on the other platform (or onto the CF card)

// 6. Run T_DB.exe on the other platform (if it has not already been run) and select your modem (GSM mobile phone).

// 7. Run T_SmsSendRecv.exe on the other platform.

// 

//

#include "T_SmsSendRecv.h"

#include <watcher.h>

#include <smuthdr.h>

#include <txtrich.h>

#include <bioscmds.h>

#include "biosmtm.h"

#include <smss.rsg>

#include <msgtestscripts.h>

#include <smsclnt.h>

#include <csmsaccount.h>

RTest test(_L("T_SmsSendRecv Testrig"));

CTrapCleanup* theCleanup;

const TInt KTestDescriptionLength	= 15;

LOCAL_C void doMainL()

	{

	CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;

	CleanupStack::PushL(scheduler);

	CActiveScheduler::Install( scheduler );

	CSmsTestUtils* smsTest = CSmsTestUtils::NewL(test);

	CleanupStack::PushL(smsTest);

	TInt nextTest = 0;

	smsTest->NotifySaPhoneOnL();

	CSmsSendRecvTest* recvTest = CSmsSendRecvTest::NewLC(*smsTest, KSendRecvScript, nextTest);

	smsTest->WaitForInitializeL();

	recvTest->StartL();

	CleanupStack::PopAndDestroy(3); //SmsTest, scheduler

	}

GLDEF_C TInt E32Main()

	{	

	__UHEAP_MARK;

	test.Start(_L("Setup"));

	theCleanup = CTrapCleanup::New();

	TRAPD(ret,doMainL());		

	test(ret==KErrNone);

	delete theCleanup;	

	test.Console()->SetPos(0, 13);

	test.End();

	test.Close();

	__UHEAP_MARKEND;

	return(KErrNone);

	}

CEntryObserver* CEntryObserver::NewL(CSmsTestUtils& aTestUtils, const TInt& aCurrentMessageNum)

	{

	CEntryObserver* self = new (ELeave) CEntryObserver(aTestUtils, aCurrentMessageNum);

	CleanupStack::PushL(self);

	self->iReceived = new (ELeave) CMsvEntrySelection();

	CleanupStack::Pop(self);

	return self;

	}

CEntryObserver::CEntryObserver(CSmsTestUtils& aTestUtils, const TInt& aCurrentMessageNum)

: CBase(), iCurrentMessageNum(aCurrentMessageNum), iSmsTest(aTestUtils)

	{

	}

CEntryObserver::~CEntryObserver() 

/**

	destructor

 */

	{

	delete iReceived;

	}

void CEntryObserver::CheckReceivedMessageL(TMsvId aId)

/**

	Checks received message

	@param		aId			A message Id

 */

	{

	// Restore SMS settings

	iSmsTest.SetEntryL(iSmsTest.iSmsServiceId);

	CSmsAccount* account = CSmsAccount::NewLC();

	account->LoadSettingsL(*iSmsTest.iServiceSettings);

	CleanupStack::PopAndDestroy(account);

	iSmsTest.Printf(_L("Check last received message...\n"));

	iSmsTest.DisplayMessageL(aId);

	iSmsTest.SetEntryL(aId);

	CSmsHeader* header = iSmsTest.GetHeaderLC(aId);

	if (header->Type() == CSmsPDU::ESmsDeliver)

		{

 		CSmsDeliver& pdu = header->Deliver();

		TBool found = EFalse;

		TInt destination, originator, is16Bit;

		destination = originator = is16Bit = 0;

		if (pdu.UserDataPresent())

			{

			const CSmsUserData& userData = pdu.UserData();

			TInt count = userData.NumInformationElements();

			iSmsTest.Printf(_L("\tPdu contains %d information elements\n"), count);

			while (!found && count--)

				{

				CSmsInformationElement& nextIE=userData.InformationElement(count);

				switch(nextIE.Identifier())

					{

					case CSmsInformationElement::ESmsIEIApplicationPortAddressing8Bit:

					case CSmsInformationElement::ESmsIEIApplicationPortAddressing16Bit:

						{

						pdu.ApplicationPortAddressing(destination, originator, &is16Bit);

						found = ETrue;

						break;

						}

					default:

						break;

					}

				}

			}

		else

			iSmsTest.Printf(_L("\tPdu contains NO user data header\n"));

		if (found)

			iSmsTest.Printf(_L("\tApplication Port Addressing: Dest %d, Origin %d, is16Bit %d\n"), destination, originator, is16Bit);

		else

			iSmsTest.Printf(_L("\tApplication Port Addressing: Not Found\n"));

		}

	//Check the description

	const TMsvEntry& entry = iSmsTest.Entry();

	if (entry.iBioType == 0)

		{

		//Test description

		TInt descriptionLength = iSmsTest.iServiceSettings->DescriptionLength();

		HBufC* buf = HBufC::NewLC(descriptionLength);

		TPtr desc = buf->Des();

		User::LeaveIfError(TSmsUtilities::GetDescription(header->Message(), desc, descriptionLength));

		iSmsTest.Printf(_L("\tiDescription=\"%S\" desc=\"%S\"\n"), &entry.iDescription, &desc);

		iSmsTest(desc.CompareF(entry.iDescription) == 0);

		if (header->Type() == CSmsPDU::ESmsStatusReport)

			{

			iSmsTest.ReadResourceStringL(KSmsResourceFile,  R_TYPE_STATUS_REPORT, desc);

			iSmsTest.Printf(_L("\tiDescription=\"%S\" Res=\"%S\"\n"), &entry.iDescription, &desc);

			iSmsTest(desc.CompareF(entry.iDescription) == 0);

			}

		CleanupStack::PopAndDestroy(buf);

		}

	CleanupStack::PopAndDestroy(header);

	}

void CEntryObserver::HandleEntryEventL(TMsvEntryEvent aEvent, TAny* aArg1, TAny* /*aArg2*/, TAny* /*aArg3*/)

/**

	Handles entry event, used by MMsvEntryObserver

	@param		aEvent		Msv entry event

	@param		aArg1		Argument 1

	@param		aArg2		Argument 2 

	@param		aArg3		Argument 3 

 */

	{

	if (aEvent == EMsvNewChildren && iCurrentMessageNum > -1)

		{

		CMsvEntrySelection* msgs = (CMsvEntrySelection*)aArg1;

		TInt count = msgs->Count();

		TInt msgRecv = 0;

		while (count--)

			{

			TMsvId id = (*msgs)[count];

			CheckReceivedMessageL(id);

			CSmsHeader* header = iSmsTest.GetHeaderLC(id);

			if (header->Type() == CSmsPDU::ESmsDeliver)

				{

				iReceived->AppendL(id);

				msgRecv++;

				}

			CleanupStack::PopAndDestroy(header);

			}

		if (msgRecv)	

			iSmsTest.Printf(_L("%d Messages Received in inbox\n"), msgRecv);

		}

	}

CSmsSendRecvTest::~CSmsSendRecvTest()

/**

	destructor

 */

	{

	delete iEntryObserver;

	delete iEntryForObserver;

	delete iWatchers;

	iSocket.Close();

	iSocketServ.Close();

	}

TBool CSmsSendRecvTest::WatchersAlreadyRunningL()

/**

	Checks if the watchers are already running

 */

	{

	RSocketServ server;

	RSocket socket;

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

	CleanupClosePushL(server);

		// test if it's there... 

	TProtocolDesc protoInfo;

	TProtocolName protocolname;

	protocolname.Copy(KSmsDatagram);

	User::LeaveIfError(server.FindProtocol(protocolname,protoInfo));

	User::LeaveIfError(socket.Open(server,

										protoInfo.iAddrFamily,

										protoInfo.iSockType, 

										protoInfo.iProtocol));

	CleanupClosePushL(socket);

	TSmsAddr addr;

	addr.SetSmsAddrFamily(ESmsAddrRecvAny);

	TInt err = socket.Bind(addr);

	CleanupStack::Pop(2); //server, socket

	socket.CancelAll();

	socket.Close();

//	server.Close();

	return (err == KErrAlreadyExists);

	}

void CSmsSendRecvTest::StartWatcherL()

/**

	Starts the watcher if it is not running

 */

	{

	iSmsTest.Test().Next(_L("Start the Watcher"));

	if (WatchersAlreadyRunningL())

		{

		iSmsTest.Printf(_L("Watchers are already running\n"));

		return;

		}

	iWatchers = CTestUtilsWatcherStarter::NewL();

	TTimeIntervalMicroSeconds32 wait = KWaitForWatchersToStart;

	while (wait.Int() > 0)

		{

		iSmsTest.Printf(_L("Waiting %d secs for watchers to start...\n"), wait.Int() / 1000000);

		wait = wait.Int() - KWaitForWatchersToStartDisplayInterval.Int();

		User::After(KWaitForWatchersToStartDisplayInterval);

		}

	}

CSmsSendRecvTest* CSmsSendRecvTest::NewLC(CSmsTestUtils& aSmsTest, const TDesC& aScriptFile, TInt& aNextTest)

	{

	CSmsSendRecvTest* self = new (ELeave) CSmsSendRecvTest(aSmsTest, aScriptFile, aNextTest);

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

void CSmsSendRecvTest::TestSendingL()

/**

	Tests sending: Creates messages as defined in the script file

 */

	{

	iSmsTest.Test().Next(_L("Sending"));

	TTime now;

	now.HomeTime();

	now += (TTimeIntervalSeconds) 5;

	iSelection->Reset();

	iSmsTest.DeleteSmsMessagesL(KMsvGlobalOutBoxIndexEntryId);

	TBool read = EFalse;

	iSmsTest.Printf(_L("Creating msgs in outbox from script: %S\n"), &iScriptFile);

	TRAPD(err, read = iSmsTest.ReadScriptL(iScriptFile, KMsvGlobalOutBoxIndexEntryId, *iSelection, now));

	iSmsTest.Test()(!err && read);

	iSmsTest.Printf(_L("Send and Receive %d messages...\n"), iSelection->Count());

	TInt count = iSelection->Count();

	iTotal = 0;

	iSent = 0;

	while (count--)

		{

		iTotal += CountRecipientsL(iSelection->At(count));

		}

	iCurrentMessageNum = -1;

	}

TInt CSmsSendRecvTest::CountRecipientsL(TMsvId aId)

/**

	Counts the number receipients in aId

	@param		aId		A message Id 

 */

	{

	CSmsHeader* header = iSmsTest.GetHeaderLC(aId);

	const TInt count = header->Recipients().Count();

	CleanupStack::PopAndDestroy(header);

	return count;

	}

TBool CSmsSendRecvTest::SendNextMessageL()

/**

	Sends the next message 

 */

	{

	iCurrentMessageNum++;

	const TInt count = iSelection->Count();

	if (iCurrentMessageNum < count)

		{

		iSmsTest.Printf(_L("Sending message %d of %d\n"), iCurrentMessageNum + 1, count);

		delete iOperation;

		iOperation = NULL;

		CMsvEntrySelection* sel = new (ELeave) CMsvEntrySelection();

		CleanupStack::PushL(sel);

		const TMsvId id = iSelection->At(iCurrentMessageNum);

		TInt replace_msg_one_index = GetIndexOfSectionL(_L("ReplaceTypeSMSOne"));

		TInt replace_msg_two_index = GetIndexOfSectionL(_L("ReplaceTypeSMSTwo"));

		TInt msg_indication_index = GetIndexOfSectionL(_L("SMSMessageIndication"));

		TInt vCalendar_index = GetIndexOfSectionL(_L("WAP:vCalendar"));

 		// storing the id of vCalender message , to use it to test for replying bio messages

 		if(vCalendar_index != KErrNotFound && vCalendar_index == (iCurrentMessageNum+1))

 			iMsgVCalenderIndex = iCurrentMessageNum;

		if(replace_msg_one_index != KErrNotFound && replace_msg_one_index == (iCurrentMessageNum+1))

			SendReplaceTypeMessageL();

		if(replace_msg_two_index != KErrNotFound && replace_msg_two_index == (iCurrentMessageNum+1))

			{

			SendReplaceTypeMessageL();

			iSmsTest.Printf(_L("This Message replaces previous Replace Type Message"));

			}

		if(msg_indication_index != KErrNotFound && msg_indication_index == (iCurrentMessageNum+1))

			SendMessageIndicationL();

		iSmsTest.DisplayMessageL(id);

		sel->AppendL(id);

		iSent += CountRecipientsL(id);

		iSmsTest.SetEntryL(KMsvGlobalOutBoxIndexEntryId);

		iOperation = MsvEntry().CopyL(*sel, iSmsTest.iSmsServiceId, iStatus);

		CleanupStack::PopAndDestroy(); //sel

		iState = EStateSending;

		SetActive();

		CActiveScheduler::Start();

		return ETrue;

		}

	return EFalse;

	}

TInt CSmsSendRecvTest::GetIndexOfSectionL(const TDesC& aSectionName)

/**

 *  Returns back the index of the section

 */

	{

	CScriptFile* script = CScriptFile::NewLC(iSmsTest, KSmsComponent);

	script->ReadScriptL(KSendRecvScript);

	TInt index = KErrNotFound;

	TInt count = iSelection->Count();

	for (TInt i = 0; i <= count; i++) //order important

		{

		CScriptSection& tempsection = *script->Sections()[i];

		if (tempsection.SectionName().CompareF(aSectionName) == 0)

			index = i;

		}

	CleanupStack::PopAndDestroy(script);

	return index;

	}

void CSmsSendRecvTest::SendReplaceTypeMessageL()

/**

 *  Handles the replace type sms messages in sendrecv.script

 */

	{	

	iSmsTest.Printf(_L("\nSend Replace Type Message\n"));

	const TMsvId id = iSelection->At(iCurrentMessageNum);

	CSmsHeader* header = iSmsTest.GetHeaderLC(id);

	CSmsSubmit& submit = header->Submit();

	submit.SetPIDType(TSmsProtocolIdentifier::ESmsPIDShortMessageType);

	submit.SetShortMessageType(TSmsProtocolIdentifier::ESmsReplaceShortMessageType1);

	StoreMessageL(id, *header);

	CleanupStack::PopAndDestroy(header);

	}

void CSmsSendRecvTest::SendMessageIndicationL(TUint8 aMessageType, TUint8 aMessageCount)

/**

 * Sends an SMS message with Special SMS Message Indication set in the user data header.

 * 

 * @param aMessageType The type of the Special SMS Message Indication

 * @param aMessageCount The number of "messages" waiting

 */

	{

	iSmsTest.Printf(_L("\nSendMessageIndicationL\n"));

	const TMsvId id = iSelection->At(iCurrentMessageNum);

	CSmsHeader* header = iSmsTest.GetHeaderLC(id);

	TBuf8<2> data;

	data.SetLength(2);

	data[0] = aMessageType;

	data[1] = aMessageCount;

	header->Submit().UserData().AddInformationElementL(CSmsInformationElement::ESmsIEISpecialSMSMessageIndication, data);

	StoreMessageL(id, *header);

	CleanupStack::PopAndDestroy(header);

	}

void CSmsSendRecvTest::StoreMessageL(TMsvId aId, const CSmsHeader& aHeader)

/**

 * Stores the header against a message

 *

 * @param aId ID of the message

 * @param aHeader The CSmsHeader to store against the message

 */

	{

	iSmsTest.SetEntryL(aId);

	CMsvStore* store = iSmsTest.EditStoreL();

	CleanupStack::PushL(store);

	aHeader.StoreL(*store);

	store->StoreBodyTextL(*iSmsTest.iRichText);

	store->CommitL();

	CleanupStack::PopAndDestroy(store);

	}

void CSmsSendRecvTest::TestWaitForReceiveL()

/**

	Waits to receive message

 */

	{

	iSmsTest.Test().Next(_L("Waiting to receive message"));

	iState = EStateWaitingToReceive;

	TRequestStatus* status = &iStatus;

	User::RequestComplete(status, KErrNone);

	SetActive();

	}