--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uiacceltk/hitchcock/tsrc/alfperfapp/src/alfperfapptestcaseexecutionview.cpp Tue Feb 02 07:56:43 2010 +0200
@@ -0,0 +1,1000 @@
+/*
+* Copyright (c) 2008 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: CAlfPerfAppTestCaseExecutionView implementation.
+ *
+*/
+
+
+#include <aknutils.h>
+#include <aknviewappui.h>
+#include <alfperfapp.rsg>
+#include <alf/alfenv.h>
+#include <hal.h>
+#include "alfperfapptestcaseexecutionview.h"
+#include "alfperfappconstants.h"
+#include "alfperfapptestcasefactory.h"
+#include "alfperfapptestcase.h"
+#include "alfperfappmodel.h"
+
+#include "../../alfdebugextension/inc/alfdebug.h"
+
+/**
+ * Client-server interface for daemon.
+ */
+class RAlfPerfAppDaemon : public RApaAppServiceBase
+ {
+public:
+ /**
+ * Constructor.
+ */
+ RAlfPerfAppDaemon();
+
+ /**
+ * Connects to daemon.
+ * @return error code, KErrNone upon success.
+ */
+ TInt Connect();
+
+ /**
+ * Gets measurements.
+ * @param aMeasurements this will contain measurements.
+ * @return error code.
+ */
+ TInt GetMeasurements( TAlfDebugServerMeasurements& aMeasurements );
+
+ /**
+ * Enables activity polling.
+ * @param aEnable ETrue if enabled, EFalse if disabled.
+ * @return error code.
+ */
+ TInt EnableActivityPoll( TBool aEnable );
+
+private:
+ /**
+ * From RApaAppServiceBase, returns service UID.
+ * @return service UID.
+ */
+ virtual TUid ServiceUid() const;
+ };
+
+/**
+ * CAlfPerfAppTestCaseExecutionView::CContainer container class.
+ */
+class CAlfPerfAppTestCaseExecutionView::CContainer : public CCoeControl
+ {
+ public:
+
+ CContainer( CAlfPerfAppTestCaseExecutionView& aView );
+ void ConstructL();
+ ~CContainer();
+
+ // From base class CCoeControl
+ virtual TKeyResponse OfferKeyEventL(
+ const TKeyEvent& aKeyEvent, TEventCode aType );
+ virtual void HandleResourceChange( TInt aType );
+ virtual void Draw(const TRect& aRect) const;
+
+ private:
+ /**
+ * Reference to execution view.
+ * Now owned.
+ */
+ CAlfPerfAppTestCaseExecutionView& iView;
+ };
+
+/**
+ * Active object to execute test cases.
+ */
+class CAlfPerfAppTestCaseExecutionView::CActiveExecuter
+: public CActive, private MAlfPerfAppTestCaseInterface
+ {
+ public:
+ CActiveExecuter(
+ CAlfPerfAppTestCaseExecutionView& aView,
+ CAlfPerfAppTestCaseFactory& aFactory,
+ CAlfPerfAppModel& aModel,
+ RAlfPerfAppDaemon& aDaemon,
+ TBool aUseContinuousRun = EFalse);
+ ~CActiveExecuter();
+
+ /**
+ * Starts executing test cases.
+ */
+ void StartNextCase();
+
+ /**
+ * Sets visible area.
+ * @param aRect new visible area.
+ */
+ void SetVisibleArea( const TRect& aRect );
+
+ /**
+ * Ends the continuous run if it was on, otherwise does nothing.
+ */
+ void EndContinuousRun();
+
+ private:
+
+ // From base class CActive
+ virtual void RunL();
+ virtual void DoCancel();
+ virtual TInt RunError( TInt aError );
+
+ // From base class MAlfPerfAppTestCaseInterface
+ virtual void MeasureNow();
+
+ private:
+
+ /**
+ * Gets next test case.
+ * @return ETrue if test case received ok.
+ */
+ TBool GetNextTestCaseL();
+
+ /**
+ * Reports error. Calls DoReportErrorL in TRAP harness.
+ * @param aErrorCode error code.
+ */
+ void ReportError( TInt aErrorCode );
+
+ /**
+ * Reports error to model.
+ * @param aErrorCode error code.
+ */
+ void DoReportErrorL( TInt aErrorCode );
+
+ /**
+ * Reports error and continues to next case.
+ * @param aErrorCode error code.
+ */
+ void ReportErrorAndContinue( TInt aErrorCode );
+
+ /**
+ * Resets current state.
+ */
+ void Reset( TBool aOkToCallObserver );
+
+ /**
+ * Completes request status with specified error code.
+ * @param aErrorCode error code.
+ */
+ void CompleteNow( TInt aErrorCode );
+
+ /**
+ * Determine next state based on current state.
+ * It's expected that current state has been completed
+ * successfully.
+ */
+ void DetermineNextState();
+
+ /**
+ * Creates alf environment and initializes
+ * debug extension plugin.
+ */
+ void CreateEnvL();
+
+ /**
+ * Deletes alf environment.
+ */
+ void DeleteEnv();
+
+ /**
+ * Performs measurements.
+ */
+ void PerformMeasurementsL();
+
+ private:
+
+ /**
+ * Reference to execution view.
+ * Not owned.
+ */
+ CAlfPerfAppTestCaseExecutionView& iView;
+
+ /**
+ * Reference to test case factory.
+ * Not owned.
+ */
+ CAlfPerfAppTestCaseFactory& iFactory;
+
+ /**
+ * Reference to model.
+ * Not owned.
+ */
+ CAlfPerfAppModel& iModel;
+
+ /**
+ * Reference to daemon.
+ * Not owned.
+ */
+ RAlfPerfAppDaemon& iDaemon;
+
+ /**
+ * Visible area rect.
+ */
+ TRect iVisibleArea;
+
+ /**
+ * Current test case id.
+ */
+ TInt iCaseId;
+
+ /*
+ * Current cases place in the sequence
+ */
+ TInt iSequenceIndex;
+
+ /**
+ * Enumerates different possibilities for current state.
+ */
+ enum TCurrentState
+ {
+ EStateIdle,
+ EStateCreateTestCase,
+ EStateSetupTestCase,
+ EStateExecuteTestCase,
+ EStateTearDownTestCase
+ };
+
+ /**
+ * Current state.
+ */
+ TCurrentState iCurrentState;
+
+ /**
+ * Alf environment.
+ * Owned.
+ */
+ CAlfEnv* iEnv;
+
+ /**
+ * Current test case under execution.
+ * Owned.
+ */
+ CAlfPerfAppTestCase* iCurrentTestCase;
+
+ /**
+ * NTickCount tick period.
+ */
+ TInt iTickPeriod;
+
+ /**
+ * Tells if the continuous run is enabled.
+ */
+ TBool iContinuousRunOngoing;
+
+ /**
+ * Tells if this is the last case. Used only to end continuous run correctly.
+ */
+ TBool iFinalCase;
+ };
+
+// ============================ MEMBER FUNCTIONS ===============================
+
+CAlfPerfAppTestCaseExecutionView* CAlfPerfAppTestCaseExecutionView::NewLC(
+ CAlfPerfAppModel& aModel )
+ {
+ CAlfPerfAppTestCaseExecutionView* self =
+ new (ELeave) CAlfPerfAppTestCaseExecutionView( aModel );
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ return self;
+ }
+
+CAlfPerfAppTestCaseExecutionView::~CAlfPerfAppTestCaseExecutionView()
+ {
+ delete iExecuter;
+ delete iFactory;
+
+ if ( iDaemon )
+ {
+ iDaemon->Close();
+ delete iDaemon;
+ }
+ }
+
+void CAlfPerfAppTestCaseExecutionView::NotifyLayoutChange(
+ const TRect& aRect )
+ {
+ if ( iExecuter )
+ {
+ iExecuter->SetVisibleArea( aRect );
+ }
+ }
+
+void CAlfPerfAppTestCaseExecutionView::NotifyExecutionCompletedL()
+ {
+ AppUi()->ActivateLocalViewL( KAlfPerfAppTestCaseResultsViewId );
+ }
+
+void CAlfPerfAppTestCaseExecutionView::NotifyTestCaseVisible( TBool aVisible )
+ {
+ if ( iContainer )
+ {
+ if ( iDaemon )
+ {
+ // Call User::ResetInactivityTime periodically if test case
+ // is visible. This ensures that screensaver is not activated
+ // and thus test case execution is not disturbed.
+ (void)iDaemon->EnableActivityPoll( aVisible );
+ }
+
+ iContainer->MakeVisible( !aVisible );
+ }
+ }
+
+CAlfPerfAppTestCaseExecutionView::CAlfPerfAppTestCaseExecutionView(
+ CAlfPerfAppModel& aModel )
+: iModel( aModel )
+ {
+ }
+
+#include <apgcli.h>
+#include <apacmdln.h>
+#include "alfperfapp.hrh"
+
+ static void StartDaemonL()
+ {
+ _LIT( KAlfPerfAppDaemonExe, "alfperfappdaemon.exe" );
+ const TUid KAlfPerfAppDaemonUid = { KAlfPerfAppDaemonUidValue };
+
+ RApaLsSession apa;
+ User::LeaveIfError(apa.Connect());
+ CleanupClosePushL(apa);
+
+ CApaCommandLine* cmdLine = CApaCommandLine::NewLC();
+ cmdLine->SetExecutableNameL( KAlfPerfAppDaemonExe );
+ cmdLine->SetServerRequiredL( KAlfPerfAppDaemonUid.iUid );
+ cmdLine->SetCommandL( EApaCommandBackground );
+ TThreadId dummy;
+
+ TRequestStatus requestStatusForRendezvous;
+ User::LeaveIfError( apa.StartApp(*cmdLine, dummy, &requestStatusForRendezvous) );
+ User::WaitForRequest( requestStatusForRendezvous );
+ User::LeaveIfError( requestStatusForRendezvous.Int() );
+
+ CleanupStack::PopAndDestroy(2, &apa);
+ }
+
+ void CAlfPerfAppTestCaseExecutionView::ConstructL()
+ {
+ BaseConstructL( R_ALFPERFAPP_TEST_CASE_EXECUTION_VIEW );
+ iFactory = CAlfPerfAppTestCaseFactory::NewL();
+
+ iDaemon = new (ELeave) RAlfPerfAppDaemon;
+ TInt err = iDaemon->Connect();
+ if ( err == KErrNotFound )
+ {
+ TRAP( err, StartDaemonL() );
+ if ( err == KErrNone ||
+ err == KErrAlreadyExists )
+ {
+ err = iDaemon->Connect();
+ }
+ }
+ if ( err != KErrNotFound )
+ {
+ User::LeaveIfError( err );
+ }
+ }
+
+ TUid CAlfPerfAppTestCaseExecutionView::Id() const
+ {
+ return KAlfPerfAppTestCaseExecutionViewId;
+ }
+
+ // -----------------------------------------------------------------------------
+ // Handles view activation
+ // -----------------------------------------------------------------------------
+ //
+ void CAlfPerfAppTestCaseExecutionView::DoActivateL(
+ const TVwsViewId& /*aPrevViewId*/,
+ TUid /*aCustomMessageId*/,
+ const TDesC8& aCustomMessage )
+ {
+ CContainer* container = new (ELeave) CContainer( *this );
+ CleanupStack::PushL( container );
+ container->ConstructL();
+ AppUi()->AddToStackL( *this, container );
+ CleanupStack::Pop( container );
+ iContainer = container;
+
+ if(aCustomMessage == _L8("UseContinuousRun"))
+ {
+ // If we should use the continuous run, use it (the ETrue in the end)
+ iExecuter = new (ELeave) CActiveExecuter( *this, *iFactory, iModel, *iDaemon, ETrue );
+ Cba()->SetCommandSetL(R_AVKON_SOFTKEYS_OK_EMPTY);
+ Cba()->DrawDeferred();
+ }
+ else
+ {
+ // If not, then just use the default parameters
+ iExecuter = new (ELeave) CActiveExecuter( *this, *iFactory, iModel, *iDaemon);
+ Cba()->SetCommandSetL(R_AVKON_SOFTKEYS_EMPTY);
+ Cba()->DrawDeferred();
+
+ }
+ iExecuter->SetVisibleArea(
+ TRect( container->Position(), container->Size() ) );
+ iExecuter->StartNextCase();
+ }
+
+ // -----------------------------------------------------------------------------
+ // Handles view deactivation
+ // -----------------------------------------------------------------------------
+ //
+ void CAlfPerfAppTestCaseExecutionView::DoDeactivate()
+ {
+ if ( iContainer )
+ {
+ AppUi()->RemoveFromStack( iContainer );
+ delete iContainer;
+ iContainer = NULL;
+ }
+
+ delete iExecuter;
+ iExecuter = NULL;
+ }
+
+ // -----------------------------------------------------------------------------
+ // Handles test case selection view specific commands.
+ // -----------------------------------------------------------------------------
+ //
+ void CAlfPerfAppTestCaseExecutionView::HandleCommandL( TInt aCommand )
+ {
+ if(aCommand == EAknSoftkeyOk) // For some reason, switch didn't catch this
+ {
+ iExecuter->EndContinuousRun();
+ return;
+ }
+ switch ( aCommand )
+ {
+ default:
+ AppUi()->HandleCommandL( aCommand );
+ break;
+ }
+ }
+
+ //
+ // Implementation of CAlfPerfAppTestCaseExecutionView::CContainer:
+ //
+
+ CAlfPerfAppTestCaseExecutionView::CContainer::CContainer(
+ CAlfPerfAppTestCaseExecutionView& aView )
+ : iView( aView )
+ {
+ }
+
+ void CAlfPerfAppTestCaseExecutionView::CContainer::ConstructL()
+ {
+ CreateWindowL();
+
+ TRect rect;
+ AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, rect );
+ SetRect( rect );
+
+ ActivateL();
+ }
+
+ CAlfPerfAppTestCaseExecutionView::CContainer::~CContainer()
+ {
+ }
+
+
+
+ TKeyResponse CAlfPerfAppTestCaseExecutionView::CContainer::OfferKeyEventL(
+ const TKeyEvent& /*aKeyEvent*/, TEventCode /*aType*/ )
+ {
+ TKeyResponse resp = EKeyWasNotConsumed;
+ if ( IsVisible() )
+ {
+ resp = EKeyWasConsumed;
+ }
+ return resp;
+ }
+
+ void CAlfPerfAppTestCaseExecutionView::CContainer::HandleResourceChange( TInt aType )
+ {
+ CCoeControl::HandleResourceChange( aType );
+
+ if ( aType == KEikDynamicLayoutVariantSwitch )
+ {
+ TRect rect;
+ AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, rect );
+ SetRect( rect );
+
+ iView.NotifyLayoutChange( rect );
+ }
+ }
+
+ void CAlfPerfAppTestCaseExecutionView::CContainer::Draw(
+ const TRect& /*aRect*/ ) const
+ {
+ CWindowGc& gc = SystemGc();
+ gc.SetPenStyle( CGraphicsContext::ENullPen );
+ gc.SetBrushStyle( CGraphicsContext::ESolidBrush );
+ gc.SetBrushColor( TRgb( 128, 0, 0 ) ); // red color
+ gc.DrawRect( Rect() );
+ gc.SetBrushStyle( CGraphicsContext::ENullBrush );
+ }
+
+ //
+ // Implementation of CAlfPerfAppTestCaseExecutionView::CActiveExecuter:
+ //
+ CAlfPerfAppTestCaseExecutionView::CActiveExecuter::CActiveExecuter(
+ CAlfPerfAppTestCaseExecutionView& aView,
+ CAlfPerfAppTestCaseFactory& aFactory,
+ CAlfPerfAppModel& aModel,
+ RAlfPerfAppDaemon& aDaemon,
+ TBool aUseContinuousRun)
+ : CActive( CActive::EPriorityHigh ),
+ iView( aView ),
+ iFactory( aFactory ),
+ iModel( aModel ),
+ iDaemon( aDaemon ),
+ iCurrentState( EStateIdle ),
+ iContinuousRunOngoing( aUseContinuousRun ),
+ iFinalCase(EFalse),
+ iSequenceIndex(0)
+ {
+ CActiveScheduler::Add( this );
+
+ TInt err = HAL::Get( HAL::ENanoTickPeriod, iTickPeriod );
+ if ( err != KErrNone )
+ {
+ iTickPeriod = 1000; // assume 1ms
+ }
+ }
+
+ CAlfPerfAppTestCaseExecutionView::CActiveExecuter::~CActiveExecuter()
+ {
+ Reset( EFalse ); // calls Cancel()
+ }
+
+ void CAlfPerfAppTestCaseExecutionView::CActiveExecuter::StartNextCase()
+ {
+ Reset( ETrue ); // reset sets current state to idle
+
+ CompleteNow( KErrNone );
+ SetActive();
+ }
+
+ void CAlfPerfAppTestCaseExecutionView::CActiveExecuter::SetVisibleArea(
+ const TRect& aRect )
+ {
+ iVisibleArea = aRect;
+
+ if ( iCurrentTestCase )
+ {
+ iCurrentTestCase->HandleVisibleAreaChange( aRect );
+ }
+ }
+
+ void CAlfPerfAppTestCaseExecutionView::CActiveExecuter::EndContinuousRun()
+ {
+ if(iContinuousRunOngoing)
+ {
+ iFinalCase = ETrue;
+ }
+
+ iContinuousRunOngoing = EFalse;
+ }
+
+ void CAlfPerfAppTestCaseExecutionView::CActiveExecuter::RunL()
+ {
+ const TInt errorCode = iStatus.Int();
+
+ if ( errorCode != KErrNone )
+ {
+ // If current test step failed, report and continue to next
+ // test case.
+ __ASSERT_ALWAYS( iCurrentState != EStateIdle, User::Invariant() );
+ ReportErrorAndContinue( errorCode );
+ return;
+ }
+
+ if ( iCurrentState == EStateIdle )
+ {
+ // When current state is idle and RunL is reached,
+ // it's time to take next case from queue and start
+ // execution.
+ if ( iFinalCase || !GetNextTestCaseL())
+ {
+ // No more test cases - stop.
+ iView.NotifyExecutionCompletedL();
+ return;
+ }
+ }
+
+ if(iCurrentTestCase && iContinuousRunOngoing && iCurrentState == EStateExecuteTestCase)
+ {
+ TInt CaseID = iCurrentTestCase->CaseID();
+ iModel.AddToExecuteArrayL(CaseID);
+ }
+
+ // Perform measurements before switching to next state
+ switch ( iCurrentState )
+ {
+ case EStateSetupTestCase:
+ case EStateExecuteTestCase:
+ // Going to execution or teardown phase.
+ PerformMeasurementsL();
+ break;
+ case EStateCreateTestCase:
+ case EStateTearDownTestCase:
+ case EStateIdle:
+ default:
+ // Either these do not contain any activity or
+ // then it's performed synchronously.
+ break;
+ }
+
+ DetermineNextState();
+
+ // Execute according to current state
+ switch ( iCurrentState )
+ {
+ case EStateCreateTestCase:
+ __ASSERT_ALWAYS( !iCurrentTestCase, User::Invariant() );
+ iCurrentTestCase = iFactory.CreateL( iCaseId, iSequenceIndex);
+
+ iStatus = KRequestPending;
+ CompleteNow( KErrNone );
+ SetActive();
+ break;
+
+ case EStateSetupTestCase:
+ __ASSERT_ALWAYS( iCurrentTestCase, User::Invariant() );
+ // Make sure test case is visible.
+ // NotifyTestCaseVisible is called with EFalse in Reset().
+ iView.NotifyTestCaseVisible( ETrue );
+
+ PerformMeasurementsL();
+ CreateEnvL();
+
+ iStatus = KRequestPending;
+ iCurrentTestCase->SetInterface( this );
+ iCurrentTestCase->SetupL( *iEnv, iVisibleArea, iStatus );
+ SetActive();
+ break;
+
+ case EStateExecuteTestCase:
+ __ASSERT_ALWAYS( iCurrentTestCase, User::Invariant() );
+ PerformMeasurementsL();
+
+ iStatus = KRequestPending;
+ iCurrentTestCase->ExecuteL( iStatus );
+ SetActive();
+ break;
+
+ case EStateTearDownTestCase:
+ __ASSERT_ALWAYS( iCurrentTestCase, User::Invariant() );
+ PerformMeasurementsL();
+
+ iCurrentTestCase->TearDown();
+
+ PerformMeasurementsL();
+
+ // Perform some reset actions. Cancel() is not
+ // needed, because we are in RunL method.
+ iCurrentTestCase->SetInterface( NULL );
+ delete iCurrentTestCase;
+ iCurrentTestCase = NULL;
+ DeleteEnv();
+
+
+ Reset( ETrue );
+
+ iStatus = KRequestPending;
+ CompleteNow( KErrNone );
+ SetActive();
+ break;
+
+ case EStateIdle:
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ void CAlfPerfAppTestCaseExecutionView::CActiveExecuter::DoCancel()
+ {
+ delete iCurrentTestCase;
+ iCurrentTestCase = NULL;
+ }
+
+ TInt CAlfPerfAppTestCaseExecutionView::CActiveExecuter::RunError(
+ TInt aError )
+ {
+ if ( iCurrentState != EStateIdle )
+ {
+ if(iCurrentTestCase)
+ {
+ iCurrentTestCase->TearDown();
+ iCurrentTestCase->SetInterface( NULL );
+ }
+ ReportErrorAndContinue( aError );
+ }
+
+ return KErrNone;
+ }
+
+ void CAlfPerfAppTestCaseExecutionView::CActiveExecuter::MeasureNow()
+ {
+ TRAP_IGNORE( PerformMeasurementsL() );
+ }
+
+ TBool CAlfPerfAppTestCaseExecutionView::CActiveExecuter::GetNextTestCaseL()
+ {
+ TBool casesLeft = iModel.GetFromExecuteArray( iCaseId );
+
+ if(casesLeft)
+ {
+ if(iCaseId < 0)
+ {
+ iSequenceIndex++;
+ }
+ else
+ {
+ iSequenceIndex = 1;
+ }
+ }
+
+ return casesLeft;
+ }
+
+ void CAlfPerfAppTestCaseExecutionView::CActiveExecuter::ReportError(
+ TInt aErrorCode )
+ {
+ TRAP_IGNORE( DoReportErrorL( aErrorCode ) );
+ }
+
+ void CAlfPerfAppTestCaseExecutionView::CActiveExecuter::DoReportErrorL(
+ TInt aErrorCode )
+ {
+ _LIT( KAlfPerfAppErrorMessage, "0x%x failed with %d (state:%d)" );
+ HBufC* messageBuffer = HBufC::NewLC( 128 );
+
+ messageBuffer->Des().Format(
+ KAlfPerfAppErrorMessage,
+ iCaseId,
+ aErrorCode,
+ iCurrentState );
+
+ iModel.AddToErrorArrayL( *messageBuffer );
+ CleanupStack::PopAndDestroy( messageBuffer );
+ }
+
+ void CAlfPerfAppTestCaseExecutionView::CActiveExecuter::ReportErrorAndContinue(
+ TInt aErrorCode )
+ {
+ ReportError( aErrorCode );
+ StartNextCase();
+ }
+
+ void CAlfPerfAppTestCaseExecutionView::CActiveExecuter::Reset(
+ TBool aOkToCallObserver )
+ {
+ Cancel();
+
+ delete iCurrentTestCase;
+ iCurrentTestCase = NULL;
+
+ DeleteEnv();
+
+ iCaseId = 0;
+ iCurrentState = EStateIdle;
+
+ if ( aOkToCallObserver )
+ {
+ iView.NotifyTestCaseVisible( EFalse );
+ }
+ }
+
+ void CAlfPerfAppTestCaseExecutionView::CActiveExecuter::CompleteNow(
+ TInt aErrorCode )
+ {
+ TRequestStatus* status = &iStatus;
+ User::RequestComplete( status, aErrorCode );
+ }
+
+ void CAlfPerfAppTestCaseExecutionView::CActiveExecuter::DetermineNextState()
+ {
+ // Determine next state after step has been completed.
+ switch ( iCurrentState )
+ {
+ case EStateIdle:
+ iCurrentState = EStateCreateTestCase;
+ break;
+
+ case EStateCreateTestCase:
+ iCurrentState = EStateSetupTestCase;
+ break;
+
+ case EStateSetupTestCase:
+ iCurrentState = EStateExecuteTestCase;
+ break;
+
+ case EStateExecuteTestCase:
+ iCurrentState = EStateTearDownTestCase;
+ break;
+
+ case EStateTearDownTestCase:
+ iCurrentState = EStateIdle;
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ void CAlfPerfAppTestCaseExecutionView::CActiveExecuter::CreateEnvL()
+ {
+ __ASSERT_ALWAYS( !iEnv, User::Invariant() );
+ iEnv = CAlfEnv::NewL();
+ iEnv->SetMaxFrameRate(100);
+ }
+
+ void CAlfPerfAppTestCaseExecutionView::CActiveExecuter::DeleteEnv()
+ {
+ delete iEnv;
+ iEnv = NULL;
+ }
+
+ void CAlfPerfAppTestCaseExecutionView::CActiveExecuter::PerformMeasurementsL()
+ {
+ CAlfPerfAppModel::TTestCaseResultItem item;
+
+ // Test case identifiers
+ item.iCaseId = iCaseId;
+
+ // Phase (0 = setup, 1 = execution, 2 = teardown)
+ switch ( iCurrentState )
+ {
+ case EStateIdle:
+ case EStateCreateTestCase:
+ case EStateSetupTestCase:
+ item.iPhase = 0;
+ break;
+
+ case EStateExecuteTestCase:
+ item.iPhase = 1;
+ break;
+
+ case EStateTearDownTestCase:
+ item.iPhase = 2;
+ break;
+
+ default:
+ item.iPhase = -1;
+ break;
+ }
+
+ TInt dummy; // not used.
+
+ // Amount of cells allocated in Application heap.
+ // Total size taken by allocated cells in Application heap.
+ // Amount of free space in Application heap.
+ item.iAppCells = User::AllocSize( item.iAppMemory );
+ item.iAppFree = User::Available( dummy );
+
+ // Perform server side measurements
+ TAlfDebugServerMeasurements serverMeasurements;
+ TBool measureOk =
+ ( iDaemon.GetMeasurements( serverMeasurements ) == KErrNone );
+
+ if ( !measureOk )
+ {
+ serverMeasurements.iTimeStamp = User::NTickCount();
+ serverMeasurements.iServerCells = 0;
+ serverMeasurements.iServerMemory = 0;
+ serverMeasurements.iServerFree = 0;
+ serverMeasurements.iFrameCount = 0;
+ }
+
+ // Convert timestamps to ms
+ if ( iTickPeriod != 1000 )
+ {
+ TUint64 stamp = serverMeasurements.iTimeStamp;
+ stamp *= iTickPeriod;
+ stamp /= 1000;
+ stamp &= 0xFFFFFFFF; // modulo 2**32
+ serverMeasurements.iTimeStamp = I64LOW( stamp );
+ }
+
+
+ // Amount of cells allocated in Server heap.
+ // Total size taken by allocated cells in Server heap.
+ // Amount of free space in Server heap.
+ // Time stamp (preferably from server side)
+ // Frame count
+ item.iTimeStamp = serverMeasurements.iTimeStamp;
+ item.iServerCells = serverMeasurements.iServerCells;
+ item.iServerMemory = serverMeasurements.iServerMemory;
+ item.iServerFree = serverMeasurements.iServerFree;
+ item.iFrameCount = serverMeasurements.iFrameCount;
+
+ // Amount of free memory in the system.
+ // Memory consumption of the system.
+ TInt systemFreeRam = 0;
+ HAL::Get( HALData::EMemoryRAMFree, systemFreeRam );
+ TInt systemTotalRam = 0;
+ HAL::Get( HALData::EMemoryRAM, systemTotalRam );
+ item.iSystemMemory = systemTotalRam - systemFreeRam;
+ item.iSystemFree = systemFreeRam;
+
+ TTestCaseSpecificResultText specificResult = 0;
+ specificResult = iCurrentTestCase->getCaseSpecificResultL();
+ if(specificResult)
+ {
+ item.specificResult8.Copy(specificResult->Des());
+ delete specificResult;
+ }
+
+ // Append to model
+ iModel.AddToResultFilesL( item );
+ }
+
+ //
+ // Implementation of RAlfPerfAppDaemon
+ //
+
+ RAlfPerfAppDaemon::RAlfPerfAppDaemon()
+ {
+ }
+
+ TInt RAlfPerfAppDaemon::Connect()
+ {
+ TInt result = KErrNone;
+ if ( !Handle() )
+ {
+ _LIT(KServerNameFormat, "%08x_%08x_AppServer");
+ TFullName serverName;
+ serverName.Format(
+ KServerNameFormat,
+ KAlfPerfAppDaemonUidValue,
+ KAlfPerfAppDaemonUidValue );
+ TRAP( result, ConnectExistingByNameL( serverName ) );
+ }
+ return result;
+ }
+
+ TInt RAlfPerfAppDaemon::GetMeasurements(
+ TAlfDebugServerMeasurements& aMeasurements )
+ {
+ if ( !Handle() )
+ {
+ return KErrNotSupported;
+ }
+
+ TPckg<TAlfDebugServerMeasurements> pckg( aMeasurements );
+ return SendReceive( EAlfPerfAppIpcGetMeasurements, TIpcArgs( &pckg ) );
+ }
+
+ TInt RAlfPerfAppDaemon::EnableActivityPoll( TBool aEnable )
+ {
+ if ( !Handle() )
+ {
+ return KErrNotSupported;
+ }
+
+ return SendReceive( EAlfPerfAppIpcEnableActivityPoll, TIpcArgs( aEnable ? 1 : 0 ) );
+ }
+
+ TUid RAlfPerfAppDaemon::ServiceUid() const
+ {
+ return TUid::Uid( KAlfPerfAppDaemonUidValue );
+ }
+