/*

* Copyright (c) 2005-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 "T_RConsoleData.h"

/*@{*/

//wrappers

_LIT(KCmdRead,				"Read");

_LIT(KCmdWrite,				"Write");

_LIT(KCmdControl,			"Control");

_LIT(KCmdInit,				"Init");

_LIT(KCmdDestroy,			"Destroy");

_LIT(KCmdCreate,			"Create");

_LIT(KCmdConstructor,		"new");

_LIT(KCmdDestructor,		"~");

_LIT(KCmdClearScreen,		"ClearScreen");

//ini sections

_LIT(KFldText,				"text");

_LIT(KFldConsoleControl,	"consoleControl");

_LIT(KFldConsoleName,		"consoleName");

_LIT(KFldConsoleSize,		"consoleSize");

_LIT(KFldSynchronous,		"synchronous");

//format fields

_LIT(KLogMissingParameter,	"Missing parameter '%S'");

_LIT(KLogError,				"Error=%d");

_LIT(KLogStringNotFound,	"String not found %S");

_LIT(KLogStraySignal,		"Stray signal");

_LIT(KLogAsyncError,		"Async RunL Error %d");

_LIT(KLogDataMissing,		"Data missing for test");

/*@}*/

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

// Construction/Destruction

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

CT_RConsoleData* CT_RConsoleData::NewL()

	{

	CT_RConsoleData* console=new (ELeave) CT_RConsoleData();

	CleanupStack::PushL(console);

	console->ConstructL();

	CleanupStack::Pop(console);

	return console;

	}

CT_RConsoleData::CT_RConsoleData()

:	CT_RSessionBaseData()

,	iActiveRConsoleRead(NULL)

,	iConsole(NULL)

	{

	}

void CT_RConsoleData::ConstructL()

/**

 * Second phase construction

 *

 * @internalComponent

 *

 * @return	N/A

 *

 * @pre		None

 * @post	None

 *

 * @leave	system wide error

 */

	{

	iActiveRConsoleRead	= CT_ActiveRConsoleRead::NewL(*this);

	}

CT_RConsoleData::~CT_RConsoleData()

/**

 * Public destructor

 */

	{

	DestroyData();

	delete iActiveRConsoleRead;

	iActiveRConsoleRead= 	NULL;

	}

void CT_RConsoleData::DestroyData()

 /**

 *	RConsole Destruction

 *

 */

	{

 	delete	iConsole;

 	iConsole	=NULL;

	}

 TAny* CT_RConsoleData::GetObject()

/**

 * Return a pointer to the object that the data wraps

 *

 * @return	pointer to the object that the data wraps

 */

	{

	return iConsole;

	}

RSessionBase* CT_RConsoleData::GetSessionBase()

	{

	return iConsole;

	}

RHandleBase* CT_RConsoleData::GetHandleBase()

	{

	return iConsole;

	}

TBool CT_RConsoleData::DoCommandL(const TTEFFunction& aCommand, const TTEFSectionName& aSection, const TInt aAsyncErrorIndex)

/**

 * Process a command read from the ini file

 *

 * @param aCommand                      The command to process

 * @param aSection                      The section in the ini containing data for the command

 * @param aAsyncErrorIndex              Command index for async calls to return errors to

 *

 * @return                              ETrue if the command is processed

 *

 * @leave                               System wide error

 */

	{

	TBool 	ret	=ETrue;

	TInt	error=KErrNone;

	if (aCommand==KCmdConstructor())

		{

		error	=DoCmdConstructor();

		}

	else if ( aCommand==KCmdDestructor )

		{

		DoCmdDestructor();

		}

	else if ( aCommand==KCmdRead())

		{

		error	=DoCmdRead(aSection, aAsyncErrorIndex);

		}

	else if ( aCommand==KCmdWrite())

		{

		error	=DoCmdWrite(aSection);

		}

	else if ( aCommand==KCmdDestroy())

		{

		error	=DoCmdDestroy();

		}

	else if ( aCommand==KCmdControl())

		{

		error	=DoCmdControl(aSection);

		}

	else if ( aCommand==KCmdInit())

		{

		error	=DoCmdInit(aSection);

		}

	else if ( aCommand==KCmdCreate())

		{

		error	=DoCmdCreate();

		}

	else if ( aCommand==KCmdClearScreen())

		{

		error	=DoCmdClearScreen();

		}

	else

		{

		ret=CT_RSessionBaseData::DoCommandL(aCommand, aSection, aAsyncErrorIndex);

		}

	if ( error!=KErrNone )

		{

		ERR_PRINTF2(KLogError, error);

		SetError(error);

		}

	return ret;

	}

TInt CT_RConsoleData::DoCmdConstructor()

 /**

 *	Wrapper function for RConsole Construction

 *

 */

	{

	DestroyData();

	TRAPD(err, iConsole=new (ELeave) RConsole());

	return err;

	}

void CT_RConsoleData::DoCmdDestructor()

 /**

 *	Wrapper function for RConsole Destruction

 *

 */

	{

	DestroyData();

	}

TInt CT_RConsoleData::DoCmdRead(const TDesC& aSection , const TInt aAsyncErrorIndex)

 /**

 *	Wrapper function for RConsole::Read(TConsoleKey &aKeystroke,TRequestStatus &aStatus)

 * 	and RConsole::Read(TConsoleKey &aKeystroke)

 *

 *	@param		aSection			The section in the ini containing data for the command

 * 	@param		aAsyncErrorIndex	Command index for async calls to return errors to

 */

 	{

 	TBool	sync=EFalse;

	GETFROMCONFIGOPTIONAL(Bool, aSection, KFldSynchronous(), sync, KLogMissingParameter);

	TInt	error=KErrNone;

	if ( !sync )

		{

		if ( !iActiveRConsoleRead->KickStartL(aSection, aAsyncErrorIndex, *iConsole) )

			{

			ERR_PRINTF1(KLogDataMissing);

			SetBlockResult(EFail);

			}

		else

			{

			IncOutstanding();

			}

		}

	else

		{

		TConsoleKey	key;

		error=iConsole->Read(key);

		}

	return error;

 	}

TInt CT_RConsoleData::DoCmdWrite(const TDesC& aSection )

 /**

 *	Wrapper function for RConsole::Write(const TDesC &aDes)

 *	@param		aSection			The section in the ini containing data for the command

 */

 	{

	TBool dataOk	=EFalse;

	TInt error		=KErrNone;

	TPtrC string;

	GETSTRINGFROMCONFIGMANDATORY(aSection, KFldText(), string, KLogStringNotFound,  dataOk);

	if ( dataOk==KErrNone)

		{

		error	=iConsole->Write(string);

		}

	return error;

 	}

TInt CT_RConsoleData::DoCmdControl(const TDesC& aSection)

 /**

 *	Wrapper function for RConsole::Control(const TDesC &aDes)

 *	@param		aSection			The section in the ini containing data for the command

 */

	{

	TBool dataOk	=EFalse;

	TInt error	=KErrNone;

	TPtrC control;

	GETSTRINGFROMCONFIGMANDATORY(aSection, KFldConsoleControl(), control, KLogStringNotFound, dataOk);

	if (dataOk==KErrNone)

		{

		error	=iConsole->Control(control);

		}

	return error;

	}

TInt CT_RConsoleData::DoCmdInit(const TDesC& aSection)

 /**

 *	Wrapper function for RConsole::Init(const TDesC &aName,const TSize &aSize

 *	@param		aSection			The section in the ini containing data for the command

 */

	{

	TBool	dataOk=ETrue;

	TPtrC	name;

	GETSTRINGFROMCONFIGMANDATORY(aSection, KFldConsoleName(), name, KLogMissingParameter, dataOk);

	TSize	size(KConsFullScreen, KConsFullScreen);

	GetSizeFromConfig(aSection, KFldConsoleSize(), size);

	TInt	error=KErrNone;

	if ( dataOk )

		{

		error=iConsole->Init(name, size);

		}

	return error;

	}

TInt CT_RConsoleData::DoCmdDestroy()

 /**

 *	Wrapper function for RConsole::Destroy()

 */

	{

	return iConsole->Destroy();

	}

TInt CT_RConsoleData::DoCmdCreate()

 /**

 *	Wrapper function for RConsole::Create()

 */

	{

	return iConsole->Create();

	}

TInt CT_RConsoleData::DoCmdClearScreen()

 /**

 *	Wrapper function for RConsole::ClearScreen()

 *

 */

	{

	return iConsole->ClearScreen();

	}

void CT_RConsoleData::RunL(CActive* aActive, TInt aIndex)

 /**

 * Called on completion of an asynchronous command

 * @param               aActive Active Object that RunL has been called on

 * @param               aIndex number of the command.

 * @pre                 N/A

 * @post                N/A

 * @leave               system wide error code

 */

	{

	TBool	activeOk=ETrue;

	TInt	err=KErrNone;

	if ( aActive!=NULL )

		{

		err=aActive->iStatus.Int();

		}

	TBool	moreToDo=EFalse;

	if(	aActive==iActiveRConsoleRead)

		{

		iActiveRConsoleRead->KillTimer();

		if ( err==KErrNone )

			{

			moreToDo=iActiveRConsoleRead->VerifyDataAndKick(aIndex, *iConsole);

			if ( !moreToDo )

				{

				INFO_PRINTF1(_L("All Events have been read"));

				}

			}

		}

	else

		{

		activeOk=EFalse;

		ERR_PRINTF1(KLogStraySignal);

		SetBlockResult(EFail);

		}

	if ( activeOk )

		{

		if ( !moreToDo )

			{

			DecOutstanding();

			}

		if ( err!=KErrNone )

			{

			ERR_PRINTF2(KLogAsyncError, err);

			SetAsyncError(aIndex, err);

			}

		}

	}

void CT_RConsoleData::DoCancel(CActive* aActive, TInt aIndex)

 /**

 * Called on cancellation of an asynchronous command

 * @param               aActive Active Object that RunL has been called on

 * @param               aIndex number of the command.

 */

	{

	TBool	activeOk=ETrue;

	TInt	err=KErrNone;

	if ( aActive==iActiveRConsoleRead )

		{

		INFO_PRINTF1(_L("ReadCancel Called"));

		iActiveRConsoleRead->KillTimer();

		iConsole->ReadCancel();

		err=aActive->iStatus.Int();

		}

	else

		{

		activeOk=EFalse;

		ERR_PRINTF1(KLogStraySignal);

		SetBlockResult(EFail);

		}

	if ( activeOk )

		{

		DecOutstanding();

	 	if( err != KErrNone )

            {

            ERR_PRINTF2(_L("DoCancel Error %d"), err);

            SetAsyncError( aIndex, err );

            }

		}

	}