/*

* 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:  State machine actions set implementation

*

*/

#include <sdpdocument.h>

#include "nspactionset.h"

#include "nspcontentparser.h"

#include "nspsession.h"

#include "nspmediastreamcontainer.h"

#include "nsputil.h"

#include "nspdefs.h"

#define MISMATCH( aData ) \

    ( aData.SubState() == CNSPSessionData::ESubMismatch ||\

      aData.SubState() == CNSPSessionData::ESubAll )

#define REMOTELITE( aData ) \

    ( aData.SubState() == CNSPSessionData::ESubRemoteLite ||\

      aData.SubState() == CNSPSessionData::ESubAll )

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

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

// TNSPActionSet::TNSPActionSet

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

//

TNSPActionSet::TNSPActionSet( CNSPSession& aSession )

    : iSession( aSession )

    {

    }

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

// TNSPActionSet::CreateStreamsL

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

//

TNatReturnStatus TNSPActionSet::CreateStreamsL( CSdpDocument& aDoc )

    {

    NSPLOG_STR( "TNSPActionSet::CreateStreamsL, Entry" )

    TNatReturnStatus status = iSession.Container().CreateStreamsL( aDoc );

    NSPLOG_INT( "TNSPActionSet::CreateStreamsL, status:", status )

    NSPLOG_STR( "TNSPActionSet::CreateStreamsL, Exit" )

    return status;    

    }

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

// TNSPActionSet::RemoveStreams

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

//

TNatReturnStatus TNSPActionSet::RemoveStreamsL( CSdpDocument& aDoc )

    {

    NSPLOG_STR( "TNSPActionSet::RemoveStreamsL, Entry" )

    TNatReturnStatus status = iSession.Container().RemoveStreamsL( aDoc );

    NSPLOG_INT( "TNSPActionSet::RemoveStreamsL, status:", status )

    NSPLOG_STR( "TNSPActionSet::RemoveStreamsL, Exit" )

    return status;

    }

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

// TNSPActionSet::ControlMediaL

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

//

TNatReturnStatus TNSPActionSet::ControlMediaL( TUint aStreamId,

		MNATFWConnectivityObserver::TNATFWConnectivityEvent aEvent,

		TInt aError, TAny* aData )

	{

	NSPLOG_STR( "TNSPActionSet::ControlMediaL, Entry" )

	TNatReturnStatus status =  iSession.Container().ControlMediaL(

			aStreamId, aEvent, aError, aData );

	NSPLOG_INT( "TNSPActionSet::ControlMediaL, status:", status )

	NSPLOG_STR( "TNSPActionSet::ControlMediaL, Exit" )

	return status;

	}

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

// TNSPActionSet::FirstRoundL

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

//

void TNSPActionSet::FirstRoundL( CSdpDocument& aDoc, TBool aStoreSdp )

    {

    NSPLOG_STR( "TNSPActionSet::FirstRoundL, Entry" )

    iSession.Container().ModStunSolvedL( aDoc );

    if ( aStoreSdp )

        {

        iSession.Data().SetUpdatedSdp( aDoc.CloneL() );

        }

    if ( iSession.Data().UseIce() )

        {

        iSession.Container().AddIceContentL( aDoc );

        }

    NSPLOG_STR( "TNSPActionSet::FirstRoundL, Exit" )

    }

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

// TNSPActionSet::LatterRoundL

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

//

void TNSPActionSet::LatterRoundL( CSdpDocument& aDoc )

    {

    NSPLOG_STR( "TNSPActionSet::LatterRoundL, Entry" )

    if ( iSession.Data().UseIce() )

        {

        iSession.Container().ModIceSolvedL( aDoc );

        }

    else

        {

        iSession.Container().ModStunSolvedL( aDoc );

        }

    NSPLOG_STR( "TNSPActionSet::LatterRoundL, Exit" )

    }

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

// TNSPActionSet::LocalRoundL

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

//

void TNSPActionSet::LocalRoundL( CSdpDocument& aDoc )

    {

    NSPLOG_STR( "TNSPActionSet::LocalRoundL, Entry" )

    iSession.Container().ModLocalSolvedL( aDoc );

    iSession.Parser().RemoveIceContent( aDoc );

    NSPLOG_STR( "TNSPActionSet::LocalRoundL, Exit" )

    }

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

// TNSPActionSet::UpdateRoundL

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

//

void TNSPActionSet::UpdateRoundL( CSdpDocument& aDoc )

    {

    NSPLOG_STR( "TNSPActionSet::UpdateRoundL, Entry" )

    if ( iSession.Data().UseIce() &&

         EIceRoleControlling == iSession.Data().Role() )

        {

        CSdpDocument* update = iSession.Container().CheckUpdateL( aDoc );

        if ( update )

            {

        	CleanupStack::PushL( update );

            iSession.Parser().RemoveIceContent( *update );

            iSession.Container().AddRemoteCandidatesL( *update );

            CleanupStack::Pop( update );

            iSession.UpdateSdpAsyncL( update ); // ownership changed

        	}

        }

    NSPLOG_STR( "TNSPActionSet::UpdateRoundL, Exit" )

    }

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

// TNSPActionSet::GetCredentialsL

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

//

TNatReturnStatus TNSPActionSet::GetCredentialsL( CSdpDocument& aDoc )

    {

    NSPLOG_STR( "TNSPActionSet::GetCredentialsL, Entry" )

    TNatReturnStatus status = KNatReady;

    CNATFWCredentials& credentials = iSession.Data().Credentials();

    if ( iSession.Data().UseIce() )

        {

        status = iSession.Container().GetCredentialsL( aDoc, credentials );

        }

    NSPLOG_INT( "TNSPActionSet::GetCredentialsL, status:", status )

    NSPLOG_STR( "TNSPActionSet::GetCredentialsL, Exit" )

    return status;

    }

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

// TNSPActionSet::GetCandidatesL

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

//

TNatReturnStatus TNSPActionSet::GetCandidatesL( CSdpDocument& aDoc )

    {

    NSPLOG_STR( "TNSPActionSet::GetCandidatesL, Entry" )

    TNatReturnStatus status = iSession.Container().GetCandidatesL( aDoc,

            iSession.Data().RemoteCandidates() );

    NSPLOG_INT( "TNSPActionSet::GetCandidatesL, status:", status )

    NSPLOG_STR( "TNSPActionSet::GetCandidatesL, Exit" )

    return status;

    }

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

// TNSPActionSet::GetSessionModifiersL

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

//

TNatReturnStatus TNSPActionSet::GetSessionModifiersL( CSdpDocument& aDoc,

        CNSPSession::TSdpRole aRole )

    {

    NSPLOG_STR( "TNSPActionSet::GetSessionModifiersL, Entry" )

    TNatReturnStatus status = KNatReady;

    CNSPSessionData& data = iSession.Data();

    CNSPSessionData::TSubState subState = data.SubState();

    TBool isIce = data.UseIce();

    TBool useIce = iSession.Parser().IsIceSupported( aDoc );

    TBool mismatch = iSession.Parser().IsMismatchL( aDoc );

    TBool lite = iSession.Parser().IsLiteAttribute( aDoc );

    // # 1. Mismatch

    data.SetSubState( mismatch ? CNSPSessionData::ESubMismatch : data.SubState() );

    data.SetUseIce( isIce && useIce && !MISMATCH( data ) );

    // # 2. Remote lite

    data.SetSubState( lite ? CNSPSessionData::ESubRemoteLite : data.SubState() );

    // # 3. Ice role

    if ( CNSPSession::EUndefined != aRole )

        {

        data.SetRole( OFFERER( aRole ) || REMOTELITE( data ) ?

                EIceRoleControlling : EIceRoleControlled );

        }

    status = ( ( data.SubState() == subState &&

                 isIce == data.UseIce() ) ? KNatReady : KNatAsync );

    NSPLOG_INT( "TNSPActionSet::GetSessionModifiersL, status:", status )

    NSPLOG_STR( "TNSPActionSet::GetSessionModifiersL, Exit" )

    return status;

    }

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

// TNSPActionSet::GetSessionConnInfoL

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

//

TNatReturnStatus TNSPActionSet::GetSessionConnInfoL( CSdpDocument& aDoc )

    {

    NSPLOG_STR( "TNSPActionSet::GetSessionConnInfoL, Entry" )

    TNatReturnStatus status = iSession.Container().GetSessionConnInfoL( aDoc );

    NSPLOG_INT( "TNSPActionSet::GetSessionConnInfoL, status:", status )

    NSPLOG_STR( "TNSPActionSet::GetSessionConnInfoL, Exit" )

    return status;

    }

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

// TNSPActionSet::RestartWithoutIce

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

//

void TNSPActionSet::RestartWithoutIce()

    {

    iSession.Container().ResetAndDestroyCandidates();

    iSession.RemoveIce( iSession.Plugins() );

    }

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

// TNSPActionSet::LoadPluginL

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

//

void TNSPActionSet::LoadPluginL()

    {

    NSPLOG_STR( "TNSPActionSet::LoadPluginL, Entry" )

    __ASSERT_ALWAYS( iSession.Plugins().MdcaCount(), User::Leave( KErrNotFound ) );

    TInt pluginIndex = 0;

    iSession.Container().LoadPluginL( iSession.Plugins(), pluginIndex );

    NSPLOG8_STR2( "TNSPActionSet::LoadPluginL, loaded:", iSession.Plugins()[pluginIndex] )

    NSPLOG_INT( "TNSPActionSet::LoadPluginL, useIce:", iSession.Data().UseIce() )

    NSPLOG_INT( "TNSPActionSet::LoadPluginL, pluginIndex:", pluginIndex )

    TBool isIce = iSession.IsIce( iSession.Plugins().MdcaPoint( pluginIndex ) );

    User::LeaveIfError( iSession.Data().UseIce() == isIce ? KErrNone : KErrNotFound );

    NSPLOG_STR( "TNSPActionSet::LoadPluginL, Exit" )

    }

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

// TNSPActionSet::ActivateL

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

//

void TNSPActionSet::ActivateL( CSdpDocument& aDoc )

    {

    if ( iSession.Data().UseIce() )

        {

        iSession.Container().ActivateL();

        }

    else

        {

        iSession.Container().ActivateL( aDoc );

        }

    }

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

// TNSPActionSet::DeActivateL

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

//

void TNSPActionSet::DeActivateL()

    {

    iSession.Container().DeActivateL();

    }

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

// TNSPActionSet::FetchL

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

//

void TNSPActionSet::FetchL()

    {

    if ( iSession.Data().UseIce() )

        {

        iSession.Container().FetchCandidatesL();

        }

    else

        {

        iSession.Container().FetchCandidateL();

        }

    }

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

// TNSPActionSet::SetRoleL

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

//

void TNSPActionSet::SetRoleL()

    {

    __ASSERT_ALWAYS( iSession.Data().UseIce(), User::Leave( KErrGeneral ) );

    iSession.Container().SetRoleL( iSession.Data().Role() );

    }

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

// TNSPActionSet::SetInboundCredentialsL

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

//

void TNSPActionSet::SetInboundCredentialsL()

    {

    if ( iSession.Data().UseIce() )

        {

        iSession.Container().SetInboundCredentialsL();

        }

    }

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

// TNSPActionSet::SetOutboundCredentialsL

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

//

void TNSPActionSet::SetOutboundCredentialsL()

    {

    if ( iSession.Data().UseIce() )

        {

        iSession.Container().SetOutboundCredentialsL();

        }

    }

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

// TNSPActionSet::ConnChecksL

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

//

void TNSPActionSet::ConnChecksL()

    {

    __ASSERT_ALWAYS( iSession.Data().UseIce(), User::Leave( KErrGeneral ) );

    iSession.Container().PerformCandidateChecksL( iSession.Data().RemoteCandidates() );

    }

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

// TNSPActionSet::UpdateL

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

//

void TNSPActionSet::UpdateL()

    {

    __ASSERT_ALWAYS( iSession.Data().UseIce(), User::Leave( KErrGeneral ) );

    iSession.Container().UpdateL( iSession.Data().RemoteCandidates() );

    }