/*
* Copyright (c) 2007 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: Class definition of CDiagExecPlanEntryImplSuite
*
*/
// CLASS DECLARATION
#include "diagexecplanentryimplsuite.h"
// SYSTEM INCLUDE FILES
#include <DiagPlugin.h> // MDiagPlugin
#include <DiagSuitePlugin.h> // MDiagSuitePlugin
#include <DiagFrameworkDebug.h> // LOGSTRING
#include <DiagSuiteExecParam.h> // TDiagSuiteExecParam
// USER INCLUDE FILES
#include "diagframework.pan" // Panics
#include "diagexecplanentryimplobserver.h" // MDiagExecPlanEntryImplObserver
// DATA
// MACROS
// LOCAL DATA TYPES
// ======== LOCAL FUNCTIONS ========
// ======== MEMBER FUNCTIONS ========
// ---------------------------------------------------------------------------
// CDiagExecPlanEntryImplSuite::NewL
// ---------------------------------------------------------------------------
//
CDiagExecPlanEntryImplSuite* CDiagExecPlanEntryImplSuite::NewL(
MDiagEngineCommon& aEngine,
const TDiagEngineConfig& aEngineConfig,
MDiagExecPlanEntryImplObserver& aObserver,
MDiagSuitePlugin& aPlugin,
TBool aAsDependency,
CDiagExecPlanEntryImpl::TType aType )
{
CDiagExecPlanEntryImplSuite* self = NewLC( aEngine,
aEngineConfig,
aObserver,
aPlugin,
aAsDependency,
aType );
CleanupStack::Pop( self );
return self;
}
// ---------------------------------------------------------------------------
// CDiagExecPlanEntryImplSuite::NewLC
// ---------------------------------------------------------------------------
//
CDiagExecPlanEntryImplSuite* CDiagExecPlanEntryImplSuite::NewLC(
MDiagEngineCommon& aEngine,
const TDiagEngineConfig& aEngineConfig,
MDiagExecPlanEntryImplObserver& aObserver,
MDiagSuitePlugin& aPlugin,
TBool aAsDependency,
CDiagExecPlanEntryImpl::TType aType )
{
CDiagExecPlanEntryImplSuite* self =
new ( ELeave ) CDiagExecPlanEntryImplSuite ( aEngine,
aEngineConfig,
aObserver,
aPlugin,
aAsDependency,
aType );
CleanupStack::PushL( self );
return self;
}
// ---------------------------------------------------------------------------
// CDiagExecPlanEntryImplSuite::CDiagExecPlanEntryImplSuite
// ---------------------------------------------------------------------------
//
CDiagExecPlanEntryImplSuite::CDiagExecPlanEntryImplSuite(
MDiagEngineCommon& aEngine,
const TDiagEngineConfig& aEngineConfig,
MDiagExecPlanEntryImplObserver& aObserver,
MDiagSuitePlugin& aPlugin,
TBool aAsDependency,
CDiagExecPlanEntryImpl::TType aType )
: CDiagExecPlanEntryImpl(
aEngine,
aEngineConfig,
aObserver,
aPlugin,
aAsDependency,
aType )
{
}
// ---------------------------------------------------------------------------
// CDiagExecPlanEntryImplSuite::~CDiagExecPlanEntryImplSuite
// ---------------------------------------------------------------------------
//
CDiagExecPlanEntryImplSuite::~CDiagExecPlanEntryImplSuite()
{
Cancel();
if ( CDiagExecPlanEntryImpl::State() == EStateRunning )
{
TRAP_IGNORE( SuitePlugin().ExecutionStopL( MDiagSuitePlugin::ESkip ) )
}
}
// ---------------------------------------------------------------------------
// CDiagExecPlanEntryImplSuite::SuitePlugin
// ---------------------------------------------------------------------------
//
MDiagSuitePlugin& CDiagExecPlanEntryImplSuite::SuitePlugin()
{
// It is safe to typecast here, since CDiagExecPlanEntryImplSuite::NewL
// accepts only MDiagSuitePlugin&.
return static_cast< MDiagSuitePlugin& >( Plugin() );
}
// ---------------------------------------------------------------------------
// From CDiagExecPlanEntryImpl
// CDiagExecPlanEntryImplSuite::ExecuteL
// ---------------------------------------------------------------------------
//
void CDiagExecPlanEntryImplSuite::ExecuteL()
{
#ifdef _DEBUG
HBufC* pluginName = Plugin().GetPluginNameL(
MDiagPlugin::ENameLayoutListSingle );
LOGSTRING4( "---- SUITE BEGIN ---- [ 0x%08x %S / %s ] ---- SUITE BEGIN ---- {",
Plugin().Uid().iUid,
pluginName,
( Type() == ETypeSuitePrepare ) ? L"PREPARE" : L"FINALIZE" )
delete pluginName;
pluginName = NULL;
#endif // _DEBUG
__ASSERT_DEBUG( State() == EStateQueued,
Panic( EDiagFrameworkCorruptStateMachine ) );
ResetWatchdog( EDiagEngineWatchdogTypeAutomatic );
ChangeStateL( EStateRunning );
// Notify observer that progress is 0 of 1 since suite does not have progress.
Observer().ExecPlanEntryProgressL( *this, 0, 1 );
TDiagSuiteExecParam* execParam = new ( ELeave ) TDiagSuiteExecParam( *this, Engine() );
if ( Type() == CDiagExecPlanEntryImpl::ETypeSuitePrepare )
{
SuitePlugin().PrepareChildrenExecutionL( execParam, // owership change
Engine().IsDependencyDisabled(),
AsDependency() );
}
else
{
SuitePlugin().FinalizeChildrenExecutionL( execParam, // owership change
Engine().IsDependencyDisabled(),
AsDependency() );
}
execParam = NULL; //lint !e423 execParam ownership changed.
}
// ---------------------------------------------------------------------------
// From CDiagExecPlanEntryImpl
// CDiagExecPlanEntryImplSuite::StopExecutionByWatchdogL
// ---------------------------------------------------------------------------
//
void CDiagExecPlanEntryImplSuite::StopExecutionByWatchdogL()
{
StopSuitePluginL( MDiagSuitePlugin::EWatchdog );
}
// ---------------------------------------------------------------------------
// From CDiagExecPlanEntryImpl
// CDiagExecPlanEntryImplSuite::StopExecutionByClientL
// ---------------------------------------------------------------------------
//
void CDiagExecPlanEntryImplSuite::DoStopExecutionByClientL(
MDiagEngineCommon::TCancelMode aCancelMode )
{
MDiagSuitePlugin::TStopReason stopReason;
switch ( aCancelMode )
{
case MDiagEngineCommon::ECancelAll:
stopReason = MDiagSuitePlugin::ECancelAll;
break;
case MDiagEngineCommon::ESkip:
stopReason = MDiagSuitePlugin::ESkip;
break;
default:
__ASSERT_DEBUG( 0, Panic( EDiagFrameworkInternal ) );
stopReason = MDiagSuitePlugin::ESkip;
break;
}
StopSuitePluginL( stopReason );
}
// ---------------------------------------------------------------------------
// CDiagExecPlanEntryImplSuite::StopSuitePluginL
// ---------------------------------------------------------------------------
//
void CDiagExecPlanEntryImplSuite::StopSuitePluginL(
MDiagSuitePlugin::TStopReason aStopReason )
{
LOGSTRING3( "CDiagExecPlanEntryImplSuite::StopSuitePluginL(): "
L"Calling plugin uid = 0x%08x SuitePlugin::ExecutionStopL( %d )",
Plugin().Uid().iUid,
aStopReason )
Cancel();
switch ( State() )
{
case EStateQueued: // fall through
case EStateInitDelay: // fall through
case EStateStopped: // fall through
case EStateSuspended: // fall through
case EStateCompleted:
LOGSTRING3( "CDiagExecPlanEntryImplSuite::DoStopSuitePluginL(): "
L"Plugin 0x%08x = %d. Do nothing.",
Plugin().Uid().iUid,
State() )
break;
case EStateRunning:
LOGSTRING2( "CDiagExecPlanEntryImplSuite::DoStopSuitePluginL(): "
L"Plugin 0x%08x was in ERunning or ESuspended. Call Stop",
Plugin().Uid().iUid )
SuitePlugin().ExecutionStopL( aStopReason );
break;
default:
LOGSTRING3( "CDiagExecPlanEntryImplSuite::DoStopSuitePluginL(): "
L"Plugin 0x%08x = INVALID STATE! %d",
Plugin().Uid().iUid,
State() )
__ASSERT_DEBUG( 0, Panic( EDiagFrameworkCorruptStateMachine ) );
break;
}
// Notify observer as if plug-in itself would have done.
ContinueExecutionL( SuitePlugin() );
}
// ---------------------------------------------------------------------------
// CDiagExecPlanEntryImplSuite::SuspendL
// ---------------------------------------------------------------------------
//
void CDiagExecPlanEntryImplSuite::SuspendL()
{
Cancel();
switch ( State() )
{
case EStateQueued: // fall through
case EStateInitDelay: // fall through
LOGSTRING3( "CDiagExecPlanEntryImplSuite::SuspendL(): "
L"Plugin 0x%08x = %d. Reset to Queued state",
Plugin().Uid().iUid,
State() )
// force reset the execution state to queued so that
// it will be restarted
ChangeStateL( EStateQueued );
break;
case EStateRunning:
LOGSTRING2( "CDiagExecPlanEntryImplSuite::SuspendL(): "
L"Plugin 0x%08x was in ERunning. Calling Stop",
Plugin().Uid().iUid )
// Suites do not have suspend. Stop with cancel as reason.
SuitePlugin().ExecutionStopL( MDiagSuitePlugin::ESkip );
// force reset the plugin execution to queued so that
// it will be restarted
ChangeStateL( EStateQueued );
break;
case EStateStopped:
LOGSTRING2( "CDiagExecPlanEntryImplSuite::SuspendL(): "
L"Plugin 0x%08x = Stopped.",
Plugin().Uid().iUid )
// plug-in is already stopped.
ChangeStateL( EStateSuspended );
break;
case EStateSuspended:
LOGSTRING2( "CDiagExecPlanEntryImplSuite::SuspendL(): "
L"Plugin 0x%08x = Suspended.",
Plugin().Uid().iUid )
// already suspneded. nothing to do.
break;
case EStateCompleted:
LOGSTRING2( "CDiagExecPlanEntryImplSuite::SuspendL(): "
L"Plugin 0x%08x was already in completed state. No change",
Plugin().Uid().iUid )
break;
default:
LOGSTRING3( "CDiagExecPlanEntryImplSuite::SuspendL(): "
L"Plugin 0x%08x = INVALID STATE! %d",
Plugin().Uid().iUid,
State() )
__ASSERT_DEBUG( 0, Panic( EDiagFrameworkCorruptStateMachine ) );
break;
}
// Postcondition. Check acceptble states.
__ASSERT_DEBUG( State() == EStateQueued ||
State() == EStateSuspended ||
State() == EStateCompleted,
Panic( EDiagFrameworkCorruptStateMachine ) );
}
// ---------------------------------------------------------------------------
// CDiagExecPlanEntryImplSuite::ResumeL
// ---------------------------------------------------------------------------
//
void CDiagExecPlanEntryImplSuite::ResumeL()
{
LOGSTRING3( "CDiagExecPlanEntryImplTest::ResumeL(): "
L"Plugin 0x%08x, State = %d", Plugin().Uid().iUid, State() )
__ASSERT_DEBUG( State() == EStateQueued ||
State() == EStateSuspended,
Panic( EDiagFrameworkCorruptStateMachine ) );
if ( State() == EStateQueued )
{
ExecuteL();
}
else
{
ContinueExecutionL( SuitePlugin() );
}
}
// ---------------------------------------------------------------------------
// From MDiagSuiteObserver
// CDiagExecPlanEntryImplSuite::ContinueExecutionL
// ---------------------------------------------------------------------------
//
void CDiagExecPlanEntryImplSuite::ContinueExecutionL( const MDiagSuitePlugin& aSender )
{
__ASSERT_ALWAYS( aSender.Uid() == Plugin().Uid(), Panic( EDiagFrameworkPlugin ) );
// Need to do an empty request complete since by default, suite plug-ins
// do nothing in prepare/finalize steps and just call ContinueExecutionL.
// Doing empty request complete ensures that Plug-in call back does not
// directly call application TestExecutionCompletedL() method.
ChangeStateL( EStateStopped );
TRequestStatus* status = &iStatus;
User::RequestComplete( status, KErrNone );
SetActive();
}
// ---------------------------------------------------------------------------
// From CActive
// CDiagExecPlanEntryImplSuite::RunL
// ---------------------------------------------------------------------------
//
void CDiagExecPlanEntryImplSuite::RunL()
{
ChangeStateL( EStateCompleted );
#ifdef _DEBUG
HBufC* pluginName = Plugin().GetPluginNameL(
MDiagPlugin::ENameLayoutListSingle );
LOGSTRING4( "} ---- SUITE END ---- [ 0x%08x %S / %s ] ---- SUITE END ----",
Plugin().Uid().iUid,
pluginName,
( Type() == ETypeSuitePrepare ) ? L"PREPARE" : L"FINALIZE" )
delete pluginName;
pluginName = NULL;
#endif // _DEBUG
Observer().ExecPlanEntryExecutedL( *this );
}
// ---------------------------------------------------------------------------
// From CActive
// CDiagExecPlanEntryImplSuite::DoCancel
// ---------------------------------------------------------------------------
//
void CDiagExecPlanEntryImplSuite::DoCancel()
{
// nothing to do
}
// End of File