/*
* Copyright (c) 2004 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 <centralrepository.h>
#include <unsafprotocolscrkeys.h>
#include "natfwcandidate.h"
#include "natfwcandidatepair.h"
#include "nspmediastreamcomponent.h"
#include "nsptesthelper.h"

_LIT8( KHost, "192.168.0.5" );
_LIT8( KServerReflex, "193.65.183.237" );
_LIT8( KPeerReflex, "190.0.22.14" );
_LIT8( KRelay, "172.23.0.196" );
_LIT8( KLoopback, "127.0.0.1" );



// METHODS:
// ---------------------------------------------------------------------------
// NSPTestHelper::NSPTestHelper
// ---------------------------------------------------------------------------
// 
NSPTestHelper::NSPTestHelper()
    {
    }

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

// ---------------------------------------------------------------------------
// NSPTestHelper::ClearCRepositoryL
// ---------------------------------------------------------------------------
// 
void NSPTestHelper::ClearCRepositoryL( CRepository& aRep )
    {
    RArray<TUint32> domainKeys;
    CleanupClosePushL( domainKeys );
    
    TInt error = aRep.FindL( 0x00000000, 0x00000000, domainKeys );
    
    if ( KErrNone == error )
        {
        for ( TInt index = 0; index < domainKeys.Count(); index++ )
            {
            aRep.Delete( domainKeys[index] );
            }
        }
    
    CleanupStack::PopAndDestroy(); // domainKeys
    }

// ---------------------------------------------------------------------------
// NSPTestHelper::CreateDomainKeyL
// ---------------------------------------------------------------------------
// 
void NSPTestHelper::CreateDomainKeyL( CRepository& aRep, const TDesC8& aDomain )
    {
    TInt error( KErrNone );
    TUint32 currentDomainKey( KErrNone );
    TUint32 tmp( 0 );
    TBool updateValue( EFalse );
    
    RArray<TUint32> keys;
    CleanupClosePushL( keys );
    
    aRep.FindEqL( KUNSAFProtocolsDomainMask,
            KUNSAFProtocolsFieldTypeMask, aDomain, keys );
    
    if ( keys.Count() )
        {
        tmp = keys[0];
        updateValue = ETrue;
        }
    
    if ( !updateValue )
        {
        currentDomainKey = tmp|KUNSAFProtocolsDomainMask;
        currentDomainKey &= KUNSAFProtocolsKeyMask;
        currentDomainKey |= KUNSAFProtocolsDomainMask;
        
        error = aRep.Create( currentDomainKey, aDomain );
        }
    
    User::LeaveIfError( error );
    CleanupStack::PopAndDestroy(); // keys
    }

// ---------------------------------------------------------------------------
// NSPTestHelper::SetCenrepTDesC8toAProtocolL
// ---------------------------------------------------------------------------
// 
void NSPTestHelper::SetCenrepTDesC8toAProtocolL( CRepository& aRep,
        const TUint32& aKey, const TDesC8& aValue )
    {
    TInt error = aRep.Set( aKey, aValue );
    
    if ( KErrNotFound == error )
        {
        error = aRep.Create( aKey, aValue );
        }
    
    User::LeaveIfError( error );
    }

// ---------------------------------------------------------------------------
// NSPTestHelper::GetAddr
// ---------------------------------------------------------------------------
// 
const TDesC8& NSPTestHelper::GetAddr( CNATFWCandidate::TCandidateType aType )
    {
    switch( aType )
        {
        case CNATFWCandidate::EHost:
            return KHost();
        
        case CNATFWCandidate::EServerReflexive:
            return KServerReflex();
        
        case CNATFWCandidate::EPeerReflexive:
            return KPeerReflex();
        
        case CNATFWCandidate::ERelay:
            return KRelay();
        
        default:
            return KLoopback();
        }
    }

// ---------------------------------------------------------------------------
// NSPTestHelper::CreateCandL
// ---------------------------------------------------------------------------
// 
CNATFWCandidate* NSPTestHelper::CreateCandL( const TDesC8& aFoundation,
        TUint aComponentId, TUint aProtocol, TUint aPriority,
        CNATFWCandidate::TCandidateType aType, TUint aSessionId, 
        TUint aStreamId, TBool /*aSelected*/ )
    {
    CNATFWCandidate* candidate = CNATFWCandidate::NewLC();
    
    candidate->SetFoundationL( aFoundation );
    candidate->SetComponentId( aComponentId );
    candidate->SetTransportProtocol( (TUint)aProtocol );
    candidate->SetPriority( aPriority );
    candidate->SetTransportDomainAddrL( GetAddr( aType ), aStreamId );
    candidate->SetType( aType );
    candidate->SetSessionId( aSessionId );
    candidate->SetStreamId( aStreamId );
    
    CleanupStack::Pop( candidate );
    return candidate;
    }

// ---------------------------------------------------------------------------
// NSPTestHelper::CreateCandL
// ---------------------------------------------------------------------------
// 
CNATFWCandidate* NSPTestHelper::CreateCandL(
        const CNSPMediaStreamComponent& aStreamComp,
        const TDesC8& aFoundation, TUint aProtocol,
        CNATFWCandidate::TCandidateType aType, TUint aSessionId, 
        TBool aSelected )
    {
    return CreateCandL( aFoundation, aStreamComp.ComponentId(), aProtocol,
            KPriorityMultiplier*aStreamComp.StreamId(),
            aType, aSessionId, aStreamComp.StreamId(), aSelected );
    }

// ---------------------------------------------------------------------------
// NSPTestHelper::CreateCandLC
// ---------------------------------------------------------------------------
// 
CNATFWCandidate* NSPTestHelper::CreateCandLC(
        const CNSPMediaStreamComponent& aStreamComp,
        const TDesC8& aFoundation, TUint aProtocol,
        CNATFWCandidate::TCandidateType aType, TUint aSessionId, 
        TBool aSelected )
    {
    CNATFWCandidate* candidate = 
            CreateCandL( aFoundation, aStreamComp.ComponentId(), aProtocol,
            KPriorityMultiplier*aStreamComp.StreamId(),
            aType, aSessionId, aStreamComp.StreamId(), aSelected );
    CleanupStack::PushL( candidate );
    return candidate;
    }


// ---------------------------------------------------------------------------
// NSPTestHelper::CreateCandPairL
// ---------------------------------------------------------------------------
// 
CNATFWCandidatePair* NSPTestHelper::CreateCandPairL(
        const CNSPMediaStreamComponent& aLocalStreamComp,
        const TDesC8& aLocalFoundation, TUint aLocalProtocol,
        CNATFWCandidate::TCandidateType aLocalType, TUint aLocalSessionId,
        TBool aLocalSelected,
        const CNSPMediaStreamComponent& aRemoteStreamComp,
        const TDesC8& aRemoteFoundation, TUint aRemoteProtocol,
        CNATFWCandidate::TCandidateType aRemoteType, TUint aRemoteSessionId,
        TBool aRemoteSelected )
    {
    CNATFWCandidate* local = CreateCandL(
            aLocalStreamComp, aLocalFoundation, aLocalProtocol,
            aLocalType, aLocalSessionId, aLocalSelected );
    CleanupStack::PushL( local );
    CNATFWCandidate* remote = CreateCandL(
            aRemoteStreamComp, aRemoteFoundation, aRemoteProtocol,
            aRemoteType, aRemoteSessionId, aRemoteSelected );
    CleanupStack::PushL( remote );
    CNATFWCandidatePair* candidatePair = CNATFWCandidatePair::NewL( *local, *remote );
    CleanupStack::PopAndDestroy( remote );
    CleanupStack::PopAndDestroy( local );
    return candidatePair;
    }

// ---------------------------------------------------------------------------
// NSPTestHelper::CreateCandPairLC
// ---------------------------------------------------------------------------
// 
CNATFWCandidatePair* NSPTestHelper::CreateCandPairLC(
        const CNSPMediaStreamComponent& aLocalStreamComp,
        const TDesC8& aLocalFoundation, TUint aLocalProtocol,
        CNATFWCandidate::TCandidateType aLocalType, TUint aLocalSessionId,
        TBool aLocalSelected,
        const CNSPMediaStreamComponent& aRemoteStreamComp,
        const TDesC8& aRemoteFoundation, TUint aRemoteProtocol,
        CNATFWCandidate::TCandidateType aRemoteType, TUint aRemoteSessionId,
        TBool aRemoteSelected )
    {
    CNATFWCandidate* local = CreateCandL(
            aLocalStreamComp, aLocalFoundation, aLocalProtocol,
            aLocalType, aLocalSessionId, aLocalSelected );
    CleanupStack::PushL( local );
    CNATFWCandidate* remote = CreateCandL(
            aRemoteStreamComp, aRemoteFoundation, aRemoteProtocol,
            aRemoteType, aRemoteSessionId, aRemoteSelected );
    CleanupStack::PushL( remote );
    CNATFWCandidatePair* candidatePair = CNATFWCandidatePair::NewL( *local, *remote );
    CleanupStack::PopAndDestroy( remote );
    CleanupStack::PopAndDestroy( local );
    CleanupStack::PushL( candidatePair );
    return candidatePair;
    }

//  END OF FILE