/*

* 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:    ICE Communication tests

*

*/

#include "natcomtest.h"

#include "natfwconnectivityapi.h"

#include "natfwcredentials.h"

#include <e32cons.h>

#include "natfwconnectivityapidefs.h"

#include <e32debug.h>

#include "natfwcandidate.h"

#include "natfwcandidatepair.h"

#include <mmccinterfacedef.h>

#include <badesca.h>

#include "natcomtestobserver.h"

#include "testdefinitions.hrh"

#include "natfwtestconsolelogs.h"

#include "natcomteststate.h"

#include "mccmediastream.h"

#include "mccsession.h"

#include "mcclink.h"

const TInt KQoS = 45;

const TInt KStreamCollectionId = 1;

const TInt KRtpMediaComponentId = 1;

const TInt KRtcpMediaComponentId = 2;

_LIT8( KMOUsername, "icemo" );

_LIT8( KMTUsername, "icemt" );

_LIT8( KNATStun, "nokia.stun" );

_LIT8( KNATTurn, "nokia.turn" );

_LIT8( KNATIce, "nokia.ice" );

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

// CNatComTest::CNatComTest

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

//

CNatComTest::CNatComTest( TUint32 aIapId, MNatComTestObserver& aObserver ) :

    CActive( CActive::EPriorityStandard ), iIapId( aIapId ),

    iObserver( aObserver )

    {

    iOnlyCandidates = EFalse;

    iState = EReady;

    }

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

// CNatComTest::ConstructL

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

//   

void CNatComTest::ConstructL( const TDesC8& aDomain )

    {

    __NATFWTESTCONSOLE( "CNatComTest::ConstructL -Start" )

    const TInt KDefaultGranularity = 1;

    CActiveScheduler::Add( this );

    iDomain = aDomain.AllocL();

    iNat = CNATFWConnectivityApi::NewL();

    iNat->RegisterObserverForEventsL( *this,

        MNATFWConnectivityObserver::EAllEvents );

    iSession = CMccSession::NewL( iIapId );

    iPlugins = new ( ELeave ) CDesC8ArrayFlat( KDefaultGranularity );

    __NATFWTESTCONSOLE( "CNatComTest::ConstructL -End" )

    }

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

// CNatComTest::NewL

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

//

CNatComTest* CNatComTest::NewL( const TDesC8& aDomain, TUint32 aIapId,

    MNatComTestObserver& aObserver )

    {

    __NATFWTESTCONSOLE( "CNatComTest::NewL" )

    CNatComTest* self = CNatComTest::NewLC( aDomain, aIapId, aObserver ); 

    CleanupStack::Pop( self );

    return self;

    }

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

// CNatComTest::NewLC

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

//

CNatComTest* CNatComTest::NewLC( const TDesC8& aDomain, TUint32 aIapId,

    MNatComTestObserver& aObserver )

    {

    __NATFWTESTCONSOLE( "CNatComTest::NewLC" )

    CNatComTest* self = new (ELeave) CNatComTest( aIapId, aObserver );

    CleanupStack::PushL( self );

    self->ConstructL( aDomain );

    return self;

    }

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

// CNatComTest::~CNatComTest

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

//

CNatComTest::~CNatComTest()

    {

    Cancel();

    delete iSession;

    delete iDomain;

    delete iNat;

    delete iPlugins;

    iLocalCandidates.ResetAndDestroy();

    iCandidatePairs.ResetAndDestroy();

    iStreamIds.Close();

    }

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

// CNatComTest::FetchCandidates

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

//  

TInt CNatComTest::OnlyFetchCandidates( TUint aProtocol )

    {

    iOnlyCandidates = ETrue;

    return StartUsingIce( aProtocol, EIceRoleControlling );

    }

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

// CNatComTest::StoreLocalCondidates

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

//  

TInt CNatComTest::StoreLocalCondidates( TUint aProtocol,

    TBool aUseRtcp )

    {

    RArray<TNatComState> sequence;

    TInt err;

    iPlugins->Reset();

    TRAP( err, iPlugins->AppendL( KNATIce ) );

    if ( err )

        {

        return err;

        }

    if ( aUseRtcp )

        {

        sequence.Append( ECreateSession );

        sequence.Append( ELoadPlugin );

        sequence.Append( ECreateRtpStream );

        sequence.Append( EFetchRtpCandidates );

        sequence.Append( ECreateRtcpStream );

        sequence.Append( EFetchRtcpCandidates );

        sequence.Append( EStoreLocalCandidates );

        sequence.Append( EEnd );

        }

    else

        {

        sequence.Append( ECreateSession );

        sequence.Append( ELoadPlugin );

        sequence.Append( ECreateRtpStream );

        sequence.Append( EFetchRtpCandidates );

        sequence.Append( EStoreLocalCandidates );

        sequence.Append( EEnd );

        }

    iStateSequence.SetSequence( sequence );

    iStateSequence.SetTestType( EIceComTest );

    SetTeardownSequence( EIceComTest, aUseRtcp );

    err = Start( aProtocol, EIceRoleControlling );

    sequence.Close();

    return err;

    }

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

// CNatComTest::StoreLocalCandidate

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

// 

TInt CNatComTest::StoreLocalCandidate( TUint aProtocol, TComTestType aTestType,

    TBool aUseRtcp )

    {

    RArray<TNatComState> sequence;

    TInt err = KErrNone;

    if ( aUseRtcp )

        {

        sequence.Append( ECreateSession );

        sequence.Append( ELoadPlugin );

        sequence.Append( ECreateRtpStream );

        sequence.Append( EFetchRtpCandidate );

        sequence.Append( ECreateRtcpStream );

        sequence.Append( EFetchRtcpCandidate );

        sequence.Append( EStoreLocalCandidates );

        sequence.Append( EEnd );

        }

    else

        {

        sequence.Append( ECreateSession );

        sequence.Append( ELoadPlugin );

        sequence.Append( ECreateRtpStream );

        sequence.Append( EFetchRtpCandidate );

        sequence.Append( EStoreLocalCandidates );

        sequence.Append( EEnd );

        }

    iStateSequence.SetSequence( sequence );

    iStateSequence.SetTestType( aTestType );

    SetTeardownSequence( aTestType, aUseRtcp );

    iPlugins->Reset();

    if ( EStunComTest == aTestType )

        {

        TRAP( err, iPlugins->AppendL( KNATStun ) );

        }

    if ( ETurnComTest == aTestType)

        {

        TRAP( err, iPlugins->AppendL( KNATTurn ) );

        }

    if ( err )

        {

        return err;

        }

    err = Start( aProtocol, EIceRoleControlling );

    sequence.Close();

    return err;

    }

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

// CNatComTest::StartComTest

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

// 

TInt CNatComTest::StartComTest( TUint aProtocol, TComTestType aTestType,

        TBool aUseRtcp )

    {

    RArray<TNatComState> sequence;

    TInt err = KErrNone;

    if ( aUseRtcp )

        {

        sequence.Append( ECreateSession );

        sequence.Append( ELoadPlugin );

        sequence.Append( ECreateRtpStream );

        sequence.Append( EFetchRtpCandidate );

        sequence.Append( ECreateRtcpStream );

        sequence.Append( EFetchRtcpCandidate );

        sequence.Append( ECreateRtpWrapper );

        sequence.Append( ECreateRtcpWrapper );

        sequence.Append( EPrepareMccLink );

        sequence.Append( ESetOutgoingAddr );

        sequence.Append( ECreateMediaUpStream );

        sequence.Append( ECreateMediaDownStream );

        sequence.Append( ESetWrapperIncomingAddr );

        sequence.Append( EPause );

        sequence.Append( ESetRtpReceivingState );

        sequence.Append( ESetRtcpReceivingState );

        sequence.Append( ESetRtpSendingState );

        sequence.Append( ESetRtcpSendingState );

        sequence.Append( EStartMediaDownStream );

        sequence.Append( EStartMediaUpStream );

        sequence.Append( ERunning );

        }

    else

        {

        sequence.Append( ECreateSession );

        sequence.Append( ELoadPlugin );

        sequence.Append( ECreateRtpStream );

        sequence.Append( EFetchRtpCandidate );

        sequence.Append( ECreateRtpWrapper );

        sequence.Append( EPrepareMccLink );

        sequence.Append( ESetOutgoingAddr );

        sequence.Append( ECreateMediaUpStream );

        sequence.Append( ECreateMediaDownStream );

        sequence.Append( ESetWrapperIncomingAddr );

        sequence.Append( EPause );

        sequence.Append( ESetRtpReceivingState );

        sequence.Append( ESetRtpSendingState );

        sequence.Append( EStartMediaDownStream );   

        sequence.Append( EStartMediaUpStream );

        sequence.Append( ERunning ); 

        }

    iStateSequence.SetSequence( sequence );

    iStateSequence.SetTestType( aTestType );

    SetTeardownSequence( aTestType, aUseRtcp );

    iPlugins->Reset();

    if ( EStunComTest == aTestType )

        {

        TRAP( err, iPlugins->AppendL( KNATStun ) );

        }

    if ( ETurnComTest == aTestType)

        {

        TRAP( err, iPlugins->AppendL( KNATTurn ) );

        }

    if ( err )

        {

        return err;

        }

    err = Start( aProtocol, EIceRoleControlling );

    sequence.Close();

    return err;

    }

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

// CNatComTest::StartUsingIce

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

//  

TInt CNatComTest::StartUsingIce( TUint aProtocol,

    TNATFWIceRole aRole, TBool aUseRtcp )

    {

    RArray<TNatComState> sequence;

    TInt err;

    iPlugins->Reset();

    TRAP( err, iPlugins->AppendL( KNATIce ) );

    if ( err )

        {

        return err;

        }

    if ( aUseRtcp )

        {

        sequence.Append( ECreateSession );

        sequence.Append( ELoadPlugin );

        sequence.Append( ECreateRtpStream );

        sequence.Append( EFetchRtpCandidates );

        sequence.Append( ECreateRtcpStream );

        sequence.Append( EFetchRtcpCandidates );

        sequence.Append( ESetOperationMode );

        sequence.Append( ESetIdentification );

        sequence.Append( EPause );

        sequence.Append( EConnectivityChecks );

        sequence.Append( EPause );

        sequence.Append( ECreateRtpWrapper );

        sequence.Append( ECreateRtcpWrapper );

        sequence.Append( EPrepareMccLink );

        sequence.Append( ESetOutgoingAddr );

        sequence.Append( ECreateMediaUpStream );

        sequence.Append( ECreateMediaDownStream );

        sequence.Append( ESetWrapperIncomingAddr );

        sequence.Append( EPause );

        if ( EIceRoleControlling == aRole )

            {

            sequence.Append( ESetRtpReceivingState );

            sequence.Append( ESetRtcpReceivingState );

            sequence.Append( ESetRtpSendingStateIce );

            sequence.Append( ESetRtcpSendingStateIce );

            sequence.Append( EStartMediaUpStream );

            sequence.Append( EStartMediaDownStream );

            }

         else

            {

            sequence.Append( ESetRtpReceivingState );

            sequence.Append( ESetRtcpReceivingState );

            sequence.Append( ESetRtpSendingStateIce );

            sequence.Append( ESetRtcpSendingStateIce );

            sequence.Append( EStartMediaDownStream );

            sequence.Append( EStartMediaUpStream );

            }

        sequence.Append( ERunning );

        }

    else

        { 

        sequence.Append( ECreateSession );

        sequence.Append( ELoadPlugin );

        sequence.Append( ECreateRtpStream );

        sequence.Append( EFetchRtpCandidates );

        sequence.Append( ESetOperationMode );

        sequence.Append( ESetIdentification );

        sequence.Append( EPause );

        sequence.Append( EConnectivityChecks );

        sequence.Append( EPause );

        sequence.Append( ECreateRtpWrapper );

        sequence.Append( EPrepareMccLink );

        sequence.Append( ESetOutgoingAddr );

        sequence.Append( ECreateMediaUpStream );

        sequence.Append( ECreateMediaDownStream );

        sequence.Append( ESetWrapperIncomingAddr );

        sequence.Append( EPause );

        if ( EIceRoleControlling == aRole )

            {

            sequence.Append( ESetRtpReceivingState );

            sequence.Append( ESetRtpSendingStateIce );  

            sequence.Append( EStartMediaUpStream );

            sequence.Append( EStartMediaDownStream );    

            }

        else

            {

            sequence.Append( ESetRtpReceivingState );

            sequence.Append( ESetRtpSendingStateIce );

            sequence.Append( EStartMediaDownStream );

            sequence.Append( EStartMediaUpStream );

            }

        sequence.Append( ERunning );

        }

    iStateSequence.SetSequence( sequence );

    iStateSequence.SetTestType( EIceComTest );

    SetTeardownSequence( EIceComTest, aUseRtcp );

    err = Start( aProtocol, aRole );

    sequence.Close();

    return err;

    }

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

// CNatComTest::SetTeardownSequence

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

// 

void CNatComTest::SetTeardownSequence( TInt aTestType, TBool aUseRtcp )

    {

    RArray<TNatComState> sequence;

    if ( aUseRtcp )

        {

        if ( EIceComTest == aTestType )

            {

            sequence.Append( EPassiveRtpSendingStateIce );

            sequence.Append( EPassiveRtcpSendingStateIce );

            }

        else

            {

            sequence.Append( EPassiveRtpSendingState );

            sequence.Append( EPassiveRtcpSendingState );

            }

        sequence.Append( EPassiveRtcpReceivingState );

        sequence.Append( EPassiveRtpReceivingState );

        sequence.Append( ETeardown );

        }

    else

        {

        if ( EIceComTest == aTestType )

            {

            sequence.Append( EPassiveRtpSendingStateIce );

            } 

        else

            {

            sequence.Append( EPassiveRtpSendingState );

            }

        sequence.Append( EPassiveRtpReceivingState );

        sequence.Append( ETeardown );

        }

    iTeardownSequence.SetSequence( sequence );

    iTeardownSequence.SetTestType( aTestType );

    sequence.Close();

    }

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

// CNatComTest::Start

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

//    

TInt CNatComTest::Start( TUint aProtocol,

    TNATFWIceRole aRole )

    {

    if ( EReady != iState )

        {

        return KErrInUse;

        }

    iMode = aRole;

    iProtocol = aProtocol;

    iState = iStateSequence.Current();

    ActiveRequestCompleted( KErrNone );

    return KErrNone;

    }

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

// CNatComTest::StopL

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

//    

void CNatComTest::StopL()

    {

    RDebug::Print( _L("TEST PRINT: CNatComTest::StopL" ) );

    if ( EReady != iState )

        {

        Cancel();

        iState = EEnd;

        ActiveRequestCompleted( KErrNone );

        }

    }

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

// CNatComTest::TeardownL

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

//

void CNatComTest::TeardownL()

    {

    RDebug::Print( _L("TEST PRINT: CNatComTest::TeardownL -start" ) );

    if ( iUpStreamId )

        {

        iSession->CloseMediaStreamL( iUpStreamId );

        iUpStreamId = 0;

        }

    if ( iDownStreamId )

        {

        iSession->CloseMediaStreamL( iDownStreamId );

        iDownStreamId = 0;

        }

    if ( iLinkId )

        {

        iSession->CloseLinkL( iLinkId );

        }

    if ( iRtpStreamId )

        {

        iNat->CloseStreamL( iSessionId, iRtpStreamId );

        }

    if ( iRtcpStreamId )

        {

        iNat->CloseStreamL( iSessionId, iRtcpStreamId );

        }

    if ( iSessionId )

        {