/*
* Copyright (c) 2005 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:  
*
*/





#include "mcesipstatemachine.h"
#include "mcesipsession.h"
#include "mcestateidle.h"
#include "mcestateclientestablishing.h"
#include "mcestateoffering.h"
#include "mcestateestablished.h"
#include "mcestateterminating.h"
#include "mcestateterminated.h"
#include "mcestateserverestablishing.h"
#include "mcestateupdating.h"
#include "mcestateupdated.h"
#include "mcestateanswering.h"
#include "mcestateerror.h"
#include "mcestatecanceled.h"
#include "mcestateconfirming.h"
#include "mcestateclientreserving.h"
#include "mcestateacknowledgementrequired.h"
#include "mcestateserverreserving.h"
#include "mcestateconfirmationrequired.h"
#include "mcestateserveroffering.h"
#include "mcestateserverinitializing.h"

#include "mceclientserver.h"
#include "mceevents.h"
#include "mcesrvlogs.h"


// -----------------------------------------------------------------------------
// CMceSipStateMachine::NewL
// -----------------------------------------------------------------------------
//
CMceSipStateMachine* CMceSipStateMachine::NewL()
	{
    CMceSipStateMachine* self = CMceSipStateMachine::NewLC();
    CleanupStack::Pop(self);
    return self;
	}

// -----------------------------------------------------------------------------
// CMceSipStateMachine::NewLC
// -----------------------------------------------------------------------------
//
CMceSipStateMachine* CMceSipStateMachine::NewLC ()
	{
    CMceSipStateMachine* self = new (ELeave) CMceSipStateMachine();
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
	}

// -----------------------------------------------------------------------------
// CMceSipStateMachine::CMceSipStateMachine
// -----------------------------------------------------------------------------
//
CMceSipStateMachine::CMceSipStateMachine ()
	{
	}

// -----------------------------------------------------------------------------
// CMceSipStateMachine::State
// -----------------------------------------------------------------------------
//
CMceState& CMceSipStateMachine::State ( TMceStateIndex aStateIndex )
	{
	return *(iStates[ aStateIndex ]);
    
	}

	
	
// -----------------------------------------------------------------------------
// CMceSipStateMachine::ConstructL
// -----------------------------------------------------------------------------
//
void CMceSipStateMachine::ConstructL ()
	{
    MCESRV_DEBUG("CMceSipStateMachine::ConstructL, Entry");
	
	CMceState* state = NULL;
	//
	state = new (ELeave) CMceStateIdle();
	CleanupStack::PushL( state );
	iStates.InsertL( state, state->Id() );
	CleanupStack::Pop( state );
	state = new (ELeave) CMceStateClientEstablishing();
	CleanupStack::PushL( state );
	iStates.InsertL( state, state->Id() );
	CleanupStack::Pop( state );
	state = new (ELeave) CMceStateOffering();
	CleanupStack::PushL( state );
	iStates.InsertL( state, state->Id() );
	CleanupStack::Pop( state );
	state = new (ELeave) CMceStateEstablished();
	CleanupStack::PushL( state );
	iStates.InsertL( state, state->Id() );
	CleanupStack::Pop( state );
	state = new (ELeave) CMceStateTerminating();
	CleanupStack::PushL( state );
	iStates.InsertL( state, state->Id() );
	CleanupStack::Pop( state );
	state = new (ELeave) CMceStateTerminated();
	CleanupStack::PushL( state );
	iStates.InsertL( state, state->Id() );
	CleanupStack::Pop( state );
	state = new (ELeave) CMceStateServerEstablishing();
	CleanupStack::PushL( state );
	iStates.InsertL( state, state->Id() );
	CleanupStack::Pop( state );
	state = new (ELeave) CMceStateUpdating();
	CleanupStack::PushL( state );
	iStates.InsertL( state, state->Id() );
	CleanupStack::Pop( state );
	state = new (ELeave) CMceStateUpdated();
	CleanupStack::PushL( state );
	iStates.InsertL( state, state->Id() );
	CleanupStack::Pop( state );
	state = new (ELeave) CMceStateAnswering();
	CleanupStack::PushL( state );
	iStates.InsertL( state, state->Id() );
	CleanupStack::Pop( state );
	state = new (ELeave) CMceStateError();
	CleanupStack::PushL( state );
	iStates.InsertL( state, state->Id() );
	CleanupStack::Pop( state );
	state = new (ELeave) CMceStateCanceled();
	CleanupStack::PushL( state );
	iStates.InsertL( state, state->Id() );
	CleanupStack::Pop( state );
	state = new (ELeave) CMceStateConfirming();
	CleanupStack::PushL( state );
	iStates.InsertL( state, state->Id() );
	CleanupStack::Pop( state );
	state = new (ELeave) CMceStateClientReserving();
	CleanupStack::PushL( state );
	iStates.InsertL( state, state->Id() );
	CleanupStack::Pop( state );
	state = new (ELeave) CMceStateAcknowledgementRequired();
	CleanupStack::PushL( state );
	iStates.InsertL( state, state->Id() );
	CleanupStack::Pop( state );
	state = new (ELeave) CMceStateServerReserving();
	CleanupStack::PushL( state );
	iStates.InsertL( state, state->Id() );
	CleanupStack::Pop( state );
	state = new (ELeave) CMceStateConfirmationRequired();
	CleanupStack::PushL( state );
	iStates.InsertL( state, state->Id() );
	CleanupStack::Pop( state );
    state = new (ELeave) CMceStateServerOffering();
	CleanupStack::PushL( state );
	iStates.InsertL( state, state->Id() );
	CleanupStack::Pop( state );
	state = new (ELeave) CMceStateServerInitializing();
	CleanupStack::PushL( state );
	iStates.InsertL( state, state->Id() );
	CleanupStack::Pop( state );

    MCESRV_DEBUG("CMceSipStateMachine::ConstructL, Exit");    
	}


// -----------------------------------------------------------------------------
// CMceSipStateMachine::Consumes
// -----------------------------------------------------------------------------
//
TBool CMceSipStateMachine::Consumes( TMceStateTransitionEvent& aEvent )
    {
    TBool consumes = EFalse;
    
    if ( aEvent.EventSource() == EMceSip )
        {
        consumes = ETrue;
        }
    else if ( aEvent.EventSource() == EMceMedia )
        {
        consumes = ETrue;
        }
    else 
        {
        consumes = 
            aEvent.Code() == EMceItcEstablishSession ||
            aEvent.Code() == EMceItcAcceptSession ||
            aEvent.Code() == EMceItcRejectSession ||
            aEvent.Code() == EMceItcTerminateSession ||
            aEvent.Code() == EMceItcCancel ||
            aEvent.Code() == EMceItcRing ||
            aEvent.Code() == EMceItcCallInQueue	||		
            aEvent.Code() == EMceItcUpdate ||
            aEvent.Code() == EMceItcEnable ||
            aEvent.Code() == EMceItcRequestSend ||  
            aEvent.Code() == EMceItcReplySend || 
            aEvent.Code() == EMceItcDisable;
        }
        
    return consumes;
    }
	
    
// -----------------------------------------------------------------------------
// CMceSipStateMachine::~CMceSipStateMachine
// -----------------------------------------------------------------------------
//
CMceSipStateMachine::~CMceSipStateMachine()
	{
    MCESRV_DEBUG("CMceSipStateMachine::~CMceSipStateMachine, Entry");
    
    iStates.ResetAndDestroy();
    iStates.Close();
    
    MCESRV_DEBUG("CMceSipStateMachine::~CMceSipStateMachine, Exit");
	}


// -----------------------------------------------------------------------------
// CMceSipStateMachine::ProcessL
// -----------------------------------------------------------------------------
//
void CMceSipStateMachine::ProcessL( TMceStateTransitionEvent& aEvent )
    {
    MCESRV_DEBUG("CMceSipStateMachine::ProcessL, Entry");
    CMceState& currentState = aEvent.Session().CurrentState();
    TMceStateIndex currentStateId = currentState.Id();
    TUint eventCode = aEvent.Code();
    MCESRV_DEBUG_STATE( "current state", currentStateId );
    MCESRV_DEBUG_EVENT( "trigger event", eventCode );
    
    if ( aEvent.EventSource() == EMceMedia )
        {
        // clear waiting flag
        aEvent.Session().SetWaitingMediaCallback( EFalse );
        }
        
    MMCEStateTransitionHandler& transition = currentState.TransitionHandler();
    TBool accept = currentState.AcceptL( aEvent );

    currentState.StateExitL( aEvent );
    
    if ( accept )
        {
        transition.EntryL( aEvent );
	    if ( aEvent.Session().CurrentState().Id() == currentState.Id() )
	        {
            transition.ExitL( aEvent );
	        }
        }

    aEvent.Session().CurrentState().StateEntry( aEvent );
        
    currentStateId = aEvent.Session().CurrentState().Id();
    MCESRV_DEBUG_STATE( "ProcessL: new state", currentStateId );
    
    MCESRV_DEBUG("CMceSipStateMachine::ProcessL, Exit");        
    }


// End of File