/*

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

*

*/

#include <e32twin.h>

#include <e32svr.h>

#include "activeconsole.h"

#include "testbase.h"

#include "tests.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "activeconsoleTraces.h"

#endif

CActiveConsole::CActiveConsole(CConsoleBase& aConsole)

 :	CActive(CActive::EPriorityStandard),

	iConsole(aConsole)

	{

	OstTraceFunctionEntry0( CACTIVECONSOLE_CACTIVECONSOLE_ENTRY );

	CActiveScheduler::Add(this);

	OstTraceFunctionExit0( CACTIVECONSOLE_CACTIVECONSOLE_EXIT );

	}

CActiveConsole* CActiveConsole::NewLC(CConsoleBase& aConsole)

	{

	OstTraceFunctionEntry0( CACTIVECONSOLE_NEWLC_ENTRY );

	CActiveConsole* self = new(ELeave) CActiveConsole(aConsole);

	CleanupStack::PushL(self);

	self->ConstructL();

#ifdef COMMANDLINE_PARAM	

	self->DisplayMainMenu();

#endif	

	OstTraceFunctionExit0( CACTIVECONSOLE_NEWLC_EXIT );

	return self;

	}

void CActiveConsole::ConstructL()

	{

	OstTraceFunctionEntry0( CACTIVECONSOLE_CONSTRUCTL_ENTRY );

	// Launch of FDTest test.

	iTest = gTestDefinitions[0].iFactoryL(*this);

	OstTraceFunctionExit0( CACTIVECONSOLE_CONSTRUCTL_EXIT );

	}

CActiveConsole::~CActiveConsole()

	{

	OstTraceFunctionEntry0( DUP1_CACTIVECONSOLE_CACTIVECONSOLE_ENTRY );

	Cancel();

	StopCurrentTest();

	OstTraceFunctionExit0( DUP1_CACTIVECONSOLE_CACTIVECONSOLE_EXIT );

	}

void CActiveConsole::DoCancel()

	{

	OstTraceFunctionEntry0( CACTIVECONSOLE_DOCANCEL_ENTRY );

	iConsole.ReadCancel();

	OstTraceFunctionExit0( CACTIVECONSOLE_DOCANCEL_EXIT );

	}

void CActiveConsole::StopCurrentTest()

	{

	OstTraceFunctionEntry0( CACTIVECONSOLE_STOPCURRENTTEST_ENTRY );

	delete iTest;

	iTest = NULL;

	OstTraceFunctionExit0( CACTIVECONSOLE_STOPCURRENTTEST_EXIT );

	}

void CActiveConsole::RunL()

// Only process when we get a return, otherwise cache- i.e. support multi-character selections

	{

	OstTraceFunctionEntry0( CACTIVECONSOLE_RUNL_ENTRY );

	DoActionKeyL(iConsole.KeyCode());

	// Repost asynchronous request.

	RequestCharacter();

	OstTraceFunctionExit0( CACTIVECONSOLE_RUNL_EXIT );

	}

void CActiveConsole::DoActionKeyL(TKeyCode aKeyCode)

	{

	OstTraceFunctionEntry0( CACTIVECONSOLE_DOACTIONKEYL_ENTRY );

	WriteNoReturn(_L8("%c"), aKeyCode);

	// Examine the key that just came in.

	switch ( TUint(aKeyCode) )

		{

	case EKeyEscape:

		{

		Write(_L8("Exiting"));

		CActiveScheduler::Stop();

		OstTraceFunctionExit0( CACTIVECONSOLE_DOACTIONKEYL_EXIT );

		return;

		}

	case EKeyEnter:

		// Tell the test about what's in the buffer so far, if anything.

		Write(_L8("You entered \'%S\'"), &iInputBuffer);

		switch ( iInputBuffer.Length() )

			{

		case 0:

			// Don't pass anything on- nothing to pass on.

			break;

		case 1:

			if ( 	iInputBuffer == _L8("S") 

				||	iInputBuffer == _L8("s") 

				)

				{

				StopCurrentTest();

				}

			else

				{

				// Tell the test via the old 'single character' interface.

				// If there is a test, then let it process the key. If there isn't a 

				// test, we process it to (possibly) create and run a new test object.

				if ( iTest )

					{

					TRAPD(err, iTest->ProcessKeyL((TKeyCode)iInputBuffer[0]));

					if ( err )

						{

						Write(_L8("CTestBase::ProcessKeyL left with %d"), err);

						StopCurrentTest();

						}

					}

				else

					{

					SelectTestL();

					}

				}

			iInputBuffer = KNullDesC8();

			break;

		default:

			// Tell the test via the new 'multi character' interface.

			// If there is a test, then let it process the key. If there isn't a 

			// test, we process it to (possibly) create and run a new test object.

			if ( iTest )

				{

				TRAPD(err, iTest->ProcessKeyL(iInputBuffer));

				if ( err )

					{

					Write(_L8("CTestBase::ProcessKeyL left with %d"), err);

					StopCurrentTest();

					}

				}

			else

				{

				SelectTestL();

				}

			iInputBuffer = KNullDesC8();

			break;

			}

		DisplayMainMenu();

		break;

	default:

		iInputBuffer.Append(aKeyCode);

		break;

		}

	OstTraceFunctionExit0( DUP1_CACTIVECONSOLE_DOACTIONKEYL_EXIT );

	}

void CActiveConsole::RequestCharacter()

	{

	OstTraceFunctionEntry0( CACTIVECONSOLE_REQUESTCHARACTER_ENTRY );

	iConsole.Read(iStatus);

	SetActive();

	OstTraceFunctionExit0( CACTIVECONSOLE_REQUESTCHARACTER_EXIT );

	}

void CActiveConsole::DisplayMainMenu()

	{

	OstTraceFunctionEntry0( CACTIVECONSOLE_DISPLAYMAINMENU_ENTRY );

	Write(KNullDesC8);

	// If there's a current test, display its step menu. Otherwise, display 

	// all the available tests.

	if ( iTest )

		{

		iTest->DisplayTestSpecificMenu();

		Write(_L8("s - stop and close current test"));

		}

	else

		{

		const TUint numberOfTests = sizeof(gTestDefinitions) / sizeof(TTestDefinition);

		for ( TUint ii = 0 ; ii < numberOfTests ; ii ++ )

			{

			Write(_L8("%d - %S"), ii, &gTestDefinitions[ii].iDescription);

			}

		}

	Write(_L8("Escape - exit program"));

	Write(KNullDesC8);

 	OstTraceFunctionExit0( CACTIVECONSOLE_DISPLAYMAINMENU_EXIT );

 	}

void CActiveConsole::Write(TRefByValue<const TDesC8> aFmt, ...)

	{

	OstTraceFunctionEntry0( CACTIVECONSOLE_WRITE_ENTRY );

	VA_LIST list;

	VA_START(list, aFmt);

	TBuf8<0x100> buf;

	buf.AppendFormatList(aFmt, list);

	TBuf<0x100> wideBuf;

	wideBuf.Copy(buf);

	iConsole.Write(wideBuf);

	iConsole.Write(_L("\n"));

	RDebug::Print(wideBuf);

	OstTraceFunctionExit0( CACTIVECONSOLE_WRITE_EXIT );

	}

void CActiveConsole::WriteNoReturn(TRefByValue<const TDesC8> aFmt, ...)

	{

	OstTraceFunctionEntry0( CACTIVECONSOLE_WRITENORETURN_ENTRY );

	VA_LIST list;

	VA_START(list, aFmt);

	TBuf8<0x100> buf;

	buf.AppendFormatList(aFmt, list);

	TBuf<0x100> wideBuf;

	wideBuf.Copy(buf);

	iConsole.Write(wideBuf);

	RDebug::Print(wideBuf);

	OstTraceFunctionExit0( CACTIVECONSOLE_WRITENORETURN_EXIT );

	}

TKeyCode CActiveConsole::Getch()

	{

	OstTraceFunctionEntry0( CACTIVECONSOLE_GETCH_ENTRY );

	return iConsole.Getch();

	}

void CActiveConsole::SelectTestL()

	{

	OstTraceFunctionEntry0( CACTIVECONSOLE_SELECTTESTL_ENTRY );

	StopCurrentTest();

	// Pick a test out of the global array of tests.

	const TUint numberOfTests = sizeof(gTestDefinitions) / sizeof (TTestDefinition);

	TLex8 lex(iInputBuffer);

	TUint index;

	TInt err = lex.Val(index);

	if (	err == KErrNone

		&&	index < numberOfTests

		)

		{

		iTest = gTestDefinitions[index].iFactoryL(*this);

		}

	else

		{

		Write(_L8("Unknown selection"));

		}

	OstTraceFunctionExit0( CACTIVECONSOLE_SELECTTESTL_EXIT );

	}

void CActiveConsole::TestFinished()

/**

 * Called by the test when it has finished. Results in the destruction of the 

 * test.

 */

	{

	OstTraceFunctionEntry0( CACTIVECONSOLE_TESTFINISHED_ENTRY );

	StopCurrentTest();

	OstTraceFunctionExit0( CACTIVECONSOLE_TESTFINISHED_EXIT );

	}

TInt CActiveConsole::RunError(TInt aError)

/**

 * Called by the Active Scheduler when a RunL in this active object leaves.

 */

	{

	OstTraceFunctionEntry0( CACTIVECONSOLE_RUNERROR_ENTRY );

	// This actually happens when a test object fails to construct properly.

	Write(_L8("Error creating test object: %d"), aError);

	iInputBuffer = KNullDesC8();

	DisplayMainMenu();

	// It's OK to carry on with the program itself, so repost asynchronous 

	// request.

	RequestCharacter();

	OstTraceFunctionExit0( CACTIVECONSOLE_RUNERROR_EXIT );

	return KErrNone;

	}

void CActiveConsole::GetNumberL(TUint& aNumber)

	{

	OstTraceFunctionEntry0( CACTIVECONSOLE_GETNUMBERL_ENTRY );

	TBuf<12> addrAsText;

	addrAsText.Zero();

	if ( aNumber != 0 )

		{

		addrAsText.Format(_L("%d"), aNumber);

		}

	WriteNoReturn(_L8("Enter a number: "));

	if ( addrAsText.Length() > 0 )

		{

		TBuf8<100> narrowBuf;

		narrowBuf.Copy(addrAsText);

		WriteNoReturn(narrowBuf);

		}

	TKeyCode code;

	TBuf<1> character;

	FOREVER

		{

		code = Getch();

		character.SetLength(0);

		character.Append(code);

		// If <CR> finish editing string

		if (code == 0x0d)

			break;

		// if <BS> remove last character

		if ((code == 0x08)&&(addrAsText.Length() != 0))

			{

			WriteNoReturn(_L8("%S"),&character);

			addrAsText.SetLength((addrAsText.Length()-1));

			}

		else

			{

			if (addrAsText.Length() < addrAsText.MaxLength())

				{

				WriteNoReturn(_L8("%S"),&character);

				addrAsText.Append(code);

				}

			}

		}

	//now extract the new address from the string...

	if( !addrAsText.Length() )

		{

		addrAsText.Append('0'); //null string causes TLex::Val to return an error

		}

	TLex lex(addrAsText);

	TInt err = lex.Val(aNumber, EDecimal);

	User::LeaveIfError(err);

	OstTraceFunctionExit0( CACTIVECONSOLE_GETNUMBERL_EXIT );

	}