/*

* Copyright (c) 2009-2010 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:

* Keeps track of the general destination/connection method structure in

* database.

*

*/

#include <metadatabase.h>

#include <commsdattypesv1_1.h>

#include <datamobilitycommsdattypes.h>

#include <cmpluginembdestinationdef.h>

#include <wlancontainer.h>

#include "cmminstancemapping.h"

#include "cmpluginbaseeng.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmminstancemappingTraces.h"

#endif

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

// Two phased construction.

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

//

CDestination* CDestination::NewL()

    {

    OstTraceFunctionEntry0( CDESTINATION_NEWL_ENTRY );

    CDestination* self = CDestination::NewLC();

    CleanupStack::Pop( self );

    OstTraceFunctionExit0( CDESTINATION_NEWL_EXIT );

    return self;

    }

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

// Two phased construction.

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

//

CDestination* CDestination::NewLC()

    {

    OstTraceFunctionEntry0( CDESTINATION_NEWLC_ENTRY );

    CDestination* self = new( ELeave ) CDestination();

    CleanupStack::PushL( self );

    self->ConstructL();

    OstTraceFunctionExit0( CDESTINATION_NEWLC_EXIT );

    return self;

    }

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

// Destructor.

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

//

CDestination::~CDestination()

    {

    OstTraceFunctionEntry0( CDESTINATION_CDESTINATION_ENTRY );

    iConnMethodItemArray.Close();

    iUnsupportedConnMethods.Close();

    OstTraceFunctionExit0( CDESTINATION_CDESTINATION_EXIT );

    }

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

// Constructor.

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

//

CDestination::CDestination()

    {

    OstTraceFunctionEntry0( DUP1_CDESTINATION_CDESTINATION_ENTRY );

    iId = 0;

    OstTraceFunctionExit0( DUP1_CDESTINATION_CDESTINATION_EXIT );

    }

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

// Second phase constructor.

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

//

void CDestination::ConstructL()

    {

    OstTraceFunctionEntry0( CDESTINATION_CONSTRUCTL_ENTRY );

    OstTraceFunctionExit0( CDESTINATION_CONSTRUCTL_EXIT );

    }

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

// Two phased construction.

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

//

CCmmInstanceMapping* CCmmInstanceMapping::NewL( CCmmCache& aCache )

    {

    OstTraceFunctionEntry0( CCMMINSTANCEMAPPING_NEWL_ENTRY );

    CCmmInstanceMapping* self = CCmmInstanceMapping::NewLC( aCache );

    CleanupStack::Pop( self );

    OstTraceFunctionExit0( CCMMINSTANCEMAPPING_NEWL_EXIT );

    return self;

    }

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

// Two phased construction.

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

//

CCmmInstanceMapping* CCmmInstanceMapping::NewLC( CCmmCache& aCache )

    {

    OstTraceFunctionEntry0( CCMMINSTANCEMAPPING_NEWLC_ENTRY );

    CCmmInstanceMapping* self = new( ELeave ) CCmmInstanceMapping( aCache );

    CleanupStack::PushL( self );

    self->ConstructL();

    OstTraceFunctionExit0( CCMMINSTANCEMAPPING_NEWLC_EXIT );

    return self;

    }

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

// Destructor.

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

//

CCmmInstanceMapping::~CCmmInstanceMapping()

    {

    OstTraceFunctionEntry0( CCMMINSTANCEMAPPING_CCMMINSTANCEMAPPING_ENTRY );

    iConnMethodItemArray.Close();

    iUnsupportedConnMethods.Close();

    iDestinations.ResetAndDestroy();

    iDeletedConnMethods.Close();

    iDeletedDestinations.Close();

    OstTraceFunctionExit0( CCMMINSTANCEMAPPING_CCMMINSTANCEMAPPING_EXIT );

    }

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

// Constructor.

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

//

CCmmInstanceMapping::CCmmInstanceMapping( CCmmCache& aCache ) : iCache( aCache )

    {

    OstTraceFunctionEntry0( DUP1_CCMMINSTANCEMAPPING_CCMMINSTANCEMAPPING_ENTRY );

    iEasyWlanId = 0;

    OstTraceFunctionExit0( DUP1_CCMMINSTANCEMAPPING_CCMMINSTANCEMAPPING_EXIT );

    }

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

// Second phase constructor.

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

//

void CCmmInstanceMapping::ConstructL()

    {

    OstTraceFunctionEntry0( CCMMINSTANCEMAPPING_CONSTRUCTL_ENTRY );

    // Read connection methods from database and find the supported ones.

    ReadAndValidateConnMethodsL();

    // Read destinations from database.

    ReadAndValidateDestinationsL();

    OstTraceFunctionExit0( CCMMINSTANCEMAPPING_CONSTRUCTL_EXIT );

    }

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

// Resets arrays and reads CMs and Connection Methods

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

//

void CCmmInstanceMapping::RefreshL()

    {

    OstTraceFunctionEntry0( CCMMINSTANCEMAPPING_REFRESHL_ENTRY );

    ReadAndValidateConnMethodsL();

    ReadAndValidateDestinationsL();

    OstTraceFunctionExit0( CCMMINSTANCEMAPPING_REFRESHL_EXIT );

    }

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

// Check if the given ID is a valid existing destination ID.

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

//

TBool CCmmInstanceMapping::ValidDestinationId( const TUint32 aId ) const

    {

    OstTraceFunctionEntry0( CCMMINSTANCEMAPPING_VALIDDESTINATIONID_ENTRY );

    TBool validity( EFalse );

    if ( aId > 0 )

        {

        for ( TInt i = 0; i < iDestinations.Count(); i++ )

            {

            if ( iDestinations[i]->iId == aId )

                {

                validity = ETrue;

                break;

                }

            }

        }

    OstTraceFunctionExit0( CCMMINSTANCEMAPPING_VALIDDESTINATIONID_EXIT );

    return validity;

    }

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

// Check if the given ID is a valid existing connection method ID.

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

//

TBool CCmmInstanceMapping::ValidConnMethodId( const TUint32 aId ) const

    {

    OstTraceFunctionEntry0( CCMMINSTANCEMAPPING_VALIDCONNMETHODID_ENTRY );

    TBool validity( EFalse );

    if ( aId > 0 )

        {

        for ( TInt i = 0; i < iConnMethodItemArray.Count(); i++ )

            {

            if ( iConnMethodItemArray[i].iId == aId )

                {

                validity = ETrue;

                break;

                }

            }

        }

    OstTraceFunctionExit0( CCMMINSTANCEMAPPING_VALIDCONNMETHODID_EXIT );

    return validity;

    }

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

// Check if the given ID is a valid existing unsupported connection method ID.

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

//

TBool CCmmInstanceMapping::UnsupportedConnMethodId( const TUint32 aId ) const

    {

    OstTraceFunctionEntry0( CCMMINSTANCEMAPPING_UNSUPPORTEDCONNMETHODID_ENTRY );

    TBool validity( EFalse );

    if ( aId > 0 )

        {

        for ( TInt i = 0; i < iUnsupportedConnMethods.Count(); i++ )

            {

            if ( iUnsupportedConnMethods[i] == aId )

                {

                validity = ETrue;

                break;

                }

            }

        }

    OstTraceFunctionExit0( CCMMINSTANCEMAPPING_UNSUPPORTEDCONNMETHODID_EXIT );

    return validity;

    }

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

// Check from database if the given destination is an embedded destination in

// any other destination.

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

//

TBool CCmmInstanceMapping::DestinationIsEmbedded( const TUint32 aDestinationId ) const

    {

    OstTraceFunctionEntry0( CCMMINSTANCEMAPPING_DESTINATIONISEMBEDDED_ENTRY );

    TBool result( EFalse );

    TInt index( 0 );

    // Iterate through all destinations.

    for ( TInt i = 0; i < iDestinations.Count(); i++ )

        {

        // An embedded destination is always at the very last position in

        // the connection method item array.

        index = iDestinations[i]->iConnMethodItemArray.Count() - 1;

        if ( index >= 0 )

            {

            // We can skip bearer type check. If the last item isn't an

            // embedded destination, the ID will not match anyway.

            if ( iDestinations[i]->iConnMethodItemArray[index].iId == aDestinationId )

                {

                result = ETrue;

                break;

                }

            }

        }

    OstTraceFunctionExit0( CCMMINSTANCEMAPPING_DESTINATIONISEMBEDDED_EXIT );

    return result;

    }

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

// Check from database if the given destination has an embedded destination.

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

//

TBool CCmmInstanceMapping::DestinationHasEmbedded( const TUint32 aDestinationId ) const

    {

    OstTraceFunctionEntry0( CCMMINSTANCEMAPPING_DESTINATIONHASEMBEDDED_ENTRY );

    TBool result( EFalse );

    for ( TInt i = 0; i < iDestinations.Count(); i++ )

        {

        // Find the correct destination.

        if ( iDestinations[i]->iId == aDestinationId )

            {

            // An embedded destination is always at the very last position in

            // the connection method item array.

            TInt index = iDestinations[i]->iConnMethodItemArray.Count() - 1;

            if ( index >= 0 )

                {

                if ( iDestinations[i]->iConnMethodItemArray[index].IsEmbedded() )

                    {

                    result = ETrue;

                    }

                }

            break;

            }

        }

    OstTraceFunctionExit0( CCMMINSTANCEMAPPING_DESTINATIONHASEMBEDDED_EXIT );

    return result;

    }

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

// Check from database if the given destination is pointed to by any virtual

// IAP.

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

//

TBool CCmmInstanceMapping::DestinationPointedToByVirtualIap(

        const TUint32 aDestinationId ) const

    {

    OstTraceFunctionEntry0( CCMMINSTANCEMAPPING_DESTINATIONPOINTEDTOBYVIRTUALIAP_ENTRY );

    TBool result( EFalse );

    if ( aDestinationId > 0 )

        {

        for ( TInt i = 0; i < iConnMethodItemArray.Count(); i++ )

            {

            if ( iConnMethodItemArray[i].LinkedSnapId() == aDestinationId )

                {

                result = ETrue;

                break;

                }

            }

        }

    OstTraceFunctionExit0( CCMMINSTANCEMAPPING_DESTINATIONPOINTEDTOBYVIRTUALIAP_EXIT );

    return result;

    }

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

// Check from database if the given connection method is pointed to by any

// virtual IAP.

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

//

TBool CCmmInstanceMapping::ConnMethodPointedToByVirtualIap(

        const TUint32 aConnMethodId ) const

    {

    OstTraceFunctionEntry0( CCMMINSTANCEMAPPING_CONNMETHODPOINTEDTOBYVIRTUALIAP_ENTRY );

    TBool result( EFalse );

    if ( aConnMethodId > 0 )

        {

        for ( TInt i = 0; i < iConnMethodItemArray.Count(); i++ )

            {

            if ( iConnMethodItemArray[i].LinkedIapId() == aConnMethodId )

                {

                result = ETrue;

                break;

                }

            }

        }

    OstTraceFunctionExit0( CCMMINSTANCEMAPPING_CONNMETHODPOINTEDTOBYVIRTUALIAP_EXIT );

    return result;

    }

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

// Check if the given connection method is the only connection method in the

// given destination and if a virtual IAP points to that destination.

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

//

TBool CCmmInstanceMapping::ConnMethodInDestinationButLocked(

        const TUint32 aConnMethodId,

        const TUint32 aDestinationId ) const

    {

    OstTraceFunctionEntry0( CCMMINSTANCEMAPPING_CONNMETHODINDESTINATIONBUTLOCKED_ENTRY );

    TBool result( EFalse );

    // Find destination.

    CDestination* destination( NULL );

    destination = GetDestination( aDestinationId );

    if ( destination )

        {

        // Check if the destination has only 1 IAP.

        if ( destination->iConnMethodItemArray.Count() == 1 )

            {

            // Check if the IAP has given ID.

            if ( destination->iConnMethodItemArray[0].iId == aConnMethodId )

                {

                // Check if this destination is linked from a virtual IAP.

                result = DestinationPointedToByVirtualIap( aDestinationId );

                }

            }

        }

    OstTraceFunctionExit0( CCMMINSTANCEMAPPING_CONNMETHODINDESTINATIONBUTLOCKED_EXIT );

    return result;

    }

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

// Get bearer type of connection method matching given ID.

// Return KErrNone if ID is found, KErrNotFound if not.

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

//

TInt CCmmInstanceMapping::GetConnMethodBearerType(

        const TUint32 aConnMethodId,

        TUint32& bearerType ) const

    {

    OstTraceFunctionEntry0( CCMMINSTANCEMAPPING_GETCONNMETHODBEARERTYPE_ENTRY );

    TInt result( KErrNotFound );

    for ( TInt i = 0; i < iConnMethodItemArray.Count(); i++ )

        {

        if ( iConnMethodItemArray[i].iId == aConnMethodId )

            {

            bearerType = iConnMethodItemArray[i].iBearerType;

            result = KErrNone;

            break;

            }

        }

    if ( result == KErrNotFound )

        {

        // Embedded destinations are not in connection method array.

        if ( aConnMethodId > KCmmDestIdIntervalMin && aConnMethodId < KCmmDestIdIntervalMax )

            {

            if ( ValidDestinationId( aConnMethodId ) )

                {

                bearerType = KUidEmbeddedDestination;

                result = KErrNone;

                }

            }

        }

    OstTraceFunctionExit0( CCMMINSTANCEMAPPING_GETCONNMETHODBEARERTYPE_EXIT );

    return result;

    }

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

// Returns the number of destinations the provided connection method belongs

// to. Zero is returned if the connection method belongs to no destination

// (legacy IAP) or does not exist.

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

//

TInt CCmmInstanceMapping::DestinationsContainingConnMethod(

        const TUint32 aConnMethodId ) const

    {

    OstTraceFunctionEntry0( CCMMINSTANCEMAPPING_CONNMETHODREFERENCECOUNT_ENTRY );

    TInt referenceCount( 0 );

    TInt count( 0 );

    // Go through each destination.

    for ( TInt i = 0; i < iDestinations.Count(); i++ )

        {

        TBool foundInThisDestination( EFalse );

        // Loop through all connection methods in this destination.

        count = iDestinations[i]->iConnMethodItemArray.Count();

        for ( TInt j = 0; j < count; j++ )

            {

            if ( iDestinations[i]->iConnMethodItemArray[j].iId == aConnMethodId )

                {

                foundInThisDestination = ETrue;

                referenceCount++;

                break;

                }

            }

        // Check unsupported connection methods also.

        if ( !foundInThisDestination )

            {

            count = iDestinations[i]->iUnsupportedConnMethods.Count();

            for ( TInt j = 0; j < count; j++ )

                {

                if ( iDestinations[i]->iUnsupportedConnMethods[j] == aConnMethodId )

                    {

                    referenceCount++;

                    break;

                    }

                }

            }

        }

    OstTraceFunctionExit0( CCMMINSTANCEMAPPING_CONNMETHODREFERENCECOUNT_EXIT );

    return referenceCount;

    }

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

// Returns the destination IDs containing the connection method given as

// parameter.