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

//

#include <gsmubuf.h>

#include <gsmuset.h>

#include <smsustrm.h>

#include "TE_smsinterbase.h"

const TInt KActiveReceiverSocketGranularity = 8;

const TInt KActiveSocketPriority = CActive::EPriorityIdle;

class CStopIfKeyPressed;

class MStopTest

	{

public:

	virtual void StopTests() = 0;

	};

//

//

// CActiveSocket

//

//

class CActiveSocket : public CActive

	{

public:

	enum { EPriority = KActiveSocketPriority };

public:

	static CActiveSocket* NewL(const TTestCase& aTest, RSocketServ& aSocketServer, RFs& aFs);

	~CActiveSocket();

	void ReceiveMessage(TRequestStatus* aStatus);

	void SetIndex(TInt aIndex);

	void TestResultL();

	TBool TestComplete();

	TPtrC Message();

private:

	virtual void DoCancel();

	virtual void RunL();

	CActiveSocket(RSocketServ& aSocketServer);

private:

	void InitRSocketL();

private:

	TRequestStatus* iActiveReceiverStatus;

	RSocket iSocket;

	TTestCase iTestCase;

	CSmsMessage* iSmsMessage;

	TInt iActiveReceiverIndex;

	TPckgBuf<TUint> iSelectBuf;

	RSocketServ& iSocketServer;

	};

//

//

// CActiveSenderImp

//

//

class CActiveSenderImp : public CActiveSender, MStopTest

	{

public:

	static CActiveSenderImp* NewL(RSocketServ& aSocketServer,

			                      RFs& aFs,

			                      const TDesC& aTelephoneNumber,

                                  const TDesC& aServiceCenterNumber);

	virtual void StartSendingL();

	virtual void StopIfKeyPressedL();

	~CActiveSenderImp();

public:

	void StopTests();

private:

	void InitRSocketL();

	void SendSmsMessageL();

private:

	virtual void DoCancel();

	virtual void RunL();

private:

	CActiveSenderImp(RSocketServ& aSocketServer, RFs& aFs);

	CStopIfKeyPressed* iStopTest;

	RSocket iSocket;

	CSmsMessage* iSmsMessage;

	TPckgBuf<TUint> iIntBuf;

	TInt iCount;

	};

//

//

// CActiveReceiverImp

//

//

class CActiveReceiverImp : public CActiveReceiver, MStopTest

	{

public:

	static CActiveReceiverImp* NewL(RSocketServ& aSocketServer, RFs& aFs);

	virtual void AddTestL(const TTestCase& aTest);

	virtual void StartTestsL();

	virtual void StopIfKeyPressedL();

	~CActiveReceiverImp();

public:

	void StopTests();

private:

	virtual void DoCancel();

	virtual void RunL();

private:

	CActiveReceiverImp(RSocketServ& aSocketServer, RFs& aFs);

	CArrayPtr<CActiveSocket>* iSockArray;

	TInt iResultCount;

	CStopIfKeyPressed* iStopTest;

	};

//

//

// CStopIfKeyPressed

//

//

class CStopIfKeyPressed : public CActive

	{

public:

	enum { EPriority = KStopIfKeyPressedPriority };

public:

	static CStopIfKeyPressed* NewL(MStopTest* aReceiver);

	virtual void RunL();

	virtual void DoCancel();

public:

	void StopIfKeyPressed();

private:

	CStopIfKeyPressed();

	MStopTest* iReceiver;

	};

CStopIfKeyPressed* CStopIfKeyPressed::NewL(MStopTest* aReceiver)

//

// Factory

//

	{

	CStopIfKeyPressed* stopTest = new(ELeave) CStopIfKeyPressed;

	stopTest->iReceiver = aReceiver;

	CActiveScheduler::Add(stopTest);

	return stopTest;

	}

void CStopIfKeyPressed::StopIfKeyPressed()

//

// Activate

//

	{

	if (IsActive())

		return;

//	CConsoleBase* console = gTest.Console();

//	console->Read(iStatus);

//	SetActive();

	}

CStopIfKeyPressed::CStopIfKeyPressed()

//

// Constructor

//

: CActive(EPriority)

	{}

void CStopIfKeyPressed::RunL()

//

// Called if a key has been pressed

//

	{

	iReceiver->StopTests();

	CActiveScheduler::Stop();

	}

void CStopIfKeyPressed::DoCancel()

//

// Cancel has been called

//

	{

//	CConsoleBase* console = gTest.Console();

//	console->ReadCancel();

	}

//

//

// CActiveSocket

//

//

CActiveSocket* CActiveSocket::NewL(const TTestCase& aTest, RSocketServ& aSocketServer, RFs& aFs)

//

// Factory

//

	{

	CActiveSocket* socket = new(ELeave) CActiveSocket(aSocketServer);

	CleanupStack::PushL(socket);

	socket->iTestCase=aTest;

	socket->InitRSocketL();

	CSmsBuffer* buffer=NULL;

	buffer=CSmsBuffer::NewL();

	socket->iSmsMessage=CSmsMessage::NewL(aFs, CSmsPDU::ESmsSubmit,buffer);

	CleanupStack::Pop();

	CActiveScheduler::Add(socket);

	return socket;

	}

CActiveSocket::CActiveSocket(RSocketServ& aSocketServer)

//

// Constructor

//

:	CActive(EPriority),

	iSocketServer(aSocketServer)

	{}

CActiveSocket::~CActiveSocket()

//

// Destructor

//

	{

	delete iSmsMessage;

	iSocket.Close();

	}

void CActiveSocket::TestResultL()

//

// Test the sms message contains the expected data

//

	{

	CSmsBufferBase& smsBuffer=iSmsMessage->Buffer();

	TInt bufLen=smsBuffer.Length();

	HBufC* textBuf=HBufC::NewL(bufLen);

	TPtr textPtr(textBuf->Des());

	smsBuffer.Extract(textPtr,0,bufLen);

//	if (iTestCase.iTestForever)

//		gTest.Printf(_L("RECEIVED: Msg %S\n"),&textPtr);

//	else if (iTestCase.iMatchType==ESmsAddrStatusReport)

//		gTest.Printf(_L("SUCCESS: Status report received for %S\n"),&iTestCase.iMsg);

//	else

//		{

//		TBool ret = (textPtr==iTestCase.iMsg);

//		if (ret>0)

//			gTest.Printf(_L("SUCCESS: Msg %S received\n"),&iTestCase.iMsg);

//		else

//			gTest.Printf(_L("SUCCESS: Msg %S not received\n"),&iTestCase.iMsg);

//		}

	delete textBuf;

	}

void CActiveSocket::SetIndex(TInt aIndex)

//

// Set the index ofthe socket within the receiver's iSockArray

//

	{

	iActiveReceiverIndex = aIndex;

	}

TPtrC CActiveSocket::Message()

//

// Return the testcase message

//

	{

	return iTestCase.iMsg;

	}

void CActiveSocket::InitRSocketL()

//

// Initialise the active socket's connection with the socket server

//

	{

	TInt ret=iSocket.Open(iSocketServer,KSMSAddrFamily,KSockDatagram,KSMSDatagramProtocol);

	User::LeaveIfError(ret);

	TSmsAddr smsAddr;

	smsAddr.SetSmsAddrFamily(iTestCase.iMatchType);

	switch(iTestCase.iMatchType)

		{

	case ESmsAddrMatchText:

		{

		TBuf8<128> match;

		match.Copy(iTestCase.iMatch);

		smsAddr.SetTextMatch(match);

		break;

		}

	case ESmsAddrMatchIEI:

		smsAddr.SetIdentifierMatch(iTestCase.iIdentifierMatch);

		break;

	case ESmsAddrMessageIndication:

		break;

	default:

		break;

		};

	ret=iSocket.Bind(smsAddr);

	User::LeaveIfError(ret);

	}

void CActiveSocket::ReceiveMessage(TRequestStatus* aStatus)

//

// Receive a message

//

	{

	iActiveReceiverStatus = aStatus;

	iSelectBuf()=KSockSelectRead;

	iSocket.Ioctl(KIOctlSelect,iStatus,&iSelectBuf,KSOLSocket);

	SetActive();

	}

void CActiveSocket::DoCancel()

//

// Cancel the select

//

	{

	iSocket.CancelAll();

	}

void CActiveSocket::RunL()

//

// Got something to read

//

	{

	if (iStatus<0)

		{

		User::RequestComplete(iActiveReceiverStatus,iStatus.Int());

		return;

		}

	RSmsSocketReadStream readstream(iSocket);

	TRAPD(ret,readstream >> *iSmsMessage);

	User::LeaveIfError(ret);

	TPckgBuf<TUint> sbuf;

	TRequestStatus status;

	iSocket.Ioctl(KIoctlReadMessageSucceeded,status,&sbuf, KSolSmsProv);

	User::WaitForRequest(status);

	User::RequestComplete(iActiveReceiverStatus,iActiveReceiverIndex);

	}

TBool CActiveSocket::TestComplete()

//

// Socket has finished performing all tests

//

	{

	if (iTestCase.iTestForever)

		return EFalse;

	return ETrue;

	}

//

//

// CActiveReceiverImp

//

//

CActiveReceiverImp* CActiveReceiverImp::NewL(RSocketServ& aSocketServer, RFs& aFs)

//

// Factory

//

	{

	CActiveReceiverImp* actRecv = new(ELeave) CActiveReceiverImp(aSocketServer, aFs);

	CleanupStack::PushL(actRecv);

	actRecv->iSockArray=new(ELeave) CArrayPtrSeg<CActiveSocket>(KActiveReceiverSocketGranularity);

	actRecv->iStatus=KRequestPending;

	CleanupStack::Pop();

	CActiveScheduler::Add(actRecv);

	return actRecv;

	}

CActiveReceiverImp::CActiveReceiverImp(RSocketServ& aSocketServer, RFs& aFs)

//

// Constructor

//

:CActiveReceiver(aSocketServer, aFs)

	{}

CActiveReceiverImp::~CActiveReceiverImp()

//

// Destructor

//

	{

	if (iSockArray)

		{

		StopTests();

		iSockArray->ResetAndDestroy();

		}

	delete iStopTest;

	delete iSockArray;

	}

void CActiveReceiverImp::AddTestL(const TTestCase& aTest)

//

// Add a test case to the receiver

//

	{

	CActiveSocket* socket = CActiveSocket::NewL(aTest, iSocketServer, iFs);

	CleanupStack::PushL(socket);

	iSockArray->AppendL(socket);

	socket->SetIndex(iSockArray->Count()-1);

	socket->ReceiveMessage(&iStatus);

	CleanupStack::Pop();

	if (aTest.iMatchType==ESmsAddrStatusReport)

		{

		// Add a test to match the original message as well as the status report

		TTestCase srrIdMatch(aTest.iMsg,aTest.iMsg.Left(TSmsAddr::EMaxTextMatchLength));

		AddTestL(srrIdMatch);

		}

	}

void CActiveReceiverImp::StartTestsL()

//

// Kick off the tests

//

	{

	SetActive();

	CActiveScheduler::Start();

	}

void CActiveReceiverImp::StopTests()

//

// Cancel all active sockets

//

	{

	for (TInt i=0;i<iSockArray->Count();i++)

		(*iSockArray)[i]->Cancel();

	if (iStopTest)

		iStopTest->Cancel();

	Cancel();

	}

void CActiveReceiverImp::StopIfKeyPressedL()

//

// Stop the active scheduler if a key is pressed

//

	{

	if (!iStopTest)

		iStopTest=CStopIfKeyPressed::NewL(this);

	iStopTest->StopIfKeyPressed();

	}

void CActiveReceiverImp::DoCancel()

	{

	TRequestStatus* status = &iStatus;

	User::RequestComplete(status,KErrCancel);

	}

void CActiveReceiverImp::RunL()

//

// An active socket has received a message

//

	{

	TInt index = iStatus.Int();

	CActiveSocket* socket = (*iSockArray)[index];

	socket->TestResultL();

	if (socket->TestComplete())

		iResultCount++;

	else

		socket->ReceiveMessage(&iStatus);

	if (iResultCount == iSockArray->Count())

		{

		StopTests();

		CActiveScheduler::Stop();

		return;

		}

	SetActive();

	iStatus=KRequestPending;

	}

//

//

// TTestCase

//

//

TTestCase::TTestCase()

//

// Constructor

//

	{

	CommonInit();

	}

TTestCase::TTestCase(const TDesC& aMsg, const TDesC& aMatch)

//

// Constructor

//