/*
* 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 CStateMachine
*
*/


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

// SYSTEM INCLUDE FILES
#include <DiagFrameworkDebug.h>             // LOGSTRING

// USER INCLUDE FILES
#include "diagenginestatemachineobserver.h" // DiagFwInternal::MStateMachineObserver
#include "diagengineeventbasic.h"           // DiagFwInternal::CEventBasic
#include "diagframework.pan"                // Panics


namespace DiagFwInternal
    {
// ======== LOCAL DATA ==========
struct TStateTableEntry
    {
    TState  iInputState;
    TEvent  iEventType;
    TState  iOutputState;
    };


static const TStateTableEntry  KStateTable[] = 
    {
        // current state    input event                 output state
        {
        EStateNotReady,     EEventExecute,              EStateCreatingPlan
        },
        {
        EStateCreatingPlan, EEventPlanCreated,          EStateRunning
        },
        {
        EStateSuspended,    EEventResumeToRunning,      EStateRunning
        },
        {
        EStateSuspended,    EEventResumeToCreatingPlan, EStateCreatingPlan
        },
        {
        EStateFinalizing,   EEventFinalized,            EStateStopped,
        },
        // ALL EStateAny MUST be listed in below.
        // This makes sure that more specific transition happens before
        // any state transitions occur.
        {
        EStateAny,          EEventAllPluginsCompleted,  EStateFinalizing
        },
        {
        EStateAny,          EEventCancelAll,            EStateCancelAll
        },
        {
        EStateAny,          EEventSuspend,              EStateSuspended
        },
        {
        EStateAny,          EEventVoiceCallActive,      EStateSuspended
        }
    };

static const TInt KStateTableSize = sizeof( KStateTable )/sizeof( TStateTableEntry );


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


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

// ---------------------------------------------------------------------------
// CStateMachine::ConstructL()
// ---------------------------------------------------------------------------
//
void CStateMachine::ConstructL()
    {
    }


// ---------------------------------------------------------------------------
// CStateMachine::NewL()
// ---------------------------------------------------------------------------
//
CStateMachine* CStateMachine::NewL( MStateMachineObserver& aObserver )
    {
    CStateMachine* self = CStateMachine::NewLC( aObserver );
    CleanupStack::Pop( self );
    return self;
    }


// ---------------------------------------------------------------------------
// CStateMachine::NewLC()
// ---------------------------------------------------------------------------
//
CStateMachine* CStateMachine::NewLC( MStateMachineObserver& aObserver )
    {
    CStateMachine* self = new( ELeave )CStateMachine( aObserver );
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

// ---------------------------------------------------------------------------
// CStateMachine::CStateMachine
// ---------------------------------------------------------------------------
//
CStateMachine::CStateMachine( MStateMachineObserver& aObserver )
    :   CActive( EPriorityStandard ),
        iObserver( aObserver ),
        iEventQueue(),
        iState( EStateNotReady )
    {
    CActiveScheduler::Add( this );
    }


// ---------------------------------------------------------------------------
// CStateMachine::~CStateMachine
// ---------------------------------------------------------------------------
//
CStateMachine::~CStateMachine() 
    {
    Cancel();
    iEventQueue.ResetAndDestroy();
    iEventQueue.Close();
    }
    

// ---------------------------------------------------------------------------
// CStateMachine::AddEventL
// ---------------------------------------------------------------------------
//
void CStateMachine::AddEventL( CEventBasic* aEvent )
    {
    __ASSERT_ALWAYS( aEvent, Panic( EDiagFrameworkBadArgument ) );

    LOGSTRING2( "CStateMachine::AddEventL: Type = %S", &( aEvent->ToString() ) )

    CleanupStack::PushL( aEvent );
    iEventQueue.AppendL( aEvent );     // owership transfer
    CleanupStack::Pop( aEvent );
    // do not set aEvent to NULL, since it is used later

    TState nextState = CheckStateTable( iState, aEvent->GetType() );

    if ( nextState != EStateAny && nextState != iState )
        {
        // state change happened.
        TState prevState = iState;
        iState = nextState;

        iObserver.HandleStateChangedL( prevState, iState, *aEvent );
        }

    ReactivateQueue();
    }


// ---------------------------------------------------------------------------
// CStateMachine::AddEventL
// ---------------------------------------------------------------------------
//
void CStateMachine::AddEventL( TEvent aEventId )
    {
    // simple event. Create a basic event type
    AddEventL( new( ELeave )CEventBasic( aEventId ) );
    }


// ---------------------------------------------------------------------------
// CStateMachine::CurrentState
// ---------------------------------------------------------------------------
//
TState CStateMachine::CurrentState() const
    {
    return iState;
    }

// ---------------------------------------------------------------------------
// CStateMachine::HandleError
// ---------------------------------------------------------------------------
//
void CStateMachine::HandleError( TInt aError )
    {
    iState = iObserver.HandleError( iState, aError );
    }

// ---------------------------------------------------------------------------
// From CActive
// CStateMachine::RunL
// ---------------------------------------------------------------------------
//
void CStateMachine::RunL() 
    {
    // Note that ReactivateQueue() must always be called before observer method
    // is called. This is because observer may delete state machine
    // during the callback. To prevent crashes, callback MUST BE the
    // last funciton to call before returning.
    if ( iEventQueue.Count() > 0 )
        {
        // there is an item in the event queue.
        // Pop and execute the event.
        CEventBasic* event = iEventQueue[0];
        iEventQueue.Remove( 0 );
        
        // always reactivate the queue before calling observer
        ReactivateQueue();

        CleanupStack::PushL( event );
        iObserver.HandleEventL( *event );
        CleanupStack::PopAndDestroy( event );

        // must return immediately to make sure that no member variables
        // are accessed after observer is called.
        return;
        }
    else
        {
        LOGSTRING( "CStateMachine::RunL(). Called for no reason?" )
        __ASSERT_DEBUG( 0, Panic( EDiagFrameworkCorruptStateMachine ) );
        }
    }

// ---------------------------------------------------------------------------
// From CActive
// CStateMachine::DoCancel
// ---------------------------------------------------------------------------
//
void CStateMachine::DoCancel() 
    {
    // Nothing to do here..
    }

// ---------------------------------------------------------------------------
// From CActive
// CStateMachine::RunError
// ---------------------------------------------------------------------------
//
TInt CStateMachine::RunError( TInt aError ) 
    {
    HandleError( aError );
    return KErrNone;
    }


// ---------------------------------------------------------------------------
// CStateMachine::CheckStateTable
// ---------------------------------------------------------------------------
//
TState CStateMachine::CheckStateTable( TState aCurrState, TEvent aEvent ) const
    {
    TState outputState = EStateAny;
    TBool isFound = EFalse;

    for ( TInt i = 0; i < KStateTableSize && !isFound; i++ )
        {
        if ( ( KStateTable[i].iInputState == EStateAny || 
                    aCurrState == KStateTable[i].iInputState ) &&
                aEvent == KStateTable[i].iEventType )
            {
            outputState = KStateTable[i].iOutputState;
            isFound = ETrue;
            }
        }
    return outputState;
    }

// ---------------------------------------------------------------------------
// CStateMachine::ReactivateQueue
// ---------------------------------------------------------------------------
//
void CStateMachine::ReactivateQueue()
    {
    if ( !IsActive() && iEventQueue.Count() > 0 )
        {
        // reactivate only if it is not already active, and there is something
        // in the queue
        TRequestStatus* stat = &iStatus;
        User::RequestComplete( stat, KErrNone );
        SetActive();
        }
    }

// ---------------------------------------------------------------------------
// CStateMachine::StateName
// ---------------------------------------------------------------------------
//

#if _DEBUG
const TDesC& CStateMachine::StateName( TState aState ) const
    {
    _LIT( KStateAny,         "EStateAny" );
    _LIT( KStateNotReady,    "EStateNotReady" );
    _LIT( KStateCreatingPlan,"EStateCreatingPlan" );
    _LIT( KStateRunning,     "EStateRunning" );
    _LIT( KStateStopped,     "EStateStopped" );
    _LIT( KStateCancelAll,   "EStateCancelAll" );
    _LIT( KStateSuspended,   "EStateSuspended" );
    _LIT( KStateFinalizing,  "EStateFinalizing" );

    switch ( aState )
        {
        case EStateAny:
            return KStateAny();

        case EStateNotReady:
            return KStateNotReady();

        case EStateCreatingPlan:
            return KStateCreatingPlan();

        case EStateRunning:
            return KStateRunning();

        case EStateStopped:
            return KStateStopped();

        case EStateCancelAll:
            return KStateCancelAll();

        case EStateSuspended:
            return KStateSuspended();

        case EStateFinalizing:
            return KStateFinalizing();
        
        default:
            _LIT( KUnknownState, "* Unknown State *");
            return KUnknownState(); 
        }
    }

#else   // #if _DEBUG

// non-debug version.
const TDesC& CStateMachine::StateName( TState /* aState */ ) const
    {
    _LIT( KNonDebugStateName, "?" );
    return KNonDebugStateName();
    }

#endif // #else _DEBUG

    } // end of namespace DiagFwInternal

// End of File