/*

* 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:  Session class implementation.

*

*/

#include <sdpdocument.h>

#include "nspsessionobserver.h"

#include "nspsession.h"

#include "nspevents.h"

#include "nspcontrollerif.h"

#include "nspmediastreamcontainer.h"

#include "nspstatemachine.h"

#include "nspactionset.h"

#include "nspstatebase.h"

#include "nspcontentparser.h"

#include "nspdefs.h"

const TUint KConstProtocolTcp = 1;

const TUint KConstProtocolUdp = 2;

const TUint KDefaultGranularity = 5;

#define CONV_PROTOCOL_L( aProtocol ) \

        (TUint) User::LeaveIfError( \

            KConstProtocolTcp == aProtocol ? (TInt)KProtocolInetTcp : \

            ( KConstProtocolUdp == aProtocol ? (TInt)KProtocolInetUdp : KErrNotFound ) )

#define LOGEVENT( aEvent ) \

	switch( aEvent )\

		{\

		case MNATFWConnectivityObserver::ESessionCreated:{ NSPLOG_STR( "CNSPSession::EventOccured, event:ESessionCreated" ); break; }\

		case MNATFWConnectivityObserver::ELocalCandidateFound:{ NSPLOG_STR( "CNSPSession::EventOccured, event:ELocalCandidateFound" ); break; }\

		case MNATFWConnectivityObserver::EFetchingCompleted:{ NSPLOG_STR( "CNSPSession::EventOccured, event:EFetchingCompleted" ); break; }\

		case MNATFWConnectivityObserver::EReceivingActivated:{ NSPLOG_STR( "CNSPSession::EventOccured, event:EReceivingActivated" ); break; }\

		case MNATFWConnectivityObserver::EReceivingDeactivated:{ NSPLOG_STR( "CNSPSession::EventOccured, event:EReceivingDeactivated" ); break; }\

		case MNATFWConnectivityObserver::ESendingActivated:{ NSPLOG_STR( "CNSPSession::EventOccured, event:ESendingActivated" ); break; }\

		case MNATFWConnectivityObserver::ESendingDeactivated:{ NSPLOG_STR( "CNSPSession::EventOccured, event:ESendingDeactivated" ); break; }\

		case MNATFWConnectivityObserver::ECandidatePairFound:{ NSPLOG_STR( "CNSPSession::EventOccured, event:ECandidatePairFound" ); break; }\

		case MNATFWConnectivityObserver::EConnChecksCompleted:{ NSPLOG_STR( "CNSPSession::EventOccured, event:EConnChecksCompleted" ); break; }\

		case MNATFWConnectivityObserver::EGeneralError:{ NSPLOG_STR( "CNSPSession::EventOccured, event:EGeneralError" ); break; }\

		case MNATFWConnectivityObserver::EAllEvents:{ NSPLOG_STR( "CNSPSession::EventOccured, event:EAllEvents" ); break; }\

		default:{ NSPLOG_STR( "CNSPSession::EventOccured, event:Unknown" ); break; }\

		}

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

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

// CNSPSession::CNSPSession

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

// 

CNSPSession::CNSPSession( MNSPControllerIF& aController,

        MNSPSessionObserver& aSessionObserver )

    : iController( aController ),

      iSessionObserver( aSessionObserver )

    {

    }

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

// CNSPSession::ConstructL

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

//

void CNSPSession::ConstructL( TUint32 aIapId, const TDesC8& aDomain,

        TUint aProtocol )

    {

    NSPLOG_STR( "CNSPSession::ConstructL(), Entry" )

    iSessionId = iController.CreateSessionL( aIapId, aDomain );

    iSessionData = CNSPSessionData::NewL();

    iStreamContainer = CNSPMediaStreamContainer::NewL(

            iController, iSessionId, CONV_PROTOCOL_L( aProtocol ) );

    iStateMachine = CNSPStateMachine::NewL();

    iProtocolsArray = new (ELeave) CDesC8ArrayFlat( KDefaultGranularity );

    NSPLOG_STR( "CNSPSession::ConstructL(), Exit" )

    }

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

// CNSPSession::NewL

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

//

CNSPSession* CNSPSession::NewL( MNSPControllerIF& aController,

        MNSPSessionObserver& aSessionObserver, TUint32 aIapId,

        const TDesC8& aDomain, TUint aProtocol )

    {

    CNSPSession* self = CNSPSession::NewLC( aController, aSessionObserver,

            aIapId, aDomain, aProtocol );

    CleanupStack::Pop( self );

    return self;

    }

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

// CNSPSession::NewLC

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

//

CNSPSession* CNSPSession::NewLC( MNSPControllerIF& aController,

        MNSPSessionObserver& aSessionObserver, TUint32 aIapId,

        const TDesC8& aDomain, TUint aProtocol )

    {

    CNSPSession* self = new ( ELeave ) CNSPSession( aController,

            aSessionObserver );

    CleanupStack::PushL( self );

    self->ConstructL( aIapId, aDomain, aProtocol );

    return self;

    }

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

// CNSPSession::~CNSPSession

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

//

CNSPSession::~CNSPSession()

    {

    NSPLOG_STR( "CNSPSession::~CNSPSession(), Entry" )

    delete iSessionData;

    delete iStreamContainer;

    delete iStateMachine;

    delete iProtocolsArray;

    TRAP_IGNORE( iController.CloseSessionL( iSessionId ) );

    NSPLOG_STR( "CNSPSession::~CNSPSession(), Exit" )

    }

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

// CNSPSession::CreateOfferL

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

//

TNatReturnStatus CNSPSession::CreateOfferL( CSdpDocument*& aOffer )

    {

    NSPLOG_STR( "CNSPSession::CreateOfferL(), Entry" )

    __ASSERT_ALWAYS( aOffer, User::Leave( KErrArgument ) );

    NSP_INPUT_OFFER( *aOffer )

    TNSPStateMachineEvent event( KErrNone, aOffer, NULL,

    		TNSPStateMachineEvent::ECreateOffer, *this );

    iStateMachine->ProcessL( event );

    NSP_OUTPUT_OFFER( event.Status(), *aOffer )

    NSPLOG_STR( "CNSPSession::CreateOfferL(), Exit" )

    return event.Status();

    }

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

// CNSPSession::ResolveL

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

//

TNatReturnStatus CNSPSession::ResolveL(

        CSdpDocument*& aOffer, CSdpDocument*& aAnswer )

    {

    NSPLOG_STR( "CNSPSession::ResolveL(), Entry" )

    __ASSERT_ALWAYS( aOffer, User::Leave( KErrArgument ) );

    __ASSERT_ALWAYS( aAnswer, User::Leave( KErrArgument ) );

    NSP_INPUT_OFFER( *aOffer )

    NSP_INPUT_ANSWER( *aAnswer )

    TNSPStateMachineEvent event( KErrNone, aOffer, aAnswer,

    		TNSPStateMachineEvent::EResolve, *this );

    iStateMachine->ProcessL( event );

    NSP_OUTPUT_OFFER( event.Status(), *aOffer )

    NSP_OUTPUT_ANSWER( event.Status(), *aAnswer )

    NSPLOG_STR( "CNSPSession::ResolveL(), Exit" )

    return event.Status();

    }

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

// CNSPSession::DecodeAnswerL

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

//

TNatReturnStatus CNSPSession::DecodeAnswerL( CSdpDocument*& aAnswer )

    {

    NSPLOG_STR( "CNSPSession::DecodeAnswerL(), Entry" )

    __ASSERT_ALWAYS( aAnswer, User::Leave( KErrArgument ) );

    NSP_INPUT_ANSWER_L( *aAnswer )

    TNSPStateMachineEvent event( KErrNone, NULL, aAnswer,

    		TNSPStateMachineEvent::EDecodeAnswer, *this );

    iStateMachine->ProcessL( event );

    NSP_OUTPUT_ANSWER_L( event.Status(), *aAnswer )

    NSPLOG_STR( "CNSPSession::DecodeAnswerL(), Exit" )

    return event.Status();

    }

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

// CNSPSession::UpdateL

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

//

void CNSPSession::UpdateL( CSdpDocument*& aOffer )

    {    

    NSPLOG_STR( "CNSPSession::UpdateL(), Entry" )

    __ASSERT_ALWAYS( aOffer, User::Leave( KErrArgument ) );

    NSP_INPUT_OFFER( *aOffer )

    TNSPStateMachineEvent event( KErrNone, aOffer, NULL,

    		TNSPStateMachineEvent::EUpdate, *this );

    iStateMachine->ProcessL( event );

    NSP_OUTPUT_OFFER( event.Status(), *aOffer )

    NSPLOG_STR( "CNSPSession::UpdateL(), Exit" )

    }

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

// CNSPSession::CloseSessionL

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

//

TNatReturnStatus CNSPSession::CloseSessionL()

    {    

    NSPLOG_STR( "CNSPSession::CloseSessionL(), Entry" )

    TNSPStateMachineEvent event( KErrNone, NULL, NULL,

    		TNSPStateMachineEvent::ECloseSession, *this );

    iStateMachine->ProcessL( event );

    NSPLOG_STR( "CNSPSession::CloseSessionL(), Exit" )

    return event.Status();

    }

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

// CNSPSession::EventOccured

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

//

TEventReturnStatus CNSPSession::EventOccured( TUint aStreamId,

        MNATFWConnectivityObserver::TNATFWConnectivityEvent aEvent,

        TInt aError, TAny* aData )

    {

    NSPLOG_STR( "CNSPSession::EventOccured(), Entry" )

    LOGEVENT( aEvent )

    NSPLOG_INT( "CNSPSession::EventOccured, aError:", aError )

    __ASSERT_ALWAYS( iStateMachine, __PANIC( KErrNotFound ) );

    TNSPStateMachineMediaEvent event( aStreamId, aEvent, aData, aError,

    		NULL, NULL, TNSPStateMachineEvent::ENat, *this );

    TRAPD( error, iStateMachine->ProcessL( event ) );

    NSPLOG_INT( "CNSPSession::EventOccured, error:", error )

    NSPLOG_INT( "CNSPSession::EventOccured, event.Status():", event.Status() )

    event.Status() = ( KErrNone == error ? event.Status() : error );

    event.CallbackType() = ( NSP_ERROR( event.Status() ) ?

    			TEventReturnStatus::EError : event.CallbackType() );

    // If event.iOffer or event.iAnswer is not NULL, it means that ownership  

    // was transferred inside iStateMachine->ProcessL().

    // If there was an error we have to free the memory here,

    // since it won't be handled anywhere else

    if ( event.CallbackType() == TEventReturnStatus::EError )

        {

        delete event.iOffer;

        event.iOffer = NULL;

        delete event.iAnswer;

        event.iAnswer = NULL;

        }

    return static_cast<TEventReturnStatus>( event );

    }

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

// CNSPSession::UpdateSdpAsyncL

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

//

void CNSPSession::UpdateSdpAsyncL( CSdpDocument* aDocument )

    {

    NSPLOG_STR( "CNSPSession::Update(), Entry" )

    __ASSERT_ALWAYS( aDocument, User::Leave( KErrArgument ) );

    NSP_OUTPUT_UPDATESDP( KNatReady, *aDocument )

    iController.OrderUpdateSdpL( iSessionId, aDocument );

    NSPLOG_STR( "CNSPSession::Update(), Exit" )

    }

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

// CNSPSession::SessionId

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

//

TUint CNSPSession::SessionId() const

    {

    return iSessionId;

    }

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

// CNSPSession::Data

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

//

CNSPSessionData& CNSPSession::Data()

    {

    return *iSessionData;

    }

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

// CNSPSession::Container

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

//

CNSPMediaStreamContainer& CNSPSession::Container()

    {

    return *iStreamContainer;

    }

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

// CNSPSession::Plugins

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

//

CDesC8Array& CNSPSession::Plugins()

    {

    return *iProtocolsArray;

    }

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

// CNSPSession::RemoveIce

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

//

void CNSPSession::RemoveIce( CDesC8Array& aDesArray ) const

    {

    iController.RemoveIce( aDesArray );

    }

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

// CNSPSession::IsIce

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

//

TBool CNSPSession::IsIce( const TDesC8& aProtocol ) const

    {

    return iController.IsIce( aProtocol );

    }

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

// CNSPSession::Parser

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

//

const CNSPContentParser& CNSPSession::Parser() const

    {

    return iController.ContentParser();

    }

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

// CNSPSession::Role

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

//

CNSPSession::TSdpRole& CNSPSession::Role()

    {

    return iRole;

    }

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

// CNSPSession::SessionObserver

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

//

MNSPSessionObserver& CNSPSession::SessionObserver() const

    {

    return iSessionObserver;

    }

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

// CNSPSession::Actions

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

//

TNSPActionSet CNSPSession::Actions()

    {

    return TNSPActionSet( *this );

    }

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

// CNSPSession::SetSessionParam

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

//

TInt CNSPSession::SetSessionParam( CNSPPlugin::TNSPSessionParamKey aParamKey,

        TUint aParamValue )

    {

    NSPLOG_STR( "CNSPSession::SetSessionParam, Entry" )

    TInt status = KErrNone;

    switch( aParamKey )

        {

        case CNSPPlugin::ENSPResourseReservationStatusKey:

            {

            status = KErrNotSupported;

            break;

            }

        case CNSPPlugin::ENSPMediaTypeOfServiceKey:

            {

            status = iStreamContainer->SetMediaTos( aParamValue );

            break;

            }

        default:

            {

            status = KErrNotFound;

            break;

            }

        }

    NSPLOG_INT( "CNSPSession::SetSessionParam, Exit, status:", status )

    return status;

    }

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

// CNSPSession::GetSessionParam

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

//

TInt CNSPSession::GetSessionParam( CNSPPlugin::TNSPSessionParamKey aParamKey )

    {

    NSPLOG_STR( "CNSPSession::GetSessionParam, Entry" )

    TInt value = KErrNone;

    switch( aParamKey )

        {

        case CNSPPlugin::ENSPResourseReservationStatusKey:

            {

            if ( iSessionData->UseIce() )

                {

                Proceed( TNSPStateMachineEvent::EReservationStatus, value );

                value = ( KNatAsync == value ?

                          CNSPPlugin::ENSPResourcesNotReserved :

                          ( KNatReady == value ?

                            CNSPPlugin::ENSPResourcesReserved : value ) );

                }

            else

                {

                value = CNSPPlugin::ENSPResourcesReserved;

                }

            break;

            }

        case CNSPPlugin::ENSPMediaTypeOfServiceKey:

            {

            value = iStreamContainer->MediaTos();

            break;

            }

        default:

            {

            value = KErrNotFound;

            break;

            }

        }

    NSPLOG_INT( "CNSPSession::GetSessionParam, Exit, value:", value )

    return value;

    }

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

// CNSPSession::SetUseIce

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

//

void CNSPSession::SetUseIce( TBool aUseIce )

    {

    __ASSERT_ALWAYS( iSessionData, __PANIC( KErrNotFound ) );

    iSessionData->SetUseIce( aUseIce );

    }

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

// CNSPSession::Proceed

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

//

void CNSPSession::Proceed( TInt aRequest, TNatReturnStatus& aStatus )

    {

    __ASSERT_ALWAYS( iStateMachine, __PANIC( KErrNotFound ) );

    __ASSERT_ALWAYS( iSessionData, __PANIC( KErrNotFound ) );

    __ASSERT_ALWAYS( iStreamContainer, __PANIC( KErrNotFound ) );

    TNSPStateMachineEvent event( KErrNone, NULL, NULL,

    		(TNSPStateMachineEvent::TRequest) aRequest, *this );