/*

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

*

*/

#ifndef DIAGENGINEIMPL_H

#define DIAGENGINEIMPL_H

// system includes

#include <e32base.h>                    // CActive

#include <DiagEngineCommon.h>           // MDiagEngineCommon

#include <DiagEngineObserver.h>         // MDiagEngineObserver::TSuspendReason

#include <DiagResultsDatabase.h>        // RDiagResultsDatabase, RDiagResultsDatabaseRecord

#include <DiagTestPlugin.h>             // MDiagTestPlugin::TStopReason

#include <DiagSuitePlugin.h>            // MDiagSuitePlugin::TStopReason

// user includes.

#include "diagenginestatemachineobserver.h"     // DiagFwInternal::MStateMachineObserver

#include "diagenginestates.h"                   // DiagFwInternal::TState

#include "diagengineevents.h"                   // DiagFwInternal::TEvent

#include "diagenginecallhandlerobserver.h"      // MDiagEngineCallHandlerObserver

#include "diagexecplanentryimplobserver.h"      // MDiagExecPlanEntryImplObserver

#include "diagengineconfig.h"                   // TDiagEngineConfig

// Forward declarations

class MDiagTestPlugin;

class MDiagSuitePlugin;

class CDiagPluginPool;

class CAknViewAppUi;

class CDiagEngineCallHandler;

class CDiagPluginExecPlanImpl;

class CDiagExecPlanEntryImpl;

class CDiagExecPlanEntryImplTest;

namespace DiagFwInternal

    {

    class CStateMachine;

    class CEventBasic;

    class CEventCancel;

    class CEventSendCompletion;

    class CEventSuiteContinue;

    class CEventTestCompleted;

    class CEventTestProgress;

    class CEventWatchdog;

    }

/**

*  Diagnostics Framework Engine Implementation

*

*  This class is the actual class that implements CDiagEngine.

*  All actual work is done by CDiagEngineImpl class.

*

*/

NONSHARABLE_CLASS( CDiagEngineImpl ) : public CActive,

                                       public MDiagEngineCommon,

                                       public MDiagExecPlanEntryImplObserver,

                                       public DiagFwInternal::MStateMachineObserver,

                                       public MDiagEngineCallHandlerObserver

    {

public:

    /**

    * Two-phased constructor.

    * @param aViewAppUi    View App Ui that is using this engine.

    * @param aObserver     Engine observer.

    * @param aDbSession    Session to RDiagResultDatabase to create record.

    * @param aPluginPool   Initialized plug-in pool that holds plug-ins.

    * @param aDisableDependency    if ETrue, plug-ins should execute

    *                      event if dependencies are not met.

    * @param aExecutionBatch - array of test uids to execute

    *

    * @return new instance of CDiagEngineImpl*

    */

    static CDiagEngineImpl* NewL( CAknViewAppUi&          aViewAppUi, 

                                  MDiagEngineObserver&    aObserver,

                                  RDiagResultsDatabase&   aDbSession,

                                  CDiagPluginPool&        aPluginPool,

                                  TBool                   aDisableDependency,

                                  const RArray< TUid >&   aExecutionBatch );

    /**

    * Two-phased constructor. This function is identical to NewL, 

    * except that it pushs created object in clean up stack.

    *

    * @param aViewAppUi    View App Ui that is using this engine.

    * @param aObserver     Engine observer.

    * @param aDbSession    Session to RDiagResultDatabase to create record.

    * @param aPluginPool   Initialized plug-in pool that holds plug-ins.

    * @param aDisableDependency    if ETrue, plug-ins should execute

    *                      event if dependencies are not met.

    * @param aExecutionBatch - array of test uids to execute

    *

    * @return new instance of CDiagEngineImpl*

    */

    static CDiagEngineImpl* NewLC( CAknViewAppUi&          aViewAppUi, 

                                   MDiagEngineObserver&    aObserver,

                                   RDiagResultsDatabase&   aDbSession,

                                   CDiagPluginPool&        aPluginPool,

                                   TBool                   aDisableDependency,

                                   const RArray< TUid >&   aExecutionBatch );

    /**

    * Two-phased constructor.

    * @param aViewAppUi    View App Ui that is using this engine.

    * @param aObserver     Engine observer.

    * @param aDbSession    Session to RDiagResultDatabase to create record.

    * @param aPluginPool   Initialized plug-in pool that holds plug-ins.

    * @param aIncompleteRecordUid - Uid to the record to resume.

    *

    * @return new instance of CDiagEngineImpl*

    */

    static CDiagEngineImpl* NewL( CAknViewAppUi&          aViewAppUi, 

                                  MDiagEngineObserver&    aObserver,

                                  RDiagResultsDatabase&   aDbSession,

                                  CDiagPluginPool&        aPluginPool,

                                  TUid                    aIncompleteRecordUid );

    /**

    * Two-phased constructor. This function is identical to NewL, 

    * except that it pushs created object in clean up stack.

    *

    * @param aViewAppUi    View App Ui that is using this engine.

    * @param aObserver     Engine observer.

    * @param aDbSession    Session to RDiagResultDatabase to create record.

    * @param aPluginPool   Initialized plug-in pool that holds plug-ins.

    * @param aIncompleteRecordUid - Uid to the record to resume.

    *

    * @return new instance of CDiagEngineImpl*

    */

    static CDiagEngineImpl* NewLC( CAknViewAppUi&          aViewAppUi, 

                                   MDiagEngineObserver&    aObserver,

                                   RDiagResultsDatabase&   aDbSession,

                                   CDiagPluginPool&        aPluginPool,

                                   TUid                    aIncompleteRecordUid );

    /**

    * Destructor.

    */

    virtual ~CDiagEngineImpl();

    /**

    * Execute tests. This implements CDiagEngine::ExecuteL

    *

    * @see CDiagEngine::ExecuteL

    */

    void ExecuteL();

    /**

    * Set custom execution parameter.

    *

    * @see CDiagEngine::SetCustomParam

    */

    void SetCustomParam( TAny* aCustomParams );

    /**

    * Suspend execution.  

    * 

    * @see CDiagEngine::SuspendL

    */

    void SuspendL();

    /**

    * Resume suspended execution. This implements CDiagEngine::ResumeL

    *

    * @see CDiagEngine::ResumeL

    */

    void ResumeL();

public: // from MDiagEngineCommon

    /**

    * Returns current execution plan.

    * 

    * @see MDiagEngineCommon::ExecutionPlanL

    */

    virtual const MDiagPluginExecPlan& ExecutionPlanL() const;

    /**

    * Stop current execution of tests.

    * 

    * @see MDiagEngineCommon::ExecutionStopL

    */

    virtual void ExecutionStopL( TCancelMode aCancelMode );

    /**

    * Resets test execution watchdog timer.

    * 

    * @see MDiagEngineCommon::ResetWatchdog

    */

    virtual void ResetWatchdog();

    /**

    * Resets test execution watchdog timer.

    * @see MDiagEngineCommon::ResetWatchdog

    */

    virtual void ResetWatchdog( TDiagEngineWatchdogTypes aWatchdogType );

    /**

    * Resets test execution watchdog timer.

    * @see MDiagEngineCommon::ResetWatchdog

    */

    virtual void ResetWatchdog( TTimeIntervalMicroSeconds32 aExpectedTimeToComplete );

    /**

    * Get App Ui reference that launched Diagnostics Engine.

    * 

    * @see MDiagEngineCommon::ViewAppUi()

    */

    virtual CAknViewAppUi& ViewAppUi();

    /**

    * Get App Ui reference that launched Diagnostics Engine.

    * 

    * @see MDiagEngineCommon::ViewAppUi()

    */

    virtual const CAknViewAppUi& ViewAppUi() const;

    /**

    * Get Database Subsession for record open for writing.

    * 

    * @see MDiagEngineCommon::DbRecord

    */

    virtual RDiagResultsDatabaseRecord& DbRecord();

    /**

    * Get Database Subsession for record open for writing.

    * 

    * @see MDiagEngineCommon::DbRecord

    */

    virtual const RDiagResultsDatabaseRecord& DbRecord() const;

    /**

    * Get reference to Plugin Pool

    * 

    * @see MDiagEngineCommon::PluginPool

    */

    virtual CDiagPluginPool& PluginPool();

    /**

    * Get reference to Plugin Pool

    * 

    * @see MDiagEngineCommon::PluginPool

    */

    virtual const CDiagPluginPool& PluginPool() const;

    /**

    * Add a text to configuraiton list option. 

    * 

    * @see MDiagEngineCommon::AddToConfigListL

    */

    virtual void AddToConfigListL( TConfigListType aListType, const TDesC& aText );

    /**

    * Remove a text from configuration list.

    * 

    * @see MDiagEngineCommon::RemoveFromConfigListL

    */

    virtual void RemoveFromConfigListL( TConfigListType aListType, const TDesC& aText );

    /**

    * Create a common dialog.

    * @see MDiagEngineCommon::CreateCommonDialogL

    */

    virtual CAknDialog* CreateCommonDialogLC( TDiagCommonDialog aDialogType,

                                              TAny* aInitData );

    /**

    * Stop watchdog activity temporarily.

    * @see MDiagEngineCommon::StopWatchdogTemporarily

    */

    virtual void StopWatchdogTemporarily();

    /**

    * Check if current engine is being executed with dependency disabled.

    * @see MDiagEngineCommon::IsDependencyDisabled

    */

    virtual TBool IsDependencyDisabled() const;

    /**

    * Get custom execution parameter.

    * @see MDiagEngineCommon::CustomParam

    */

    virtual TAny* CustomParam() const;

    /**

    * Send a command to application.

    *   @see MDiagEngineCommon::ExecuteAppCommandL

    */

    virtual void ExecuteAppCommandL( TDiagAppCommand aCommand, 

                                     TAny* aParam1,

                                     TAny* aParam2 );

private: // from MDiagExecPlanEntryImplObserver

    /**

    * Observe plugin execution progress

    * @see MDiagExecPlanEntryImplObserver::ExecPlanEntryProgressL

    */

    virtual void ExecPlanEntryProgressL( CDiagExecPlanEntryImpl& aSender,

                                         TUint aCurrentStep,

                                         TUint aTotalSteps );

    /**

    * Observe plugin execution completion

    * @see MDiagExecPlanEntryImplObserver::ExecPlanEntryExecutedL

    */

    virtual void ExecPlanEntryExecutedL( CDiagExecPlanEntryImpl& aSender );

    /**

    * Observer critical error from plug-in execution entry.

    * @see MDiagExecPlanEntryImplObserver::ExecPlanEntryCriticalError

    */

    virtual void ExecPlanEntryCriticalError( TInt aError );

private: // from DiagFwInternal::MStateMachineObserver

    /**

    * Handle state transition

    * 

    * @see MDiagEngineStateMachineObserver::HandleStateChangedL

    */

    virtual void HandleStateChangedL( DiagFwInternal::TState aPreviousState, 

                                      DiagFwInternal::TState aCurrentState,

                                      const DiagFwInternal::CEventBasic& aEventPreview );

    /**

    * Handle event.

    * 

    * @see MDiagEngineStateMachineObserver::HandleEventL

    */

    virtual void HandleEventL( DiagFwInternal::CEventBasic& aEvent );

    /**

    * Handle error.

    * 

    * @see MDiagEngineStateMachineObserver::HandleError

    */

    virtual DiagFwInternal::TState HandleError( DiagFwInternal::TState aCurrentState, 

                                                TInt aError );

private:    // From MDiagEngineCallHandlerObserver

    /**

    * Handle call handling state change.

    * 

    * @see MDiagEngineCallHandlerObserver::CallHandlerStateChangedL

    */

    virtual void CallHandlerStateChangedL( TDiagEngineCallHandlerState aState );

private:    // from CActive

    /**

    * RunL from CActive

    * 

    * @see CActive::RunL

    */

    virtual void RunL();

    /**

    * DoCancel from CActive

    * 

    * @see CActive::DoCancel

    */

    virtual void DoCancel();

    /**

    * Handle error 

    * 

    * @see CActive::RunError

    */

    virtual TInt RunError( TInt aError );

private:    // Private Constructors

    /**

    * C++ Constrctor

    *

    * @param aViewAppUi - Reference to Appui.

    * @param aObserver - Reference to engine observer. (Generall app)

    * @param aDbSession - Session to the database.

    * @param aPluginPool - Reference to plug-in pool.

    * @param aDisableDependency - Whether to disable dependency check.

    * @param aIncompleteRecordUid - Uid to the record to resume.

    *   If this UID is aIncompleteRecordUid == TUid::Null(), it will create

    *   a new record. 

    */

    CDiagEngineImpl( CAknViewAppUi&          aViewAppUi,

                     MDiagEngineObserver&    aObserver,

                     RDiagResultsDatabase&   aDbSession,

                     CDiagPluginPool&        aPluginPool );

    /**

    * Second phase constructor for creating a new record.

    *

    * @param aDisableDependency - Whether to disable dependency check

    * @param aExecutionBatch - Array of plug-in uids to execute

    */

    void ConstructNewRecordL( TBool aDisableDependency, 

                              const RArray< TUid >& aExecutionBatch );

    /**

    * Second phase constructor for resuming incomplete record.

    * 

    * @param aIncompleteRecordUid - Uid of DB record to resume from.

    */

    void ConstructIncompleteRecordL( TUid aIncompleteRecordUid );

    /**

    * Second phase constructor common.

    * Initializes items that are common to both new session and resuming session.

    */

    void ConstructCommonL();

private:    // Event handlers

    /**

    * State handler function for EStateCreatingPlan

    *

    * @param aEvent - Event to handle.

    */

    void HandleEventInCreatingPlanStateL( DiagFwInternal::CEventBasic& aEvent );

    /**

    * State handler function for EStateRunning

    *

    * @param aEvent - Event to handle.

    */

    void HandleEventInRunningStateL( DiagFwInternal::CEventBasic& aEvent );

    /**

    * State handler function for EStateCancelAll

    *

    * @param aEvent - Event to handle.

    */

    void HandleEventInCancelAllStateL( DiagFwInternal::CEventBasic& aEvent );

    /**

    * State handler function for EStateSuspended

    *

    * @param aEvent - Event to handle.

    */

    void HandleEventInSuspendedStateL( DiagFwInternal::CEventBasic& aEvent );

    /**

    * State handler function for EStateFinalizing

    *

    * @param aEvent - Event to handle.

    */

    void HandleEventInFinalizingStateL( DiagFwInternal::CEventBasic& aEvent );

    /**

    * State handler function for EStateStopped

    *

    * @param aEvent - Event to handle.

    */

    void HandleEventInStoppedStateL( DiagFwInternal::CEventBasic& aEvent );

private:    // Other private functions

    /**

    * Start creating execution plan

    */

    void StartCreateExecutionPlanL();

    /**

    * Handle Plan created event

    */

    void HandlePlanCreatedL();

    /**

    * Notify test progress event to engine observer

    *

    * @param aEvent - test progress event.

    */

    void NotifyTestProgressL( DiagFwInternal::CEventTestProgress& aEvent );

    /**

    * Report plug-in execution result to observer and continue to the next test.

    *

    * @param aError - Error code to report to observer.

    * @param aResult - result to report to observer.

    */

    void NotifyResultAndContinueL( TInt aError, CDiagResultsDatabaseItem* aResult );

    /**

    * Commit db record to DB. 

    *

    */

    void CommitResultsToDb();

    /**

    * Notify observer that last plugin is completed and engine is now stopped.

    * This could also mean that execution has failed.

    *

    * @param aEvent - last completion event

    */

    void NotifyLastPluginCompletedL( DiagFwInternal::CEventSendCompletion& aEvent );

    /**

    * Execute next plugin in the plan

    *

    */

    void ExecuteNextPluginL();

    /**

    * Suspend engine

    * 

    * @param aReason - Reason for suspending.

    */

    void DoSuspendL( MDiagEngineObserver::TSuspendReason aReason );

    /**

    * Add event to state machine.

    *   This functions makes sure that correct resume event is added to 

    *   the state machine depending on the previous state.

    * @param aReason - Resume reason.

    */

    void AddResumeEventL( MDiagEngineObserver::TResumeReason aReason );

    /**

    * Resume engine