/*

* 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 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].iBearerType == KUidEmbeddedDestination )

                    {

                    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 );

    OstTraceFunctionExit0( CCMMINSTANCEMAPPING_DESTINATIONPOINTEDTOBYVIRTUALIAP_EXIT );

    return EFalse; //TODO, virtual IAPs are not yet supported.

    }

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

// 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 );

    OstTraceFunctionExit0( CCMMINSTANCEMAPPING_CONNMETHODPOINTEDTOBYVIRTUALIAP_EXIT );

    return EFalse; //TODO, virtual IAPs are not yet supported.

    }

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

// 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 );

    // - Find correct destination.

    // - Check if it only has 1 CM.

    // - Check if the CM is the one given.

    // - Call DestinationPointedToByVirtualIap( aDestinationId ).

    //

    OstTraceFunctionExit0( CCMMINSTANCEMAPPING_CONNMETHODINDESTINATIONBUTLOCKED_EXIT );

    return EFalse; //TODO, virtual IAPs are not yet supported.

    }

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

// 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, need check from ID range.

        if ( aConnMethodId > KCmmDestIdIntervalMin && aConnMethodId < KCmmDestIdIntervalMax )

            {

            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;

    }

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

// Get database session.

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

//

CommsDat::CMDBSession& CCmmInstanceMapping::Session() const

    {

    OstTraceFunctionEntry0( CCMMINSTANCEMAPPING_SESSION_ENTRY );

    return iCache.Session();

    }

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

// Discovers all connection methods from database. Unsupported connection

// methods are kept separately.

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

//

void CCmmInstanceMapping::ReadAndValidateConnMethodsL()

    {

    OstTraceFunctionEntry0( CCMMINSTANCEMAPPING_READANDVALIDATECONNMETHODSL_ENTRY );

    CMDBRecordSet<CCDIAPRecord>* iapRecordSet =

            new( ELeave ) CMDBRecordSet<CCDIAPRecord>( KCDTIdIAPRecord );

    CleanupStack::PushL( iapRecordSet );

    CCDIAPRecord* iapRecord = static_cast<CCDIAPRecord*>( CCDRecordBase::RecordFactoryL( KCDTIdIAPRecord ) );

    CleanupStack::PushL( iapRecord );

    TRAP_IGNORE( iapRecordSet->LoadL( Session() ) );

    //TODO, check from commsdat dump if all high-range IDs are available, or was some records

    //TODO  used up by something. will this possibly affect cm/destination creation with predef ID? (Keijo)

    iConnMethodItemArray.Reset();

    iUnsupportedConnMethods.Reset();

    TInt iapRecordCount( iapRecordSet->iRecords.Count() );

    TInt err( KErrNone );

    TUint32 bearerType( 0 );

    TUint bearerPriority( CMManager::KDataMobilitySelectionPolicyPriorityWildCard );

    for ( TInt i = 0; i < iapRecordCount; i++ )

        {

        TUint32 connMethodId( iapRecordSet->iRecords[i]->RecordId() );

        // Check the connection method is not on the deleted list waiting to be deleted from database.

        TInt indexInDeletedList = iDeletedConnMethods.FindInOrder( ( TUint )connMethodId );

        if ( indexInDeletedList == KErrNotFound )

            {

            // Check the bearer type of the iap. Leaves if iap is unsupported.

            iapRecord->SetRecordId( connMethodId );

            TRAP( err, iCache.BearerInfoFromIapRecordL( iapRecord, bearerType, bearerPriority ) ); //TODO

            if ( !err )

                {

                TCmmConnMethodItem item( connMethodId, bearerType, bearerPriority, 0 );

                iConnMethodItemArray.Append( item ); // Ignore errors.

                }

            else if ( err == KErrNotSupported )

                {

                iUnsupportedConnMethods.Append( connMethodId ); // Ignore errors.

                }

            else if ( err == KErrNoMemory )

                {

                User::Leave( err ); //TODO, check what this will cause.

                }

            }

        }

    CleanupStack::PopAndDestroy( iapRecord );

    CleanupStack::PopAndDestroy( iapRecordSet );

    OstTraceFunctionExit0( CCMMINSTANCEMAPPING_READANDVALIDATECONNMETHODSL_EXIT );

    }

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

// Discovers all destinations and the connection methods inside them.

// Unsupported connection methods are kept separately.

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

//

void CCmmInstanceMapping::ReadAndValidateDestinationsL()

    {

    OstTraceFunctionEntry0( CCMMINSTANCEMAPPING_READANDVALIDATEDESTINATIONSL_ENTRY );