/*

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

#include "mcesipsession.h"

#include "mceactionset.h"

#include "mcefcactionset.h"

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

// CMceStateIdle::CMceStateIdle

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

//

CMceStateIdle::CMceStateIdle ()

    : CMceState( KMceStateIdle )

	{

	}

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

// CMceStateIdle::~CMceStateIdle

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

//

CMceStateIdle::~CMceStateIdle()

	{

	}

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

// CMceStateIdle::DoAcceptL

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

//

TBool CMceStateIdle::DoAcceptL( TMceStateTransitionEvent& aEvent )

	{

    //not accepted	

	User::LeaveIfError( aEvent.EventSource() == EMceMedia ? 

                        KErrTotalLossOfPrecision :

                        KErrNone );

    //accepted

    User::LeaveIfError(

       aEvent.EventSource() == EMceSip && aEvent.Code() == EMceInvite ? KErrNone :

       aEvent.EventSource() == EMceClient && aEvent.Code() == EMceItcEstablishSession ? KErrNone :

       KErrTotalLossOfPrecision );

	return ETrue;

	}

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

// CMceStateIdle::EntryL

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

//

void CMceStateIdle::EntryL( TMceStateTransitionEvent& aEvent )

	{

	switch( aEvent.Code() )

	    {

	    case EMceItcEstablishSession://going to send INVITE out

	        {

	        EntryEstablishL( aEvent );

            break;

	        }

	    case EMceInvite: //INVITE in

	        {

	        EntryInviteL( aEvent );

	        break;

	        }

        default:

            {

            //NOP

            break;

            }

	    }

	}

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

// CMceStateIdle::ExitL

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

//

void CMceStateIdle::ExitL( TMceStateTransitionEvent& aEvent )

	{

	CMceSipSession& session = aEvent.Session();

	TInt status = aEvent.ParamStatus();

	switch( aEvent.Code() )

	    {

	    case EMceItcEstablishSession:

	        {

            //server state -> client establishing, client state -> offering

            session.Actions().ClientStateChanged( aEvent.ParamIDs(),

            									  CMceSession::EOffering );

	        if ( status == KMceAsync )

	            {

                session.Actions().StateChanged( KMceStateClientEstablishing );

	            }

            else

                {

                session.Actions().StateChanged( KMceStateOffering );

	            }

	        break;

	        }

	    case EMceInvite:

	        {

			if ( status == KErrNone || status == KMceAsync )

				{

				if ( ( session.NatSession() && !session.IsNatDisabled() ) &&

						( &aEvent.Session().Request()) && 		

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

					{

					// Whether synchronous or asynchronous, wait NAT plugin to

					// get initialized

					session.Actions().StateChanged( KMceStateServerInitializing );

					}

				else

					{

					session.Actions().StateChanged( KMceStateServerEstablishing );	

					}

                }

            else // if error, server state -> terminated

                {

                session.Actions().StateChanged( KMceStateTerminated );

                }

	        break;

	        }

        default:

            {

            //NOP

            break;

            }

	    }

	}

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

// CMceStateIdle::EntryEstablishL

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

//

void CMceStateIdle::EntryEstablishL( TMceStateTransitionEvent& aEvent )

    {

    //update session body based on session received from client

    //and start waiting EMceMceMediaUpdated

    CMceSipSession& session = aEvent.Session();

    TInt status = KErrNone;

    session.Actions().UpdateBodyL( aEvent.ParamIDs(),

                                   aEvent.ParamClientMessage() );

    status = session.Actions().UpdateL();                                           

    if ( status == KMceReady )

        {

        session.Actions().EncodeL();

        session.FCActions().UpdateFCOfferL( *session.Offer() );

        session.Actions().SendInviteL();

        }  

    aEvent.ParamStatus() = status;  

    }

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

// CMceStateIdle::EntryInviteL

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

//    

void CMceStateIdle::EntryInviteL( TMceStateTransitionEvent& aEvent )

    {

    // Handle incoming INVITE

    CMceSipSession& session = aEvent.Session();

    TInt status = KErrNone;

    session.Extensions().UpdateL( session.Request() );

    session.Actions().CheckContactIsSecureL( session.Request() );

    // Pull mode situation

    if ( &session.Request() && !MceSip::HasContent( session.Request() ) )

        {

        session.Actions().ProcessSessionTimerServerL( session.Request() );

        session.Actions().ClientUpdateIncomingSessionL( session.Request() );

	    }

	else

	    {

	    //create SDP

        status = session.Actions().CreateSDP( session.Request() );

        if ( MCE_IS_ERROR( status ) )

            {

            if ( MceSip::IsSIPStackError( status ) )

                {

                MceSip::DiscardRequest( session.Request(), status );

                }

            else

                {

                User::Leave( status );

                }

            }

        else

            {

            //session timer

            session.Actions().ProcessSessionTimerServerL( session.Request() );

            //decode received SDP offer

            //and start waiting EMceItcUpdate, if everything OK

            TMceSipWarningCode warning = session.Actions().DecodeL();

            if ( !warning )

                {

                status = session.Actions().Update();

                if ( status == KErrNotSupported )

                    {

                    warning = KMceSipWarnSessionDescriptionParameterNotUnderstood;

                    }

                }

            if ( warning ) //if error, reject offer (4XX out)

                {

                session.Actions().SendRejectOfferWithWarningL( warning, session.Request() );

                status = KErrAbort;

                }

            else

                {

                //if OK show SDP to FC and send session, created based on SDP

                //to client for updating

                User::LeaveIfError( status );

				if ( !session.NatSession() || session.IsNatDisabled() )

					{

					session.ContinueHandlingIncomingSessionL();

					}

                }

            }

	    }

	aEvent.ParamStatus() = status;

    }

// End Of File