/*

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

*

*/

// CLASS DECLARATION

#include <DiagTestPluginBase.h>

// SYSTEM INCLUDE FILES

#include <coemain.h>                        // CCoeEnv::Static()

#include <DiagTestExecParam.h>              // TDiagTestExecParam

#include <DiagResultsDbItemBuilder.h>       // CDiagResultsDbItemBuilder

#include <DiagTestObserver.h>               // MDiagTestObserver

#include <DiagPluginConstructionParam.h>    // CDiagPluginConstructionParam

#include <DiagFrameworkDebug.h>             // LOGSTRING

#include <DiagResultDetailBasic.h>          // CDiagResultDetailBasic

#include <DiagEngineCommon.h>               // MDiagEngineCommon

#include <DiagPluginPool.h>                 // CDiagPluginPool

#include <DiagResultsDatabase.h>            // RDiagResultsDatabase

#include <DiagPluginWaitingDialogWrapper.h> // CDiagPluginWaitingDialogWrapper

#include <DiagPluginExecPlan.h>             // MDiagPluginExecPlan

#include <DiagSuitePlugin.h>                // MDiagSuitePlugin

// ADO & Platformization Changes

#include <avkon.hrh>						// EAknSoftkeyYes

// USER INCLUDE FILES

#include "diagpluginbaseutils.h"            // DiagPluginBaseUtils

#include "diagpluginbase.pan"               // Panic Codes

// CONSTANTS

// priority of result value. Entries that are earlier have higher priority

static const CDiagResultsDatabaseItem::TResult KResultPriority[] = 

    {

    CDiagResultsDatabaseItem::EQueuedToRun,

    CDiagResultsDatabaseItem::EDependencyFailed,

    CDiagResultsDatabaseItem::EFailed,       

    CDiagResultsDatabaseItem::ECancelled,    

    CDiagResultsDatabaseItem::ESkipped,      

    CDiagResultsDatabaseItem::EInterrupted,  

    CDiagResultsDatabaseItem::EWatchdogCancel,

    CDiagResultsDatabaseItem::ENotPerformed, 

    CDiagResultsDatabaseItem::ESuspended,    

    CDiagResultsDatabaseItem::ESuccess

    };

static const TInt KResultPriorityCount = 

    sizeof( KResultPriority ) / sizeof( CDiagResultsDatabaseItem::TResult );

// LOCAL TYPES

class CDiagTestPluginBase::TPrivateData

    {

public:     // Constructor

    // Note that this is not a C-class, and ALL member must be explicitly initialized.

    TPrivateData( CCoeEnv& aCoeEnv )

        :   iDtorIdKey( TUid::Null() ),

            iPluginResourceLoader( aCoeEnv ),

            iWaitingDialogWrapper( NULL ),

            iResultBuilder( NULL ),

            iExecParam( NULL ),

            iCustomParam( NULL ),

            iDependencyCheckSkipped( EFalse ),

            iDependencyExecution( EFalse ),

            iSinglePluginExecution( EFalse ),

            iWatchdogResultType( CDiagResultsDatabaseItem::EWatchdogCancel )

        {}

public:

    /**

    * ECOM Destructor key.

    */

    TUid iDtorIdKey;

    /**

    * Resource loader for derived class resource.

    */

    RConeResourceLoader iPluginResourceLoader;

    /**

    * Wrapper class for displaying waiting dialogs.

    * Ownership: Shared. Normally, dialog will dismiss itself. However,

    * if plug-in is being deleted, it can be deleted by the plug-in as well.

    */

    CDiagPluginWaitingDialogWrapper* iWaitingDialogWrapper;

    /**

    * Results Db Item Builder. This will be used to build the result db item.

    * Owneship: this.

    */

    CDiagResultsDbItemBuilder*  iResultBuilder;

    /**

    * Test execution parameter.

    * Ownership: this.

    */

    TDiagTestExecParam* iExecParam;

    /**

    * Custom test execution parameter

    * Ownership: Does not own. Owned by application.

    */

    TAny* iCustomParam;

    /**

    * This indicates whether this test session has skipped dependency check.

    */

    TBool iDependencyCheckSkipped;

    /**

    * This indicates whether this test is being executed to satisfy dependency.

    */

    TBool iDependencyExecution;

    /**

    * Indicates if the plugin is run as a single plugin

    * or as a part of suite

    */

    TBool iSinglePluginExecution;

    /**

    * Result type to use when watchdog is timed out.

    */

    CDiagResultsDatabaseItem::TResult iWatchdogResultType;

    };

// ======== LOCAL FUNCTIONS ========

// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------

// CDiagTestPluginBase::CDiagTestPluginBase

// ---------------------------------------------------------------------------

//

EXPORT_C CDiagTestPluginBase::CDiagTestPluginBase( 

        CDiagPluginConstructionParam* aParam )

    :   CActive( EPriorityStandard ),

        iConstructionParam( aParam ),

        iCoeEnv ( *CCoeEnv::Static() )

    {

    __ASSERT_ALWAYS( aParam, Panic( EDiagPluginBasePanicBadArgument ) );

    CActiveScheduler::Add(this);

    }

// ---------------------------------------------------------------------------

// CDiagTestPluginBase::BaseConstructL

// ---------------------------------------------------------------------------

//

EXPORT_C void CDiagTestPluginBase::BaseConstructL( const TDesC& aResourceFileName )

    {

    iData = new ( ELeave ) TPrivateData( CoeEnv() );

    DiagPluginBaseUtils::OpenResourceFileL(

        aResourceFileName, iData->iPluginResourceLoader, CoeEnv().FsSession() );

    }

// ---------------------------------------------------------------------------

// CDiagTestPluginBase::~CDiagTestPluginBase

// ---------------------------------------------------------------------------

//

EXPORT_C CDiagTestPluginBase::~CDiagTestPluginBase()

    {

    if ( iData )

        {

        // In case test was still running, clean up.

        // It takes care of:

        //  iData->iWaitingDialog

        //  iData->iIsDialogDismessedByUserResponsePtr

        //  iData->iResultBuilder

        //  iData->iExecParam

        // It must be trapped, since it is part of object destruction.

        TRAPD( err, StopAndCleanupL() );

        if ( err != KErrNone )

            {

            LOGSTRING3( "CDiagTestPluginBase::~CDiagTestPluginBase(). "

                L"StopAndCleaupL() failed Uid = 0x%08x , err = %d",

                Uid(),

                err );

            }

        // Call DestroyedImplementation only if it was set.

        // SetDtorIdKey may not have been called if it is not actually an

        // ECOM plug-in.

        if ( iData->iDtorIdKey != TUid::Null() )

            {

            REComSession::DestroyedImplementation( iData->iDtorIdKey );

            }

        iData->iPluginResourceLoader.Close();

        delete iData;

        iData = NULL;

        }

    delete iConstructionParam;

    iConstructionParam = NULL;

    }

// ---------------------------------------------------------------------------

// From CActive

// CDiagTestPluginBase::RunError

// ---------------------------------------------------------------------------

//

EXPORT_C TInt CDiagTestPluginBase::RunError( TInt aError )

    {

    LOGSTRING2( "CDiagTestPluginBase::RunError( %d )", aError )

    // Check if we are executing a test.

    if ( iData->iExecParam != NULL )

        {

        // Catch error from CompleteTestL. If there is an error while calling

        // CompleteTestL(), return the error to active scheduler.

        aError = KErrNone;

        TRAP( aError, CompleteTestL( CDiagResultsDatabaseItem::EFailed ) );

        }

    }

// ---------------------------------------------------------------------------

// From MDiagTestPlugin

// CDiagTestPluginBase::GetServiceLogicalNameL

// ---------------------------------------------------------------------------

//

EXPORT_C const TDesC& CDiagTestPluginBase::ServiceLogicalName() const

    {

    return iConstructionParam->ServiceProvided();

    }

// ---------------------------------------------------------------------------

// From MDiagTestPlugin

// CDiagTestPluginBase::GetLogicalDependenciesL

// ---------------------------------------------------------------------------

//

EXPORT_C void CDiagTestPluginBase::GetLogicalDependenciesL( 

        CPtrCArray& aArray ) const

    {       

    aArray.CopyL( iConstructionParam->ServicesRequired() );

    }

// ---------------------------------------------------------------------------

// From MDiagTestPlugin

// CDiagTestPluginBase::Type

// ---------------------------------------------------------------------------

//

EXPORT_C MDiagPlugin::TPluginType CDiagTestPluginBase::Type() const

    {

    return ETypeTestPlugin;

    }

// ---------------------------------------------------------------------------

// From MDiagTestPlugin

// CDiagTestPluginBase::CreateIconL

// ---------------------------------------------------------------------------

//

EXPORT_C CGulIcon* CDiagTestPluginBase::CreateIconL() const

    {

    return NULL;

    }

// ---------------------------------------------------------------------------

// From MDiagTestPlugin

// CDiagTestPluginBase::IsSupported

// ---------------------------------------------------------------------------

//

EXPORT_C TBool CDiagTestPluginBase::IsSupported() const

    {

    return ETrue;

    }

// ---------------------------------------------------------------------------

// From MDiagTestPlugin

// CDiagTestPluginBase::ParentUid

// ---------------------------------------------------------------------------

//

EXPORT_C TUid CDiagTestPluginBase::ParentUid() const

    {

    return iConstructionParam->ParentUid();

    }

// ---------------------------------------------------------------------------

// From MDiagTestPlugin

// CDiagTestPluginBase::Order

// ---------------------------------------------------------------------------

//

EXPORT_C TUint CDiagTestPluginBase::Order() const

    {

    return iConstructionParam->Order();

    }

// ---------------------------------------------------------------------------

// From MDiagTestPlugin

// CDiagTestPluginBase::SetDtorIdKey

// ---------------------------------------------------------------------------

//

EXPORT_C void CDiagTestPluginBase::SetDtorIdKey( TUid aDtorIdKey )

    {

    __ASSERT_ALWAYS( iData, Panic( EDiagPluginBasePanicInvalidState ) );

    LOGSTRING3( "CDiagTestPluginBase::SetDtorIdKey: Old=0x%x, New=0x%x",

        iData->iDtorIdKey.iUid, aDtorIdKey.iUid )

    iData->iDtorIdKey = aDtorIdKey;

    }

// ---------------------------------------------------------------------------

// From MDiagTestPlugin

// CDiagTestPluginBase::GetTitleL

// ---------------------------------------------------------------------------

//

EXPORT_C HBufC* CDiagTestPluginBase::GetTitleL() const

    {

    // Currently, GetTitleL() is not supported.

    User::Leave( KErrNotSupported );

    return NULL;

    }

// ---------------------------------------------------------------------------

// From MDiagTestPlugin

// CDiagTestPluginBase::GetDescriptionL

// ---------------------------------------------------------------------------

//

EXPORT_C HBufC* CDiagTestPluginBase::GetDescriptionL() const

    {

    // Currently, GetDescriptionL() is not supported.

    User::Leave( KErrNotSupported );

    return NULL;

    }

// ---------------------------------------------------------------------------

// From MDiagTestPlugin

// CDiagTestPluginBase::CustomOperationL

// ---------------------------------------------------------------------------

//

EXPORT_C TAny* CDiagTestPluginBase::CustomOperationL( TUid /* aUid */, 

        TAny* /* aParam */ ) 

    {

    LOGSTRING( "CDiagTestPluginBase::CustomOperationL: KErrNotSupported" )

    User::Leave( KErrNotSupported );

    return NULL;

    }

// ---------------------------------------------------------------------------

// From MDiagTestPlugin

// CDiagTestPluginBase::GetCustomL

// ---------------------------------------------------------------------------

//

EXPORT_C TAny* CDiagTestPluginBase::GetCustomL( TUid /* aUid*/,

                                                TAny* /* aParam */ )

    {

    LOGSTRING( "CDiagTestPluginBase::GetCustomL: KErrNotSupported" )

    User::Leave( KErrNotSupported );

    return NULL;

    }

// ---------------------------------------------------------------------------

// From MDiagTestPlugin

// CDiagTestPluginBase::TestSessionBeginL

// ---------------------------------------------------------------------------

//

EXPORT_C void CDiagTestPluginBase::TestSessionBeginL( 

        MDiagEngineCommon& /* aEngine */,

        TBool /* aSkipDependencyCheck */,

        TAny* /* aCustomParams */ )

    {

    }

// ---------------------------------------------------------------------------

// From MDiagTestPlugin

// CDiagTestPluginBase::TestSessionEndL

// ---------------------------------------------------------------------------

//

EXPORT_C void CDiagTestPluginBase::TestSessionEndL( 

        MDiagEngineCommon& /* aEngine */,

        TBool /* aSkipDependencyCheck */,

        TAny* /* aCustomParams */ )

    {

    }

// ---------------------------------------------------------------------------

// From CDiagTestPluginBase

// CDiagTestPluginBase::RunTestL

// ---------------------------------------------------------------------------

//

EXPORT_C void CDiagTestPluginBase::RunTestL( 

        TDiagTestExecParam* aExecParam,

        TBool aSkipDependencyCheck,

        TBool aDependencyExecution,

        TAny* aCustomParam ) 

    {

    __ASSERT_ALWAYS( iData, Panic( EDiagPluginBasePanicInvalidState ) );

    __ASSERT_DEBUG( iData->iExecParam == NULL, Panic( EDiagPluginBasePanicInternal ) );

    __ASSERT_DEBUG( iData->iResultBuilder == NULL, Panic( EDiagPluginBasePanicInternal ) );

    delete iData->iExecParam;

    delete iData->iResultBuilder;

    iData->iExecParam = aExecParam;

    iData->iCustomParam = aCustomParam;

    iData->iDependencyCheckSkipped = aSkipDependencyCheck;

    iData->iDependencyExecution = aDependencyExecution;

    iData->iResultBuilder = CDiagResultsDbItemBuilder::NewL( Uid(), aDependencyExecution );

    ResetWatchdogToDefault();

    // checking if this is a single test execution or not 

    iData->iSinglePluginExecution = 

        ( aExecParam->Engine().ExecutionPlanL().TestCount( EFalse ) == 1 );

    // verify that dependencies are satisfied.

    RArray<TUid>* failedUids = NULL;

    CDiagResultsDatabaseItem::TResult dependencyResult = CDiagResultsDatabaseItem::ESuccess;

    if ( !aSkipDependencyCheck )

        {

        dependencyResult =  VerifyDependenciesL( 

            aExecParam->Engine(),

            failedUids );

        }

    if(dependencyResult == CDiagResultsDatabaseItem::ESuccess)

	LOGSTRING( "This is to remove compiler warning");

    if ( failedUids )

        {

        failedUids->Reset();

        failedUids->Close();

        delete failedUids;

        failedUids = NULL;

        }

    DoRunTestL();

    /*if ( dependencyResult == CDiagResultsDatabaseItem::ESuccess )

        {

        }

    else

        {

        // Create dependency failed test result and send it to engine.

        // Note that we can't actually call CompleteTestL(), or StopAndCleanupL() 

        // here because we haven't actually called the derived class.

        // So, reporting and clean up must be done manually.

        // Map dependent test result to what we should report.

        switch ( dependencyResult )

            {

            case CDiagResultsDatabaseItem::EFailed:

                dependencyResult = CDiagResultsDatabaseItem::EDependencyFailed;

                break;

            case CDiagResultsDatabaseItem::EWatchdogCancel:

            case CDiagResultsDatabaseItem::ESkipped:

            case CDiagResultsDatabaseItem::EInterrupted:

            case CDiagResultsDatabaseItem::ENotPerformed:

                dependencyResult = CDiagResultsDatabaseItem::EDependencySkipped;

                break;

            default:

                // no change is needed.

                break;

            }

        iData->iResultBuilder->SetTestCompleted( dependencyResult );

        iData->iExecParam->Observer().TestExecutionCompletedL( *this,

            iData->iResultBuilder->ToResultsDatabaseItemL() );

        BaseStopAndCleanup();

        }*/

    }

// ---------------------------------------------------------------------------

// CDiagTestPluginBase::ExecutionParam

// ---------------------------------------------------------------------------

//

EXPORT_C TDiagTestExecParam& CDiagTestPluginBase::ExecutionParam()

    {

    __ASSERT_ALWAYS( iData, Panic( EDiagPluginBasePanicInvalidState ) );

    __ASSERT_ALWAYS( iData->iExecParam, Panic( EDiagPluginBasePanicInvalidState ) );

    return *(iData->iExecParam);

    }

// ---------------------------------------------------------------------------

// CDiagTestPluginBase::IsDependencyCheckSkipped

// ---------------------------------------------------------------------------

//

EXPORT_C TBool CDiagTestPluginBase::IsDependencyCheckSkipped() const

    {

    __ASSERT_ALWAYS( iData, Panic( EDiagPluginBasePanicInvalidState ) );

    __ASSERT_ALWAYS( iData->iExecParam, Panic( EDiagPluginBasePanicInvalidState ) );

    return iData->iDependencyCheckSkipped;

    }

// ---------------------------------------------------------------------------

// CDiagTestPluginBase::IsDependencyExecution

// ---------------------------------------------------------------------------

//

EXPORT_C TBool CDiagTestPluginBase::IsDependencyExecution() const

    {

    __ASSERT_ALWAYS( iData, Panic( EDiagPluginBasePanicInvalidState ) );

    __ASSERT_ALWAYS( iData->iExecParam, Panic( EDiagPluginBasePanicInvalidState ) );

    return iData->iDependencyExecution;

    }

// ---------------------------------------------------------------------------

// CDiagTestPluginBase::CustomParam

// ---------------------------------------------------------------------------

//

EXPORT_C TAny* CDiagTestPluginBase::CustomParam() const

    {

    __ASSERT_ALWAYS( iData, Panic( EDiagPluginBasePanicInvalidState ) );

    __ASSERT_ALWAYS( iData->iExecParam, Panic( EDiagPluginBasePanicInvalidState ) );