/*

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

*

*/

// CLASS DECLARATION

#include "diagengineimpl.h"                 // CDiagEngineImpl

// SYSTEM INCLUDE FILES

#include <DiagPluginPool.h>                 // CDiagPluginPool

#include <DiagFrameworkDebug.h>             // LOGSTRING

#include <DiagPlugin.h>                     // MDiagPlugin

#include <DiagTestExecParam.h>              // TDiagTestExecParam

#include <DiagSuiteExecParam.h>             // TDiagSuiteExecParam

#include <DiagResultsDbItemBuilder.h>       // CDiagResultsDbItemBuilder

#include <DiagResultsDbRecordEngineParam.h> // CDiagResultsDbRecordEngineParam

// USER INCLUDE FILES

#include "diagpluginexecplanimpl.h"         // CDiagPluginExecPlanImpl

#include "diagexecplanentryimpltest.h"      // CDiagExecPlanEntryImplTest

#include "diagenginestatemachine.h"         // DiagFwInternal::CStateMachine

#include "diagenginecallhandler.h"          // CDiagEngineCallHandler

#include "diagframework.pan"                // Panic Codes

#include "diagengineconfig.h"               // TDiagEngineConfig

// EVENT INCLUDE FILES

#include "diagengineeventbasic.h"           // DiagFwInternal::CEventBasic

#include "diagengineeventtestprogress.h"    // DiagFwInternal::CEventTestProgress

using namespace DiagFwInternal;

// DATA

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

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

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

// CDiagEngineImpl::NewL()

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

//

CDiagEngineImpl* CDiagEngineImpl::NewL( 

        CAknViewAppUi&          aViewAppUi, 

        MDiagEngineObserver&    aObserver,

        RDiagResultsDatabase&   aDbSession,

        CDiagPluginPool&        aPluginPool,

        TBool                   aDisableDependency,

        const RArray< TUid >&   aExecutionBatch )

    {

    CDiagEngineImpl* self = CDiagEngineImpl::NewLC( aViewAppUi,

                                                    aObserver,

                                                    aDbSession,

                                                    aPluginPool,

                                                    aDisableDependency,

                                                    aExecutionBatch );

    CleanupStack::Pop( self );

    return self;

    }

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

// CDiagEngineImpl::NewLC()

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

//

CDiagEngineImpl* CDiagEngineImpl::NewLC( 

        CAknViewAppUi&          aViewAppUi, 

        MDiagEngineObserver&    aObserver,

        RDiagResultsDatabase&   aDbSession,

        CDiagPluginPool&        aPluginPool,

        TBool                   aDisableDependency,

        const RArray< TUid >&   aExecutionBatch )

    {

    CDiagEngineImpl* self = new ( ELeave ) CDiagEngineImpl( aViewAppUi,

                                                            aObserver,

                                                            aDbSession,

                                                            aPluginPool );

    CleanupStack::PushL( self );

    self->ConstructNewRecordL( aDisableDependency, aExecutionBatch );

    return self;

    }

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

// CDiagEngineImpl::NewL()

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

//

CDiagEngineImpl* CDiagEngineImpl::NewL( CAknViewAppUi&          aViewAppUi, 

                                        MDiagEngineObserver&    aObserver,

                                        RDiagResultsDatabase&   aDbSession,

                                        CDiagPluginPool&        aPluginPool,

                                        TUid                    aIncompleteRecordUid )

    {

    CDiagEngineImpl* self = CDiagEngineImpl::NewLC( aViewAppUi,

                                                    aObserver,

                                                    aDbSession,

                                                    aPluginPool,

                                                    aIncompleteRecordUid );

    CleanupStack::Pop( self );

    return self;

    }

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

// CDiagEngineImpl::NewLC()

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

//

CDiagEngineImpl* CDiagEngineImpl::NewLC( CAknViewAppUi&    aViewAppUi, 

                                   MDiagEngineObserver&    aObserver,

                                   RDiagResultsDatabase&   aDbSession,

                                   CDiagPluginPool&        aPluginPool,

                                   TUid                    aIncompleteRecordUid )

    {

    CDiagEngineImpl* self = new ( ELeave ) CDiagEngineImpl( aViewAppUi,

                                                            aObserver,

                                                            aDbSession,

                                                            aPluginPool );

    CleanupStack::PushL( self );

    self->ConstructIncompleteRecordL( aIncompleteRecordUid );

    return self;

    }

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

// CDiagEngineImpl::CDiagEngineImpl

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

//

CDiagEngineImpl::CDiagEngineImpl( CAknViewAppUi&          aViewAppUi,

                                  MDiagEngineObserver&    aObserver,

                                  RDiagResultsDatabase&   aDbSession,

                                  CDiagPluginPool&        aPluginPool )

    :   CActive( EPriorityStandard ),

        iViewAppUi( aViewAppUi ),

        iObserver( aObserver ),

        iDbSession( aDbSession ),

        iPluginPool( aPluginPool )

    {

    LOGSTRING( "---- DIAG ENGINE BEGIN ---- DIAG ENGINE BEGIN ----{" )

    CActiveScheduler::Add( this );

    }

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

// CDiagEngineImpl::ConstructNewRecordL

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

//

void CDiagEngineImpl::ConstructNewRecordL( TBool aDisableDependency,

                                           const RArray< TUid >& aExecutionBatch )

    {

    ConstructCommonL();

    LOGSTRING( "CDiagEngineImpl::ConstructNewRecordL()" )

    iContinueIncompleteRecord = EFalse;

    iEngineConfig.SetDependencyDisabled( aDisableDependency );

    // convert uid array to plugin reference array.

    // Also, make a copy of the plug-in UID array so that it can be

    // passed to database.

    TInt batchCount = aExecutionBatch.Count();

    // uidList must be allocated in heap since it database will own the data later.

    RArray< TUid >* uidList = new( ELeave )RArray< TUid >();

    CleanupStack::PushL( uidList );     // to delete array itself.

    CleanupClosePushL( *uidList );      // to call close.

    uidList->ReserveL( batchCount );

    MDiagPlugin* plugin = NULL;

    for ( TInt i = 0; i < batchCount ; i++ )

        {

        LOGSTRING2( "CDiagEngineImpl::ConstructNewRecordL() "

            L"Add plugin 0x%08x", aExecutionBatch[i].iUid )

        iPluginPool.FindPlugin( aExecutionBatch[i], plugin );

        iBatch.AppendL( plugin );

        plugin = NULL;

        uidList->AppendL( aExecutionBatch[i] );

        }

    CDiagResultsDbRecordEngineParam* engineParam = 

        CDiagResultsDbRecordEngineParam::NewL(

            uidList,                                // ownership transfer

            !iEngineConfig.IsDependencyDisabled()   /* isDependencyExecution */ );

    CleanupStack::Pop( uidList );   // CleanupClosePushL( *uidList )

    CleanupStack::Pop( uidList );   // CleanupStack::PushL( uidList )

    uidList = NULL;

    CleanupStack::PushL( engineParam );

    User::LeaveIfError( 

        iDbRecord.CreateNewRecord( iDbSession, iRecordId, *engineParam ) );

    CleanupStack::PopAndDestroy( engineParam );

    engineParam = NULL;

    iPlan = CDiagPluginExecPlanImpl::NewL( *this, iEngineConfig, *this );

    }

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

// CDiagEngineImpl::ConstructIncompleteRecordL

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

//

void CDiagEngineImpl::ConstructIncompleteRecordL( TUid aIncompleteRecordUid )

    {

    ConstructCommonL();

    LOGSTRING2( "CDiagEngineImpl::ConstructIncompleteRecordL() "

        L"RecordId = 0x%08x", aIncompleteRecordUid.iUid )

    iRecordId = aIncompleteRecordUid;

    iContinueIncompleteRecord = ETrue;

    User::LeaveIfError( 

        iDbRecord.Connect( iDbSession, 

                           iRecordId,

                           EFalse   /* aReadOnly */ ) );

    // make sure that record is open for writing.

    TBool isTestCompleted = EFalse;

    User::LeaveIfError( iDbRecord.IsTestCompleted( isTestCompleted ) );

    if ( isTestCompleted )

        {

        User::Leave( KErrLocked );

        }

    // recover original parameter

    CDiagResultsDbRecordEngineParam* engineParam = NULL;

    User::LeaveIfError(

        iDbRecord.GetEngineParam( engineParam ) );

    CleanupStack::PushL( engineParam );

    // Recover original batch.

    MDiagPlugin* plugin = NULL;

    iEngineConfig.SetDependencyDisabled( !engineParam->DependencyExecution() );

    const RArray< TUid >& uidArray = engineParam->ExecutionsUidArray();

    TInt count = uidArray.Count();

    for ( TInt i = 0; i < count; i++ )

        {

        LOGSTRING2( "CDiagEngineImpl::ConstructNewRecordL() "

            L"Add plugin 0x%08x", uidArray[i].iUid )

        User::LeaveIfError( 

            iPluginPool.FindPlugin( uidArray[i], plugin ) );

        iBatch.AppendL( plugin );

        plugin = NULL;

        }

    CleanupStack::PopAndDestroy( engineParam );

    engineParam = NULL;

    iPlan = CDiagPluginExecPlanImpl::NewL( *this, iEngineConfig, *this );

    }

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

// CDiagEngineImpl::ConstructCommonL()

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

//

void CDiagEngineImpl::ConstructCommonL()

    {

    LOGSTRING( "CDiagEngineImpl::ConstructCommonL." )

    // Read Cenrep key

    iEngineConfig.ReadCenrepKeysL();

    // Create state machine.

    iStateMachine = CStateMachine::NewL( *this );

    // Create call handler.

    iCallHandler = CDiagEngineCallHandler::NewL( *this );

    }

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

// CDiagEngineImpl::~CDiagEngineImpl

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

//

CDiagEngineImpl::~CDiagEngineImpl()

    {

    LOGSTRING( "CDiagEngineImpl::~CDiagEngineImpl() Destructor" )

    StopAllRequests();

    CleanupIncompleteTestSession();

    // always delete plan before record is closed.

    delete iPlan;

    iPlan = NULL;

    iDbRecord.Close();

    iBatch.Close(); // MUST NOT destroy since we don't own elements within it

    delete iStateMachine;

    iStateMachine = NULL;

    delete iSuspendedResult;

    iSuspendedResult = NULL;

    delete iCallHandler;

    iCallHandler = NULL;

    LOGSTRING( "} ---- DIAG ENGINE END ---- DIAG ENGINE END ----" )

    }

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

// CDiagEngineImpl::CleanupIncompleteTestSession

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

//

void CDiagEngineImpl::CleanupIncompleteTestSession()

    {

    if ( iStateMachine == NULL || 

            iStateMachine->CurrentState() == EStateNotReady ||

            iStateMachine->CurrentState() == EStateStopped )

        {

        // Test is never started or already finished. Nothing to clean up here.

        return;

        }

    // At this point, we can either suspend or complete the test record.

    // Normally, since state machine is not in EStateStopped state,

    // record should suspended.

    //

    // However, even if it is not completely done executing the plan, 

    // if last test is already completed, engine will report TestCompleted( ETrue ).

    // Otherwise, when examining db record for resuming, the record will appear

    // incomplete, but in reality there is no more test to execute and resuming the

    // record will immediately finish the session, which is meaningless.

    // Hence, when last test plug-in is executed, engine will record test completed,

    // instead of suspend, even if there are suite items left in plan.

    LOGSTRING2( "CDiagEngineImpl::CleanupIncompleteTestSession() State = %d", 

        iStateMachine->CurrentState() )

    switch( iStateMachine->CurrentState() )

        {

        case EStateStopped:

            // all completed. Nothing to finalize.

            break;

        case EStateNotReady:        // fall through

        case EStateCreatingPlan:

            // Plan was not fully created.

            // Mark the record as incomplete and let execution plan

            // to figure out how to resume later.

            // No need to call NotifyPluginsOfTestSessionEnd() since 

            // TestSessionBeginL() was never called. 

            iDbRecord.Suspend();    // in destructor. Error ignored.

            break;

        case EStateCancelAll:

            {

            // Test session was being cancelled. Since we were in cancel all mode,

            // it cannot be resumed. Mark the record completed.

            NotifyPluginsOfTestSessionEnd();

            TInt err =  iDbRecord.TestCompleted( EFalse /* aFullyComplete */ );

            LOGSTRING2( "CDiagEngineImpl::CleanupIncompleteTestSession() "

                L" TestCompleted( EFalse ) err = %d", err )

            // in destructor. Error ignored.

            }

            break;

        case EStateFinalizing:

            {

            // Engine was about to finalize, but never got a chance to.

            // In this state, db record should always be closed with TestCompleted

            // since it is a normal execution finish scenario and it cannot

            // be resumed later.

            NotifyPluginsOfTestSessionEnd();

            TBool isFullyCompleted = ( iEngineError == KErrNone );

            TInt err = iDbRecord.TestCompleted( isFullyCompleted );

            LOGSTRING3( "CDiagEngineImpl::CleanupIncompleteTestSession() "

                L"iDbRecord.TestCompleted( %d ) err = %d", isFullyCompleted, err )

            // We are in destructor. Ignore errors from db.

            }

            break;

        default:

            // In other states, engine was still executing some items.

            // Check if it shoud be marked as suspended or not.

            {

            TBool allTestsCompleted = EFalse;

            for ( TInt i = iPlan->CurrentIndex(); i < iPlan->Count(); i++ )

                {

                if ( (*iPlan)[i].Plugin().Type() == MDiagPlugin::ETypeTestPlugin &&

                     (*iPlan)[i].State() != MDiagExecPlanEntry::EStateCompleted )

                    {

                    // Found a test entry that is not completed.

                    allTestsCompleted = EFalse;

                    break; //lint !e960  break OK here.

                    }

                }

            NotifyPluginsOfTestSessionEnd();

            if ( allTestsCompleted )

                {

                TInt err =  iDbRecord.TestCompleted( ETrue /* aFullyComplete */ );

                LOGSTRING2( "CDiagEngineImpl::CleanupIncompleteTestSession() "

                    L" iDbRecord.TestCompleted( ETrue ) err = %d", err )

                }

            else

                {

                TInt err = iDbRecord.Suspend();

                LOGSTRING2( "CDiagEngineImpl::CleanupIncompleteTestSession(). "

                    L"iDbRecord.Suspend() err = %d", err )

                }

            }

            break;

        }

    }

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

// CDiagEngineImpl::ExecuteL

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

//

void CDiagEngineImpl::ExecuteL()

    {

    __ASSERT_ALWAYS( iStateMachine->CurrentState() == EStateNotReady,

                     Panic( EDiagFrameworkInvalidState ) );

    iStateMachine->AddEventL( EEventExecute );

    }

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

// CDiagEngineImpl::SetCustomParam

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

//

void CDiagEngineImpl::SetCustomParam( TAny* aCustomParams )

    {

    __ASSERT_ALWAYS( aCustomParams, Panic( EDiagFrameworkBadArgument ) );

    // Custom parameter can be set only when engine is not running.

    __ASSERT_ALWAYS( iStateMachine->CurrentState() == EStateNotReady, 

                     Panic( EDiagFrameworkInvalidState ) );

    iCustomParam = aCustomParams;

    }

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

// CDiagEngineImpl::SuspendL

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

//

void CDiagEngineImpl::SuspendL()

    {

    DiagFwInternal::TState state = iStateMachine->CurrentState();

    // Suspendable states:

    __ASSERT_ALWAYS( ( state == EStateRunning ||

                       state == EStateCreatingPlan ||

                       state == EStateFinalizing ||

                       state == EStateStopped ),

                     Panic( EDiagFrameworkInvalidState ) );

    if ( state == EStateFinalizing || state == EStateStopped )

        {

        // ignore suspend request. All tests are already completed and

        // we are just waiting to finalize db record and report final

        // result.

        return;

        }

    StopAllRequests();

    LOGSTRING( "CDiagEngineImpl::SuspendL(). Adding suspend event" )

    iStateMachine->AddEventL( EEventSuspend );

    }

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

// CDiagEngineImpl::ResumeL

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

//

void CDiagEngineImpl::ResumeL()

    {

    __ASSERT_ALWAYS( iStateMachine->CurrentState() == EStateSuspended,

                     Panic( EDiagFrameworkInvalidState ) );

    LOGSTRING( "CDiagEngineImpl::SuspendL(). Adding resume event" )

    AddResumeEventL( MDiagEngineObserver::EResumedByClient );

    }

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

// From class MDiagEngineCommon

// CDiagEngineImpl::ExecutionPlanL

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

//

const MDiagPluginExecPlan& CDiagEngineImpl::ExecutionPlanL() const

    {

    return *iPlan;

    }

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

// From class MDiagEngineCommon

// CDiagEngineImpl::ExecutionStopL

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

//

void CDiagEngineImpl::ExecutionStopL( TCancelMode aCancelMode )

    {

    DiagFwInternal::TState state = iStateMachine->CurrentState();

    // Acceptable states for execution stop.

    __ASSERT_ALWAYS( state == EStateCreatingPlan ||

                     state == EStateRunning ||

                     state == EStateSuspended ||

                     state == EStateFinalizing ||

                     state == EStateStopped,

                     Panic( EDiagFrameworkInvalidState ) );

    if ( state == EStateFinalizing || state == EStateStopped )