// Copyright (c) 1996-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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:

// e32test\device\t_loop.cpp

// 

//

//#define _DEBUG_DEVCOMM

#include <e32base.h>

#include <e32base_private.h>

#include <e32test.h>

#include <e32svr.h>

#include <d32comm.h>

#include <e32math.h>

#include <e32uid.h>

#if defined (__WINS__)

#define __COMM_LDD _L("ECOMM")

#define __COMM_PDD1 _L("ECDRV")

#else

#define __COMM_LDD _L("ECOMM")

#define __COMM_PDD1 _L("EUART1")

#define __COMM_PDD2 _L("EUART2")

#endif

const char KSpinner[]={'|','/','-','\\',};

const TInt KKeyboardPriority	= 4;

const TInt KTimerPriority		= 3;

const TInt KWriterPriority		= 2;

const TInt KReaderPriority		= 1;

////////////////////////////////////////////////////////////////////////////////

RTest Test(_L("T_LOOP"));

#define TEST(a) __DoTest((a), __FILE__, __LINE__, 0)

#define TESTERR(a,b) __DoTest((a), __FILE__, __LINE__, b)

void __DoTest(TBool aCondition, char* aFile, TInt aLine, TInt aErr)

	{

	if (aCondition)

		return;

	if (aErr==0)

		Test.Printf(_L("\r\nCheckpoint Fail at %s:%d\r\n"), aFile, aLine);

	else

		Test.Printf(_L("\r\nCheckpoint Fail at %s:%d: Return code = %d (0x%x)\r\n"), aFile, aLine, aErr, aErr);

	__DEBUGGER();

	Test.Getch();

	User::Exit(aErr);

	}

////////////////////////////////////////////////////////////////////////////////

class CDevCommTestBase;

// This needs:

// inline void Read(TRequestStatus &aStatus) { iConsole->Read(aStatus); }

// inline void ReadCancel() { iConsole->ReadCancel(); }

// inline void TKeyCode KeyCode() { return iConsole->KeyCode(); }

// adding to RTest

class CKeyReader : public CActive

	{

public:

	CKeyReader(CDevCommTestBase* aTester, RTest& aTest);

	~CKeyReader();

	void Start();

protected:

	void RunL();

	void DoCancel();

public:

	RTest& iTest;

	TKeyCode iKey;

	CDevCommTestBase* iTester;

	};

class CDevCommIOBase : public CActive

	{

public:

	CDevCommIOBase(CDevCommTestBase* aTester, TInt aPriority);

	~CDevCommIOBase();

	void CreateL(TInt aBufferSize);

	void UpdateCount();

	void ResetCount();

public:

	CDevCommTestBase* iTester;

	TPtr8 iDes;

	TUint8* iBuffer;

	TInt iSize;

	TInt iCount;

	TInt iTotal;

	};

class CDevCommWriterBase : public CDevCommIOBase

	{

public:

	CDevCommWriterBase(CDevCommTestBase* aTester);

	~CDevCommWriterBase();

	void Ready();

	void Start();

protected:

	void RunL();

	void DoCancel();

	};

class CDevCommReaderBase : public CDevCommIOBase

	{

public:

	CDevCommReaderBase(CDevCommTestBase* aTester);

	~CDevCommReaderBase();

	void Ready();

	void Start();

protected:

	void RunL();

	void DoCancel();

	};

class CDevCommTimerBase : public CTimer

	{

public:

	CDevCommTimerBase(CDevCommTestBase* aTester);

	void CreateL();

protected:

	void RunL();

public:

	CDevCommTestBase* iTester;

	};

enum THandshakeMode

	{

	EHandshakeNone,

	EHandshakeHardware,

	EHandshakeSoftware

	};

class CDevCommTestBase : public CAsyncOneShot

	{

public:

	CDevCommTestBase();

	~CDevCommTestBase();

	void CreateL(TInt aBufferSize);

	TInt Open(TInt aPort);

	void Close();

	void Debug();

	TInt SetHandshaking(THandshakeMode aMode);

	TInt LineFailOn();

	TInt LineFailOff();

	TInt ZeroTerminate();

	void ShowLoopSignals(TUint aOutState, TUint aInState);

	virtual void ReadComplete(TInt aStatus);

	virtual void WriteComplete(TInt aStatus);

	virtual void TimeComplete(TInt aStatus);

	virtual void KeyComplete(TKeyCode aKey);

	void Start();

public:

	RBusDevComm iComm;

	CDevCommWriterBase* iWriter;

	CDevCommReaderBase* iReader;

	CDevCommTimerBase* iTimer;

	CKeyReader* iKeyboard;

	TInt iBufferSize;

	};

CKeyReader::CKeyReader(CDevCommTestBase* aTester, RTest& aTest)

	: CActive(KKeyboardPriority), iTest(aTest), iTester(aTester)

	{

	__DECLARE_NAME(_S("CKeyReader"));

	CActiveScheduler::Add(this);

	}

CKeyReader::~CKeyReader()

	{

	Cancel();

	}

void CKeyReader::Start()

	{

	if (IsActive())

		return;

	SetActive();

	iTest.Console()->Read(iStatus);

	}

void CKeyReader::RunL()

	{

	iKey = iTest.Console()->KeyCode();

	iTester->KeyComplete(iKey);

	Start();

	}

void CKeyReader::DoCancel()

	{

	iTest.Console()->ReadCancel();

	}

CDevCommIOBase::CDevCommIOBase(CDevCommTestBase* aTester, TInt aPriority)

	: CActive(aPriority), iTester(aTester), iDes(NULL, 0)

	{

	__DECLARE_NAME(_S("CDevCommIOBase"));

	CActiveScheduler::Add(this);

	}

CDevCommIOBase::~CDevCommIOBase()

	{

	if (iBuffer)

		User::Free(iBuffer);

	}

void CDevCommIOBase::CreateL(TInt aSize)

	{

	iSize = aSize;

	if (iSize>0)

		iBuffer = (TUint8*)User::AllocL(iSize);

	iDes.Set(iBuffer, iSize, iSize);

	}

void CDevCommIOBase::UpdateCount()

	{

	iCount += iDes.Length();

	iTotal += iDes.Length();

	}

void CDevCommIOBase::ResetCount()

	{

	iCount = 0;

	}

CDevCommWriterBase::CDevCommWriterBase(CDevCommTestBase* aTester)

	: CDevCommIOBase(aTester, KWriterPriority)

	{

	__DECLARE_NAME(_S("CDevCommWriterBase"));

	}

CDevCommWriterBase::~CDevCommWriterBase()

	{

	Cancel();

	}

void CDevCommWriterBase::Start()

	{

	__ASSERT_ALWAYS(iBuffer!=NULL, User::Panic(_L("No Buffer"), 0));

	if (IsActive())

		return;

	SetActive();

	iTester->iComm.Write(iStatus, iDes);

	}

void CDevCommWriterBase::Ready()

	{

	if (IsActive())

		return;

	SetActive();

	iTester->iComm.Write(iStatus, TPtr8(NULL, 0));

	}

void CDevCommWriterBase::RunL()

	{

	UpdateCount();

	iTester->WriteComplete(iStatus.Int());

	}

void CDevCommWriterBase::DoCancel()

	{

	iTester->iComm.WriteCancel();

	}

CDevCommReaderBase::CDevCommReaderBase(CDevCommTestBase* aTester)

	: CDevCommIOBase(aTester, KReaderPriority)

	{

	__DECLARE_NAME(_S("CDevCommReaderBase"));

	}

CDevCommReaderBase::~CDevCommReaderBase()

	{

	Cancel();

	}

void CDevCommReaderBase::Start()

	{

	__ASSERT_ALWAYS(iBuffer!=NULL, User::Panic(_L("No Buffer"), 0));

	if (IsActive())

		return;

	SetActive();

	iDes.SetLength(iDes.MaxLength()-iCount);

	iTester->iComm.Read(iStatus, iDes);

	}

void CDevCommReaderBase::Ready()

	{

	if (IsActive())

		return;

	SetActive();

    TPtr8 ptr(NULL, 0);

    iTester->iComm.Read(iStatus, ptr);

	}

void CDevCommReaderBase::RunL()

	{

	UpdateCount();

	iTester->ReadComplete(iStatus.Int());

	}

void CDevCommReaderBase::DoCancel()

	{

	iTester->iComm.ReadCancel();

	}

CDevCommTimerBase::CDevCommTimerBase(CDevCommTestBase* aTester)

	: CTimer(KTimerPriority), iTester(aTester)

	{

	__DECLARE_NAME(_S("CDevCommTestTimerBase"));

	CActiveScheduler::Add(this);

	}

void CDevCommTimerBase::CreateL()

	{

	ConstructL();

	}

void CDevCommTimerBase::RunL()

	{

	iTester->TimeComplete(iStatus.Int());

	}

CDevCommTestBase::CDevCommTestBase()

	: CAsyncOneShot(-1)

	{

	__DECLARE_NAME(_S("CDevCommTestBase"));

	}

CDevCommTestBase::~CDevCommTestBase()

	{

	delete iKeyboard;

	delete iTimer;

	delete iWriter;

	delete iReader;

	iComm.Close();

	}

void CDevCommTestBase::CreateL(TInt aBufferSize)

	{

	iBufferSize = aBufferSize;

	iKeyboard = new (ELeave) CKeyReader(this, Test);

	iTimer = new (ELeave) CDevCommTimerBase(this);

	iWriter = new (ELeave) CDevCommWriterBase(this);

	iReader = new (ELeave) CDevCommReaderBase(this);

	iKeyboard->Start();

	iWriter->CreateL(iBufferSize);

	iTimer->CreateL();

	iReader->CreateL(iBufferSize/16);

	}

void CDevCommTestBase::Start()

	{

	Call();

	}

TInt CDevCommTestBase::Open(TInt aPort)

	{

	TInt err;

    if (err = iComm.Open(aPort), err!=KErrNone)

		return err;

    TCommConfig cBuf;

	TCommConfigV01 &c=cBuf();

	iComm.Config(cBuf);

    c.iStopBits = EStop1;

    c.iDataBits = EData8;

    c.iParity = EParityNone;

	c.iHandshake = 0

//		| KConfigObeyXoff

//		| KConfigSendXoff

		| KConfigObeyCTS

//		| KConfigFailCTS

		| KConfigObeyDSR

//		| KConfigFailDSR

//		| KConfigObeyDCD

//		| KConfigFailDCD

//		| KConfigFreeRTS

//		| KConfigFreeDTR

		;

    c.iRate = EBps115200;

    c.iFifo = EFifoEnable;

	c.iTerminatorCount = 0;

	c.iTerminator[0] = 0x00;

    if (err = iComm.SetConfig(cBuf), err!=KErrNone)

		{

		iComm.Close();

		return err;

		}

	return KErrNone;

	}

TInt CDevCommTestBase::ZeroTerminate()

	{

	TCommConfig cBuf;

	TCommConfigV01 &c=cBuf();

	iComm.Config(cBuf);

	c.iTerminatorCount = 1;

	c.iTerminator[0] = 0x00;

    return iComm.SetConfig(cBuf);

	}

void CDevCommTestBase::Close()

	{

	iTimer->Cancel();

	iReader->Cancel();

	iWriter->Cancel();

	iComm.Close();

	}

TInt CDevCommTestBase::SetHandshaking(THandshakeMode aMode)

	{

    TCommConfig cBuf;

	TCommConfigV01 &c=cBuf();

	iComm.Config(cBuf);

	switch (aMode)

		{

	case EHandshakeNone:

	c.iHandshake = 0

//		| KConfigObeyXoff

//		| KConfigSendXoff

//		| KConfigObeyCTS

//		| KConfigFailCTS

//		| KConfigObeyDSR

//		| KConfigFailDSR

//		| KConfigObeyDCD

//		| KConfigFailDCD

		| KConfigFreeRTS

		| KConfigFreeDTR

		;

		break;

	case EHandshakeSoftware:

	c.iXonChar=0x11;

	c.iXoffChar=0x13;

	c.iHandshake = 0

		| KConfigObeyXoff

		| KConfigSendXoff

//		| KConfigObeyCTS

//		| KConfigFailCTS

//		| KConfigObeyDSR

//		| KConfigFailDSR

//		| KConfigObeyDCD

//		| KConfigFailDCD

		| KConfigFreeRTS

		| KConfigFreeDTR

		;

		break;

	case EHandshakeHardware:

	c.iHandshake = 0

//		| KConfigObeyXoff

//		| KConfigSendXoff

		| KConfigObeyCTS

//		| KConfigFailCTS

		| KConfigObeyDSR

//		| KConfigFailDSR

//		| KConfigObeyDCD

//		| KConfigFailDCD

//		| KConfigFreeRTS

//		| KConfigFreeDTR

		;

		break;

		}

    return iComm.SetConfig(cBuf);

	}

TInt CDevCommTestBase::LineFailOn()

	{

    TCommConfig cBuf;

	TCommConfigV01 &c=cBuf();

	iComm.Config(cBuf);

	c.iHandshake |= (KConfigFailDSR|KConfigFailDCD);

    return iComm.SetConfig(cBuf);

	}

TInt CDevCommTestBase::LineFailOff()

	{

    TCommConfig cBuf;

	TCommConfigV01 &c=cBuf();

	iComm.Config(cBuf);

	c.iHandshake &= ~(KConfigFailDSR|KConfigFailDCD);

    return iComm.SetConfig(cBuf);

	}

void CDevCommTestBase::ShowLoopSignals(TUint aOutState, TUint aInState)

	{

	TPtrC cts, dsr, dcd;

	TPtrC rts, dtr;

	rts.Set(aOutState & KSignalRTS ? _L("RTS On ") : _L("RTS Off"));

	dtr.Set(aOutState & KSignalDTR ? _L("DTR On ") : _L("DTR Off"));

	Test.Printf(_L("%S, %S : "), &rts,  &dtr);

	cts.Set(aInState & KSignalCTS ? _L("CTS On ") : _L("CTS Off"));

	dsr.Set(aInState & KSignalDSR ? _L("DSR On ") : _L("DSR Off"));

	dcd.Set(aInState & KSignalDCD ? _L("DCD On ") : _L("DCD Off"));

	Test.Printf(_L("%S, %S, %S "), &cts, &dsr, &dcd);

	rts.Set(aInState & KSignalRTS ? _L("RTS On ") : _L("RTS Off"));

	dtr.Set(aInState & KSignalDTR ? _L("DTR On ") : _L("DTR Off"));

	Test.Printf(_L("[%S, %S]\r\n"), &rts,  &dtr);

	}

#ifdef _DEBUG_DEVCOMM

void CDevCommTestBase::Debug()

	{

	TCommDebugInfoPckg infopckg;

	TCommDebugInfo& info = infopckg();