/*
* 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:  Connected state implementation.
*
*/

#include <sdpdocument.h>
#include "nspstateconnected.h"
#include "nspevents.h"
#include "nspsession.h"
#include "nspactionset.h"
#include "nspsessiondata.h"
#include "nspdefs.h"

// ======== MEMBER FUNCTIONS ========
// ---------------------------------------------------------------------------
// CNSPStateConnected::CNSPStateConnected
// ---------------------------------------------------------------------------
//
CNSPStateConnected::CNSPStateConnected()
    {
    }


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


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


// ---------------------------------------------------------------------------
// CNSPStateConnected::~CNSPStateConnected
// ---------------------------------------------------------------------------
//
CNSPStateConnected::~CNSPStateConnected()
    {
    }


// ---------------------------------------------------------------------------
// CNSPStateConnected::DoAcceptL
// ---------------------------------------------------------------------------
//
TBool CNSPStateConnected::DoAcceptL( TNSPStateMachineEvent& aEvent )
    {
    TBool accept = ETrue;
    
    User::LeaveIfError(
    		TNSPStateMachineEvent::ENat == aEvent.Request() ||
            TNSPStateMachineEvent::ECreateOffer == aEvent.Request() ||
            TNSPStateMachineEvent::EResolve == aEvent.Request() ||
            TNSPStateMachineEvent::EDecodeAnswer == aEvent.Request() ||
            TNSPStateMachineEvent::EUpdate == aEvent.Request() ||
            TNSPStateMachineEvent::EReservationStatus == aEvent.Request() ||
            TNSPStateMachineEvent::ECloseSession == aEvent.Request() ?
                    KErrNone : KErrTotalLossOfPrecision );
    
    if ( TNSPStateMachineEvent::ENat == aEvent.Request() )
    	{
    	// Events are ignored if return value from this method is 'EFalse'.
    	TNSPStateMachineMediaEvent& event = MEDIAEVENT( aEvent );
    	
    	accept = (
    		MNATFWConnectivityObserver::EReceivingActivated == event.Event() ||
        	MNATFWConnectivityObserver::ESendingActivated == event.Event() ||
        	( MNATFWConnectivityObserver::EGeneralError == event.Event() &&
        			NSP_ERROR( event.Status() ) ) );
    	}
    
    return accept;
    }


// ---------------------------------------------------------------------------
// CNSPStateConnected::DoStateEntryL
// ---------------------------------------------------------------------------
//
void CNSPStateConnected::DoStateEntryL( TNSPStateMachineEvent& aEvent )
    {
    CNSPSession& session = aEvent.Session();
    
    session.Actions().UpdateRoundL( session.Data().UpdatedSdp() );
    
    if ( ANSWERER( session.Role() ) )
        {
    	aEvent.Offer() = session.Data().ReleaseOffer();
    	aEvent.CallbackType() = TEventReturnStatus::EOfferReady;
        }
    else if ( OFFERER( session.Role() ) )
        {
    	aEvent.Answer() = session.Data().ReleaseAnswer();
    	aEvent.CallbackType() = TEventReturnStatus::EAnswerReady;
        }
    else
        {
        User::Leave( KErrArgument );
        }
    }


// ---------------------------------------------------------------------------
// CNSPStateConnected::DoReverse
// ---------------------------------------------------------------------------
//
void CNSPStateConnected::DoReverse( TNSPStateMachineEvent& aEvent )
    {
    CNSPSession& session = aEvent.Session();
    session.Data().SetOffer( NULL );
    session.Data().SetAnswer( NULL );
    session.Role() = CNSPSession::EUndefined;
    }


// ---------------------------------------------------------------------------
// CNSPStateConnected::DoApplyL
// ---------------------------------------------------------------------------
//
void CNSPStateConnected::DoApplyL( TNSPStateMachineEvent& aEvent )
    {
    switch ( aEvent.Request() )
        {
        case TNSPStateMachineEvent::ENat:
        	{
        	ControlMediaL( aEvent );
        	break;
        	}
        
        case TNSPStateMachineEvent::ECreateOffer:
            {
            ApplyCreateOfferL( aEvent );
            break;
            }
        
        case TNSPStateMachineEvent::EResolve:
            {
            ApplyResolveL( aEvent );
            break;
            }
        
        case TNSPStateMachineEvent::EDecodeAnswer:
            {
            ApplyDecodeAnswerL( aEvent );
            break;
            }
        
        case TNSPStateMachineEvent::EUpdate:
            {
            ApplyUpdateL( aEvent );
            break;
            }
        
        case TNSPStateMachineEvent::EReservationStatus:
            {
            aEvent.Status() = KNatReady;
            break;
            }
        
        case TNSPStateMachineEvent::ECloseSession:
            {
            aEvent.NextState() = KStateIndexDeActivating;
            aEvent.Status() = KNatAsync;
            break;
            }
        
        default:
            {
            User::Leave( KErrArgument );
            }
        }
    }


// ---------------------------------------------------------------------------
// CNSPStateConnected::DoExitL
// ---------------------------------------------------------------------------
//
void CNSPStateConnected::DoExitL( TNSPStateMachineEvent& aEvent )
    {
    CNSPSession& session = aEvent.Session();
    
    switch ( aEvent.Request() )
        {
        case TNSPStateMachineEvent::EResolve:
            {
            session.Data().SetOffer( aEvent.Offer()->CloneL() );
            session.Data().SetAnswer( aEvent.Answer()->CloneL() );
            session.Role() = CNSPSession::EAnswerer;
            break;
            }
        
        case TNSPStateMachineEvent::EDecodeAnswer:
            {
            session.Data().SetAnswer( aEvent.Answer()->CloneL() );
            session.Role() = CNSPSession::EOfferer;
            break;
            }
        case TNSPStateMachineEvent::ECreateOffer:
        	{
        	session.Data().SetOffer( aEvent.Offer()->CloneL() );
        	session.Role() = CNSPSession::EOfferer;
        	break;
        	}
        case TNSPStateMachineEvent::ECloseSession:
            {
            break;
            }
        
        default:
            {
            User::Leave( KErrArgument );
            }
        }
    }


// ---------------------------------------------------------------------------
// CNSPStateConnected::ControlMediaL
// ---------------------------------------------------------------------------
//
void CNSPStateConnected::ControlMediaL( TNSPStateMachineEvent& aEvent ) const
	{
	TNSPStateMachineMediaEvent& event = MEDIAEVENT( aEvent );
    TNatReturnStatus status = event.Session().Actions().ControlMediaL(
    		event.StreamId(), event.Event(), event.Status(), event.Data() );
    
    if ( NSP_TRIGGER( status ) )
    	{
    	// NOP
    	}
    else
    	{
    	event.Status() = status;
    	}
	}


// ---------------------------------------------------------------------------
// CNSPStateConnected::ApplyCreateOfferL
// ---------------------------------------------------------------------------
//
void CNSPStateConnected::ApplyCreateOfferL( TNSPStateMachineEvent& aEvent ) const
    {
    CNSPSession& session = aEvent.Session();
    TNatReturnStatus status = KNatReady;
    
    status = session.Actions().CreateStreamsL( *aEvent.Offer() );
    
    if ( KNatAsync == status )
        {	
        aEvent.NextState() = KStateIndexLocalCand;  	
        }
    else
        {
        session.Actions().LatterRoundL( *aEvent.Offer() );
        }
    aEvent.Status() = status;
    }


// ---------------------------------------------------------------------------
// CNSPStateConnected::ApplyResolveL
// ---------------------------------------------------------------------------
//
void CNSPStateConnected::ApplyResolveL( TNSPStateMachineEvent& aEvent ) const
    {
    CNSPSession& session = aEvent.Session();
    TNatReturnStatus status = KNatReady;
    
    status = session.Actions().CreateStreamsL( *aEvent.Answer() );
    
    if ( KNatAsync == status )
        {
        aEvent.NextState() = KStateIndexLocalCand;  	
        // TBD: Adding media streams, goto Localcand state.
        }
    else
        {
        session.Actions().LatterRoundL( *aEvent.Answer() );
        session.Actions().GetSessionConnInfoL( *aEvent.Offer() ); // ret ignored
        session.Actions().LocalRoundL( *aEvent.Offer() );
        }
    
    aEvent.Status() = status;
    }


// ---------------------------------------------------------------------------
// CNSPStateConnected::ApplyDecodeAnswerL
// ---------------------------------------------------------------------------
//
void CNSPStateConnected::ApplyDecodeAnswerL( TNSPStateMachineEvent& aEvent ) const
    {
    CNSPSession& session = aEvent.Session();
    
    session.Actions().GetSessionConnInfoL( *aEvent.Answer() );
    session.Actions().LocalRoundL( *aEvent.Answer() );
    }


// ---------------------------------------------------------------------------
// CNSPStateConnected::ApplyUpdateL
// ---------------------------------------------------------------------------
//
void CNSPStateConnected::ApplyUpdateL( TNSPStateMachineEvent& aEvent ) const
    {
    CNSPSession& session = aEvent.Session();
    
    if ( OFFERER( session.Role() ) )
        {
        session.Actions().LocalRoundL( *aEvent.Offer() );
        }
    else
        {
        User::Leave( KErrArgument );
        }
    }

// end of file