/*

* 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 "mcenatstateconnected.h"

#include "mcenatsipsession.h"

#include "mceactionset.h"

#include "mceclientserver.h"

#include "mcenatevents.h"

#include "mcenatactions.h"

#include "mcesrvlogs.h"

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

// CMceNatStateConnected::CMceNatStateConnected

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

//

CMceNatStateConnected::CMceNatStateConnected()

	{

	}

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

// CMceNatStateConnected::~CMceNatStateConnected

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

//

CMceNatStateConnected::~CMceNatStateConnected()

	{

	}

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

// CMceNatStateConnected::Accept

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

//

TBool CMceNatStateConnected::Accept( TMceNatStateTransitionEvent& aEvent )

    {

    switch ( aEvent.NatCode() )

        {

        case EMceNatUpdated:

            {

            return aEvent.Session().DoesMediaManagerNeedToNegotiate( NULL );

            }

        case EMceNatHandleSIP:

            {

            return ( EMceInvite == aEvent.Code() || 

                     EMcePrack == aEvent.Code()  ||

            	  	 ( EMceAck == aEvent.Code() &&

            	  	   MceSip::HasContent( aEvent.Session().Request() ) ) );

           	}

        case EMceNatUpdateSdp:

        case EMceNatError:

        case EMceNatICMPError: 

            {

            return ETrue;

            }

        default:

            {

            return EFalse;

            }

        }

    }    

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

// CMceNatStateConnected::EntryL

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

//

void CMceNatStateConnected::EntryL( TMceNatStateTransitionEvent& aEvent )

	{

	MCESRV_DEBUG( "*** CMceNatStateConnected::EntryL, Entry" );

	if ( EMceNatSync == aEvent.NatCode() ||

	     EMceNatOffer == aEvent.NatCode() )

	    {

	    // NOP

	    }

    else

        {

	    aEvent.NatActions().Continue();

	    }

    MCESRV_DEBUG( "*** CMceNatStateConnected::EntryL, Exit" );

	}

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

// CMceNatStateConnected::ExitL

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

//

void CMceNatStateConnected::ExitL( TMceNatStateTransitionEvent& aEvent )

	{

	MCESRV_DEBUG( "*** CMceNatStateConnected::ExitL, Entry" );

	switch ( aEvent.NatCode() )

	    {

	    case EMceNatError:

	    case EMceNatICMPError:

	        {

	        ExitErrorL( aEvent );

	        break;

	        }

	    case EMceNatUpdateSdp:

	        {

	        ExitUpdateSdpL( aEvent );

	        break;

	        }

	  	case EMceNatHandleSIP:

	        {

	        if ( EMceInvite == aEvent.Code() )

	        	{

		        ExitHandleInviteL( aEvent );

	        	}

			else

				{

	        	ExitDefaultL( aEvent );

				}	        	

	        break;

	        }

	    default:

	        {

	        ExitDefaultL( aEvent );

	        break;

	        }

	    }

	MCESRV_DEBUG( "*** CMceNatStateConnected::ExitL, Exit" );

	}

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

// CMceNatStateConnected::ExitErrorL

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

//

void CMceNatStateConnected::ExitErrorL( TMceNatStateTransitionEvent& aEvent )

    {

    TMceStateIndex sipState = aEvent.Session().CurrentState().Id();

    if (( aEvent.NatCode() == EMceNatICMPError && 

    		KMceStateEstablished == sipState ) || 

    		aEvent.NatCode() == EMceNatError )

    	{

    	aEvent.Session().Actions().ClientErrorOccured( aEvent.ParamStatus() );

    	User::Leave( aEvent.ParamStatus() );		

    	}

    }

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

// CMceNatStateConnected::ExitUpdateSdpL

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

//

void CMceNatStateConnected::ExitUpdateSdpL( 

    TMceNatStateTransitionEvent& /*aEvent*/ )

    {

    // NAT has resulted in different transport address than initial O/A 

    // exchange suggested, hence re-INVITE must be sent.

    //CMceSipSession& session = aEvent.Session();

    //CSdpDocument* previous = session.Offer();

    //aEvent.Session().SetOffer( aEvent.Document() );

    //aEvent.NatActions().SetOffered( KMceNatOfferSdp );

    //aEvent.NatActions().SdpCleanup( previous, session.Offer() );

    //aEvent.Session().Actions().SendInviteL();

    }

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

// CMceNatStateConnected::ExitHandleInviteL

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

//

void CMceNatStateConnected::ExitHandleInviteL( 

    TMceNatStateTransitionEvent& aEvent )

    {

    if ( !MceSip::HasContent( aEvent.Session().Request() ) )

        {

        // TBD: Restart of ICE

        }

    // Not consumed, done by SIP state machine

    aEvent.NatActions().Continue();        

    }

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

// CMceNatStateConnected::ExitDefaultL

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

//

void CMceNatStateConnected::ExitDefaultL( TMceNatStateTransitionEvent& aEvent )

    {

  	TMceStateIndex sipState = aEvent.Session().CurrentState().Id();

    if ( KMceStateServerEstablishing == sipState || 

        KMceStateUpdating == sipState || 

       	( aEvent.NatCode() == EMceNatUpdated && 

       	KMceStateAcknowledgementRequired == sipState )) //i.e. DecodeL

    	{

    	// MT state loop

    	//Check if the invite package received includes corresponding SDP;

    	if ( !MceSip::HasContent( aEvent.Session().Request() ) )

    		{

    		//no SDP, so certify to Pull mode Re-INVITE 

    		aEvent.NatActions().StateChangedL( aEvent, KMceNatStateCreateOffer );

    		}

    	else

    		{

    		//including SDP, so certify to normal INVITE request

    		aEvent.NatActions().StateChangedL( aEvent, KMceNatStateCreateAnswer  );

    		}

    	}

    else if ( aEvent.NatCode() == EMceNatUpdated && 

		 	  ( KMceStateEstablished == sipState ||

     	  	    KMceStateConfirming == sipState ||

    	  	    KMceStateClientEstablishing == sipState ) ||

    	  	 ( aEvent.ParamStatus() == KMceReady ) &&

    	  	 ( aEvent.Code() == EMceProvisionalResponse ) )

		//i.e. UpdateL	

		{

        // MO state loop

        aEvent.NatActions().StateChangedL( aEvent, KMceNatStateCreateOffer );

		}

	else

		{

		aEvent.NatActions().Continue();        	

		}		

    }

// End of File