diff -r 000000000000 -r cec860690d41 haitest/bspsvs/suite/e32/src/T_RConsoleData.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/haitest/bspsvs/suite/e32/src/T_RConsoleData.cpp Tue Feb 02 01:39:10 2010 +0200 @@ -0,0 +1,416 @@ +/* +* 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 ); + } + } + + }