/*

* 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:  Engine implementation

*

*/

// System Include Files

#include <e32std.h>                     // User

#include <f32file.h>                    // RFs

#include <DiagEngine.h>                 // CDiagEngine

#include <DiagPlugin.h>                 // MDiagPlugin

#include <DiagSuitePlugin.h>            // MDiagSuitePlugin

#include <DiagResultsDatabaseItem.h>    // CDiagResultsDatabaseItem

#include <DiagPluginPool.h>             // CDiagPluginPool

#include <DiagResultsDatabaseTestRecordInfo.h>

                                        // TDiagResultsDatabaseTestRecordInfo

#include <drmserviceapi.h>              // CDrmServiceApi

#include <e32property.h>                // RProperty

#include <PSVariables.h>                // Property values

#include <startupdomainpskeys.h>        // Property values

#include <centralrepository.h>          // CRepository

#include <ProfileEngineSDKCRKeys.h>     // CR Keys for Profile

#include <DiagFrameworkDebug.h>         // Debug Logger

#include <DiagResultsDbRecordEngineParam.h>

// User Include Files

#include "devdiagapp.hrh"               // UID definition

#include "devdiagengine.h"              // CDevDiagEngine

#include "devdiagengineobserver.h"      // CDevDiagEngineObserver

#include "devdiagexecutionresults.h"    // CDevDiagExecResults

#include "devdiag.pan"                  // Panic

#include "devdiagcommoncanceldialogs.h"       // CDevDiagCancelExecutionDialog

#include "devdiagcommonskipdialogs.h"

// Local Constants

const TInt KErrDevDiagAlreadyInitialized = ( -1 );

const TInt KErrDevDiagAlreadyLoaded      = ( -2 );

const TInt KErrDevDiagUninitialized      = ( -3 );

///@@@KSR: changes for BAD Warnings - #177-D: variable "KErrDevDiagExecuting" was declared but never referenced

//const TInt KErrDevDiagExecuting          = ( -4 );

const TInt KErrDevDiagAlreadyRunning     = ( -5 );

const TInt KErrDevDiagNotRunning         = ( -6 );

const TInt KErrDevDiagSuspendResume      = ( -7 );

const TUid KUidDevDiagApplication        = { _UID3 };

///@@@KSR: changes for BAD Warnings - #177-D: variable "KProgressGranularity" was declared but never referenced

//const TInt KProgressGranularity     = ( 2 );

// Local Data Types

typedef CArrayFixFlat< TDiagResultsDatabaseTestRecordInfo > CDatabaseRecordInfoArray;

const TInt KArrayGranuality(50);

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

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

// Static two-phase constructor.

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

//

CDevDiagEngine* CDevDiagEngine::NewL()

    {

    LOGSTRING( "CDevDiagEngine::NewL()" )

    CDevDiagEngine* self = CDevDiagEngine::NewLC();

    CleanupStack::Pop( self );

    return self;

    }

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

// Static two-phase constructor.

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

//

CDevDiagEngine* CDevDiagEngine::NewLC()

    {

    LOGSTRING( "CDevDiagEngine::NewLC()" )

    CDevDiagEngine* self = new ( ELeave ) CDevDiagEngine();

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// Destructor.

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

//

CDevDiagEngine::~CDevDiagEngine()

    {

    LOGSTRING( "CDevDiagEngine::~CDevDiagEngine()" )

    // Cancel any outstanding asynchronous requests.

    Cancel();

    // Delete the member variables.

    delete iResults;

    delete iDiagEngine;

    delete iPluginPool;

    if ( iUids )

        {

        delete iUids;

        iUids = NULL;

        }

    iLastResults.ResetAndDestroy();

    iLastResults.Close();

    // Close the session with the results database.

    iResultsDatabase.Close();

    }

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

// This function allows the UI to receive application engine callbacks by

// implementing the MDevDiagEngineObserver interface.

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

//

void CDevDiagEngine::SetObserver( MDevDiagEngineObserver* aObserver )

    {

    LOGSTRING2( "CDevDiagEngine::SetObserver( 0x%x )", aObserver )

    if ( iObserver && aObserver )

        {

        // We have cannot leave here.

        TRAP_IGNORE( iObserver->HandleEngineCommandL(

            MDevDiagEngineObserver::EDevDiagEngineCommandObserverChanged,

            KErrNone,

            NULL ) )

        }

    iObserver = aObserver;

    }

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

// This function begins test execution.  It is the responsibility of the

// caller to check the runtime requirements prior to calling this function.

// This is an asynchronous request.

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

//

void CDevDiagEngine::ExecuteTestL( TUid aUid, CAknViewAppUi& aAppUi )

    {

    LOGSTRING2( "CDevDiagEngine::ExecuteTestL( 0x%x )", aUid.iUid )

    // Reset the member variables to prepare for a new execution run.

    delete iDiagEngine;

    iDiagEngine = NULL;

    delete iResults;

    iResults = NULL;

    iSuspendCounter = 0;

    RArray< TUid > uidArray;

    uidArray.Append( aUid );

    CleanupClosePushL( uidArray );

    // Create an engine instance and execute the test or suite.

    iDiagEngine = CDiagEngine::NewL( aAppUi,

                                     *this,

                                     iResultsDatabase,

                                     *iPluginPool,

                                     EFalse,

                                     uidArray );

    CleanupStack::PopAndDestroy(); // uidArray

    iDiagEngine->ExecuteL();

    // Do the state transition now that we are successfully starting.

    SetState( EStateStartingExecution );

    }

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

// This function will provides the execution results, which may be from an

// execution run which is ongoing, or from logged test results.

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

//

const CDevDiagExecResults& CDevDiagEngine::ExecutionResults() const

    {

    LOGSTRING( "CDevDiagEngine::ExecutionResults()" )

    __ASSERT_ALWAYS( HasExecutionResults(),

                     Panic( EDevDiagApplicationNotInitialized ) );

    return *iResults;

    }

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

// This function will handle getting the results information for the most

// recent test execution.

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

//

void CDevDiagEngine::LoadLastLoggedResultsL()

    {

    LOGSTRING( "CDevDiagEngine::LoadLastLoggedResultsL()" )

    // Check the state.

    __ASSERT_ALWAYS( iState == EStateReady,

                     Panic( EDevDiagApplicationInvalidEngineState ) );

    // If there are any existing results, just use them.

    if ( iResults )

        {

        return;

        }

    // Get info about the last test record.  If there are no existing records,

    // just return -- the caller must check if there are results before they

    // do anything.

    TUid lastExecutionRecord;

    if ( iResultsDatabase.GetLastRecord( lastExecutionRecord ) != KErrNone )

        {

        return;

        }

    // Now, load the logged results.

    iResults = CDevDiagExecResults::NewL( lastExecutionRecord,

                                          *iPluginPool,

                                          iResultsDatabase );

    }

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

// This function will stop test execution.  The argument specifies whether all

// execution should be stopped, or just the currently running test.

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

//

void CDevDiagEngine::ExecutionStopL( TDevDiagAppEngineStopMode aReason )

    {

   LOGSTRING2( "CDevDiagEngine::ExecutionStopL( %d )", aReason )

    // Check the state.

    __ASSERT_ALWAYS( IsRunningPlugins(),

                     Panic( EDevDiagApplicationInvalidEngineState ) );

    // Stop the execution.

    switch ( aReason )

        {

        case EStopModeSkip:

            iDiagEngine->ExecutionStopL( MDiagEngineCommon::ESkip );

            break;

        case EStopModeCancel:

            SetState( EStateStoppingExecution );

            // Start an idle active object, which will handle deleting the

            // diagnostics engine.  This cannot be done here because the

            // engine may be executing a test which is displaying the "Cancel

            // Execution" dialog, which calls this function.  The priority of

            // this CIdle MUST be higher than then diagnostics engine and ALL

            // of its active objects.

            delete iIdle;

            iIdle = NULL;

            iIdle = CIdle::NewL( CActive::EPriorityHigh );

            iIdle->Start( TCallBack( HandleExecutionCancelledL, this ) );

            // Inform the observer.  In the case where the observer is

            // displaying a dialog, this will allow the observer to cancel it.

            if ( iObserver )

                {

                iObserver->HandleEngineCommandL(

                    MDevDiagEngineObserver::EDevDiagEngineCommandExecutionStopping,

                    KErrCancel,

                    NULL );

                }

            break;

        case EStopModeSuspend:

            // Increment the suspend counter and check the state.

            LOGSTRING2( "CDevDiagEngine::ExecutionStopL, counter: %d",

                        iSuspendCounter )

            iSuspendCounter++;

            if ( iState == EStateExecutionSuspended )

                {

                // Do nothing - we're already suspended.

                __ASSERT_DEBUG( iSuspendCounter > 1,

                                Panic( EDevDiagApplicationInvalidEngineState ) );

                break;

                }

            SetState( EStateExecutionSuspended );

            iDiagEngine->SuspendL();

            break;

        case EStopModeWatchdog:

            iDiagEngine->StopWatchdogTemporarily();

            break;

        default:

            __ASSERT_DEBUG( EFalse, Panic( EDevDiagApplicationInvalidStopMode ) );

            break;

        }

    }

TInt CDevDiagEngine::HandleExecutionCancelledL( TAny* aPtr )

    {

    LOGSTRING2( "CDevDiagEngine::HandleExecutionCancelledL( 0x%x )", aPtr )

    CDevDiagEngine* myThis = static_cast< CDevDiagEngine* >( aPtr );

    myThis->iResults->Finalize( EFalse );

    delete myThis->iDiagEngine;

    myThis->iDiagEngine = NULL;

    delete myThis->iIdle;

    myThis->iIdle = NULL;

    myThis->SetState( EStateReady );

    // Inform the observer object.

    if ( myThis->iObserver )

        {

        myThis->iObserver->HandleEngineCommandL(

            MDevDiagEngineObserver::EDevDiagEngineCommandTestExecutionCancelled,

            KErrCancel,

            NULL );

        }

    return KErrNone;

    }

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

// This function will resume suspended test execution.

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

//

void CDevDiagEngine::ExecutionResumeL( TDevDiagAppEngineResumeMode aReason )

    {

    LOGSTRING2( "CDevDiagEngine::ExecutionResumeL( %d )", aReason )

    // Check the state.

    __ASSERT_ALWAYS( IsRunningPlugins(),

                     Panic( EDevDiagApplicationInvalidEngineState ) );

    // Resume the execution.

    switch ( aReason )

        {

        case EResumeModeResume:

            {

            LOGSTRING2( "CDevDiagEngine::ExecutionResumeL, counter: %d",

                        iSuspendCounter )

            // Decrement the suspend counter and check the state.

            --iSuspendCounter;

            __ASSERT_DEBUG( iSuspendCounter >= 0,

                            Panic( EDevDiagApplicationInvalidEngineState ) );

            __ASSERT_ALWAYS( iState == EStateExecutionSuspended,

                            Panic( EDevDiagApplicationInvalidEngineState ) );

            // Resume the execution, but only if there have been enough

            // "resume" calls to match the number of "suspend" calls.

            if ( iSuspendCounter == 0 )

                {

                SetState( EStateRunningTests );

                iDiagEngine->ResumeL();

                }

            break;

            }

        case EResumeModeWatchdog:

           // iDiagEngine->ResetWatchdogL();

            break;

        default:

            __ASSERT_DEBUG( EFalse,

                            Panic( EDevDiagApplicationInvalidEngineState ) );

            break;

        }

    }

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

// Returns the plugin pool.

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

//

const CDiagPluginPool& CDevDiagEngine::PluginPool() const

    {

    LOGSTRING( "CDevDiagEngine::PluginPool()" )

    __ASSERT_ALWAYS( ArePluginsLoaded(),

                   Panic( EDevDiagApplicationNotInitialized ) );

    return *iPluginPool;

    }

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

// Returns whether or not tests are running.

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

//

TBool CDevDiagEngine::IsRunningPlugins() const

    {

    LOGSTRING( "CDevDiagEngine::IsRunningPlugins()" )

    return ( iState == EStateStartingExecution ||

             iState == EStateRunningTests ||

             iState == EStateStoppingExecution ||

             iState == EStateExecutionSuspended );

    }

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

// Checks if the engine is currently stopping execution.

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

//

TBool CDevDiagEngine::IsStoppingExecution() const

    {

    LOGSTRING( "CDevDiagEngine::IsStoppingExecution()" )

    return ( iState == EStateStoppingExecution );

    }

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

// Returns whether or not plugins are done loading.

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

//

TBool CDevDiagEngine::ArePluginsLoaded() const

    {

    LOGSTRING( "CDevDiagEngine::ArePluginsLoaded()" )

    return ( iState != EStateInitial &&

             iState != EStateLoadingPlugins );

    }

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

// Returns whether execution results are available.

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

//

TBool CDevDiagEngine::HasExecutionResults() const

    {

    LOGSTRING( "CDevDiagEngine::HasExecutionResults()" )

    if ( iResults )

        {

        return ETrue;

        }

    return EFalse;

    }

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

// The default constructor.

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

//

CDevDiagEngine::CDevDiagEngine() : CActive( EPriorityStandard ),                            

                               iDiagEngine( NULL )

    {

    LOGSTRING( "CDevDiagEngine::CDevDiagEngine()" )

    }

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

// The second phase constructor.

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

//

void CDevDiagEngine::ConstructL()

    {

    LOGSTRING( "CDevDiagEngine::ConstructL()" )

    // Connect to the results database.

    User::LeaveIfError( iResultsDatabase.Connect( KUidDevDiagApplication ) );

    LOGSTRING( "CDevDiagEngine::ResultDB connect");

    // Load the plugins.

    iPluginPool = CDiagPluginPool::NewL( *this );

    LOGSTRING( "CDevDiagEngine::NewL");

    SetState( EStateLoadingPlugins );

    iPluginPool->LoadAsyncL( KDiagPluginInterfaceUid );

    LOGSTRING( "CDevDiagEngine::LoadPlugin");

    // Add the application engine to the active scheduler.

    CActiveScheduler::Add( this );

    }

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

// To obtain the current engine state

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

TInt CDevDiagEngine::GetState()

	{

	return iState;

	}

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

// The state machine transition handler.  If there is an error in changing

// states, then it will be returned and the state will be left unchanged.

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

//

void CDevDiagEngine::SetState( TDevDiagAppEngineState aNextState )

    {

    LOGSTRING3( "CDevDiagEngine::SetState( %d ), iState = %d",

                aNextState,

                iState )    

    // The state transition table.  Structure: State in / State to go to.

    static const TInt KStateTable[ EStateMax ][ EStateMax ] =

        {

            // EStateInitial

            {

            KErrNone,                        // To EStateInitial

            KErrNone,                        // To EStateLoadingPlugins

            KErrDevDiagUninitialized,        // To EStateReady

            KErrDevDiagUninitialized,        // To EStateStartingExecution

            KErrDevDiagUninitialized,        // To EStateRunningTests

            KErrDevDiagUninitialized,        // To EStateStoppingExecution

            KErrDevDiagUninitialized         // To EStateExecutionSuspended

            },

            // EStateLoadingPlugins

            {

            KErrDevDiagAlreadyInitialized,   // To EStateInitial

            KErrNone,                        // To EStateLoadingPlugins

            KErrNone,                        // To EStateReady

            KErrDevDiagUninitialized,        // To EStateStartingExecution

            KErrDevDiagUninitialized,        // To EStateRunningTests

            KErrDevDiagUninitialized,        // To EStateStoppingExecution

            KErrDevDiagUninitialized         // To EStateExecutionSuspended

            },

            // EStateReady

            {

            KErrDevDiagAlreadyInitialized,   // To EStateInitial

            KErrDevDiagAlreadyLoaded,        // To EStateLoadingPlugins