/*

* Copyright (c) 2008-2009 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:  Provides cached information on IAPs and SNAPs in CommsDat.

*

*/

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <commsdat_partner.h>

#endif

#include <datamobilitycommsdattypes.h>

#include "ConnMonServ.h"

#include "CEventQueue.h"

#include "ConnMonIAP.h"

#include "ConnMonBearer.h"

#include "connmoncommsdatcache.h"

#include "log.h"

using namespace CommsDat;

TConnMonSnapEntry::TConnMonSnapEntry()

    {

    iId = 0;

    iNextLayerIapId = 0;

    iNextLayerSnapId = 0;

    iAvailability = 0;

    iNextLayerIndex = KErrNotFound;

    }

TConnMonSnapEntry::TConnMonSnapEntry(

        TUint aId,

        TUint aNextLayerIapId,

        TUint aNextLayerSnapId )

        :

        iId( aId ),

        iNextLayerIapId( aNextLayerIapId ),

        iNextLayerSnapId( aNextLayerSnapId )

    {

    iAvailability = 0;

    iNextLayerIndex = KErrNotFound;

    }

TInt TConnMonSnapEntry::Compare(

        const TConnMonSnapEntry& aFirst,

        const TConnMonSnapEntry& aSecond )

    {

    // Availability info is ignored

    if ( aFirst.iId < aSecond.iId ) return -1;

    if ( aFirst.iId > aSecond.iId ) return 1;

    if ( aFirst.iNextLayerSnapId < aSecond.iNextLayerSnapId ) return -1;

    if ( aFirst.iNextLayerSnapId > aSecond.iNextLayerSnapId ) return 1;

    if ( aFirst.iNextLayerIapId < aSecond.iNextLayerIapId ) return -1;

    if ( aFirst.iNextLayerIapId > aSecond.iNextLayerIapId ) return 1;

    return 0;

    }

TInt TConnMonSnapEntry::FindCompare(

        const TInt* aKey,

        const TConnMonSnapEntry& aEntry )

    {

    // Zero if match, negative if first is smaller, positive otherwise

    return ( *aKey ) - aEntry.iId;

    }

TBool TConnMonSnapEntry::Match(

        const TConnMonSnapEntry& aFirst,

        const TConnMonSnapEntry& aSecond )

    {

    // Availability info is ignored

    if ( ( aFirst.iId == aSecond.iId ) &&

            ( aFirst.iNextLayerIapId == aSecond.iNextLayerIapId ) &&

            ( aFirst.iNextLayerSnapId == aSecond.iNextLayerSnapId ) )

        {

        return ETrue;

        }

    return EFalse;

    }

TConnMonIapEntry::TConnMonIapEntry()

    {

    iId = 0;

    iBearerType = 0;

    iServiceType = 0;

    iAvailability = 0;

    iNextLayerIapId = 0;

    iNextLayerSnapId = 0;

    iNextLayerIndex = KErrNotFound;

    }

TConnMonIapEntry::TConnMonIapEntry(

        TUint aId,

        TUint aBearerType,

        TUint aServiceType )

        :

        iId( aId ),

        iBearerType( aBearerType ),

        iServiceType( aServiceType )

    {

    iAvailability = 0;

    iNextLayerIndex = KErrNotFound;

    iNextLayerIapId = 0;

    iNextLayerSnapId = 0;

    }

TInt TConnMonIapEntry::Compare(

        const TConnMonIapEntry& aFirst,

        const TConnMonIapEntry& aSecond )

    {

    // Zero if match, negative if first is smaller, positive otherwise

    // Availability info is ignored

    return aFirst.iId - aSecond.iId;

    }

TInt TConnMonIapEntry::FindCompare(

        const TInt* aKey,

        const TConnMonIapEntry& aEntry )

    {

    // Zero if match, negative if first is smaller, positive otherwise

    return ( *aKey ) - aEntry.iId;

    }

TBool TConnMonIapEntry::Match(

        const TConnMonIapEntry& aFirst,

        const TConnMonIapEntry& aSecond )

    {

    // Availability info is ignored

    if ( ( aFirst.iId == aSecond.iId ) &&

            ( aFirst.iBearerType == aSecond.iBearerType ) &&

            ( aFirst.iServiceType == aSecond.iServiceType ) )

        {

        return ETrue;

        }

    return EFalse;

    }

TConnMonVirtualIapEntry::TConnMonVirtualIapEntry()

    {

    iId = 0;

    iNextLayerIapId = 0;

    iNextLayerSnapId = 0;

    }

TConnMonVirtualIapEntry::TConnMonVirtualIapEntry(

        TUint aId,

        TUint aNextLayerIapId,

        TUint aNextLayerSnapId )

        :

        iId( aId ),

        iNextLayerIapId( aNextLayerIapId ),

        iNextLayerSnapId( aNextLayerSnapId )

    {

    }

TInt TConnMonVirtualIapEntry::Compare(

        const TConnMonVirtualIapEntry& aFirst,

        const TConnMonVirtualIapEntry& aSecond )

    {

    // Zero if match, negative if first is smaller, positive otherwise

    return aFirst.iId - aSecond.iId;

    }

TInt TConnMonVirtualIapEntry::FindCompare(

        const TInt* aKey,

        const TConnMonVirtualIapEntry& aEntry )

    {

    // Zero if match, negative if first is smaller, positive otherwise

    return ( *aKey ) - aEntry.iId;

    }

TBool TConnMonVirtualIapEntry::Match(

        const TConnMonVirtualIapEntry& aFirst,

        const TConnMonVirtualIapEntry& aSecond )

    {

    if ( ( aFirst.iId == aSecond.iId ) &&

            ( aFirst.iNextLayerIapId == aSecond.iNextLayerIapId ) &&

            ( aFirst.iNextLayerSnapId == aSecond.iNextLayerSnapId ) )

        {

        return ETrue;

        }

    return EFalse;

    }

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

// Two phased constructor.

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

//

CConnMonCommsDatCache* CConnMonCommsDatCache::NewL()

    {

    //LOGENTRFN("CConnMonCommsDatCache::NewL()")

    CConnMonCommsDatCache* self = CConnMonCommsDatCache::NewLC();

    CleanupStack::Pop( self );

    //LOGEXITFN("CConnMonCommsDatCache::NewL()")

    return self;

    }

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

// Two phased constructor.

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

//

CConnMonCommsDatCache* CConnMonCommsDatCache::NewLC()

    {

    //LOGENTRFN("CConnMonCommsDatCache::NewLC()")

    CConnMonCommsDatCache* self = new( ELeave ) CConnMonCommsDatCache;

    CleanupStack::PushL( self );

    self->ConstructL();

    //LOGEXITFN("CConnMonCommsDatCache::NewLC()")

    return self;

    }

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

// Destructor.

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

//

CConnMonCommsDatCache::~CConnMonCommsDatCache()

    {

    LOGENTRFN("CConnMonCommsDatCache::~CConnMonCommsDatCache()")

    if ( iSnapCache )

        {

        iSnapCache->Close();

        delete iSnapCache;

        iSnapCache = NULL;

        }

    if ( iIapCache )

        {

        iIapCache->Close();

        delete iIapCache;

        iIapCache = NULL;

        }

    if ( iVirtualIapCache )

        {

        iVirtualIapCache->Close();

        delete iVirtualIapCache;

        iVirtualIapCache = NULL;

        }

    iWlanIapIdCache.Close();

    iIapIdCache.Close();

    iSnapIdCache.Close();

    LOGEXITFN("CConnMonCommsDatCache::~CConnMonCommsDatCache()")

    }

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

// Reads all IAP and SNAP information from CommsDat and initializes the cache

// with it.

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

//

void CConnMonCommsDatCache::Init(

        CConnMonServer* aServer,

        CConnMonIAP* aConnMonIap,

        RPointerArray<TConnMonBearer>* aBearers )

    {

    LOGENTRFN("CConnMonCommsDatCache::Init()")

    iServer = aServer;

    iIap = aConnMonIap;

    iBearers = aBearers;

    if ( iInitStatus != EConnMonCacheInitNotStarted )

        {

        LOGIT("Init: ERROR, ConnMon CommsDat cache init called too many times")

        return;

        }

    iInitStatus = EConnMonCacheInitInProgress;

    // Check if WLAN bearer is available

    for ( TInt i = 0; i < iBearers->Count(); i++ )

        {

        if ( (*iBearers)[i]->BearerId() == EBearerIdWLAN )

            {

            iWlanSupportEnabled = ETrue;

            break;

            }

        }

    TRAPD( leaveCode, InitCommsDatCacheL() );

    if ( leaveCode )

        {

        LOGIT1("Init: ERROR (Ok if empty), LEAVE in ConnMon CommsDat cache init <%d>", leaveCode)

        }

    RefreshAvailabilityInfo( EFalse ); // Never send events in Init phase

    iInitStatus = EConnMonCacheInitCompleted;

    LOGEXITFN("CConnMonCommsDatCache::Init()")

    }

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

// Calls the correct method to read the CommsDat table, refered to with

// parameter aTableId, to cache. This should be called when a change is

// detected in CommsDat through central repository events.

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

//

void CConnMonCommsDatCache::RefreshCommsDatCacheL( const TUint32 aTableId )

    {

    //LOGENTRFN("CConnMonCommsDatCache::RefreshCommsDatCacheL()")

    CMDBSession* db = CMDBSession::NewLC( CMDBSession::LatestVersion() );

    db->SetAttributeMask( ECDHidden | ECDProtectedWrite );

    if ( aTableId == iIapRecordTableId )

        {

        LOGIT("RefreshCommsDatCacheL: IAP table change event")

        RefreshCommsDatIapCacheL( *db );

        }

    else if ( aTableId == iSnapRecordTableId )

        {

        LOGIT("RefreshCommsDatCacheL: SNAP table change event")

        RefreshCommsDatSnapCacheL( *db );

        }

    else if ( aTableId == iVirtualRecordTableId )

        {

        LOGIT("RefreshCommsDatCacheL: Virtual record table change event")

        RefreshCommsDatVirtualIapCacheL( *db );

        }

    else if ( aTableId == 0 )

        {

        // This option is not currently used, but provided to support the

        // possibility to read CommsDat information again when client is

        // asking for IAP/SNAP availability information as a request.

        // This would be needed in the case that CenRep change events

        // become unreliable for some reason, and thus the CommsDat cache

        // would not be reliably up to date.

        LOGIT("RefreshCommsDatCacheL: Reading all commsdat tables")

        RefreshCommsDatIapCacheL( *db );

        RefreshCommsDatSnapCacheL( *db );

        RefreshCommsDatVirtualIapCacheL( *db );

        }

    CleanupStack::PopAndDestroy( db );

    //LOGEXITFN("CConnMonCommsDatCache::RefreshCommsDatCacheL()")

    }

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

// Solves IAP and SNAP availability. The availability information in the cache

// tables will be up to date after a call to this method.

// If parameter aCanSendEvents is true, availability changed events will be

// sent to clients if any changes from previous availability state is detected.

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

//

void CConnMonCommsDatCache::RefreshAvailabilityInfo( const TBool aCanSendEvents )

    {

    LOGENTRFN("CConnMonCommsDatCache::RefreshAvailabilityInfo()")

    // If any relevant commsdat table changed.

    //

    // These flags are set to true only when CommsDat change event is received,

    // CommsDat information is read into ConnMon cache, and that information

    // has changed.

    if ( iIapsChanged || iSnapsChanged || iVirtualIapsChanged )

        {

        UpdateSnapAndVirtualIapLinks();

        iIapsChanged = EFalse;

        iSnapsChanged = EFalse;

        iVirtualIapsChanged = EFalse;

        }

    ResetAllAvailabilityInfo();

    for ( TInt i = 0; i < iBearers->Count(); i++ )

        {

        (*iBearers)[i]->FlagAvailableIaps();

        }

    SolveSnapAndVirtualIapAvailability();

    LOGIT(".")

    TBool availableIapsChanged = UpdateAvailableIaps();

    #ifdef _DEBUG

    // Print available IAP IDs to log

    for ( TInt j = 0; j < iIapCache->Count(); j++ )

        {

        if ( (*iIapCache)[j].iAvailability == EConnMonAvailabilityAvailable )

            {

            TUint currentId = (*iIapCache)[j].iId;

            if ( (*iIapCache)[j].iBearerType == EConnMonCacheBearerTypeVirtual )

                {

                switch ( (*iIapCache)[j].iServiceType )

                    {

                    case EConnMonCacheServiceTypeCsd:

                        LOGIT1("  %3d: CSD, virtual", currentId) break;

                    case EConnMonCacheServiceTypeGprs:

                        LOGIT1("  %3d: GPRS, virtual", currentId) break;

                    case EConnMonCacheServiceTypeLan:

                        LOGIT1("  %3d: LAN, virtual", currentId) break;

                    case EConnMonCacheServiceTypeWlan:

                        LOGIT1("  %3d: WLAN, virtual", currentId) break;

                    default:

                        LOGIT1("  %3d: Unknown, virtual", currentId) break;

                    }

                }

            else

                {

                switch ( (*iIapCache)[j].iServiceType )

                    {

                    case EConnMonCacheServiceTypeCsd:

                        LOGIT1("  %3d: CSD", currentId) break;

                    case EConnMonCacheServiceTypeGprs:

                        LOGIT1("  %3d: GPRS", currentId) break;

                    case EConnMonCacheServiceTypeLan:

                        LOGIT1("  %3d: LAN", currentId) break;

                    case EConnMonCacheServiceTypeWlan:

                        LOGIT1("  %3d: WLAN", currentId) break;

                    default:

                        LOGIT1("  %3d: Unknown", currentId) break;

                    }

                }

            }

        }

    #endif // _DEBUG

    TBool availableSnapsChanged = UpdateAvailableSnaps();

    // Print available SNAP IDs to log

    #ifdef _DEBUG

    TUint lastSnapId( 0 );

    for ( TInt k = 0; k < iSnapCache->Count(); k++ )

        {

        TUint currentId = (*iSnapCache)[k].iId;

        if ( currentId != lastSnapId )

            {

            lastSnapId = currentId;

            if ( (*iSnapCache)[k].iAvailability == EConnMonAvailabilityAvailable )

                {

                LOGIT1("  %4d", currentId)

                }

            }

        }

    LOGIT(".")

    #endif // _DEBUG

    if ( aCanSendEvents )

        {

        if ( availableIapsChanged )

            {

            LOGIT("RefreshAvailabilityInfo: sending IAP availability event")

            SendIapAvailabilityEvent();

            }

        if ( availableSnapsChanged )

            {

            LOGIT("RefreshAvailabilityInfo: sending SNAP availability event")

            SendSnapAvailabilityEvent();

            }

        }

    LOGEXITFN("CConnMonCommsDatCache::RefreshAvailabilityInfo()")

    }

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

// Set as available all IAPs which correspond to the given bearer ID

// (converted to service type).

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

//

void CConnMonCommsDatCache::SetAvailableIapsWithBearerId( const TUint aBearerId )

    {

    //LOGENTRFN("CConnMonCommsDatCache::SetAvailableIapsWithBearerId()")

    TInt err( KErrNone );

    TUint serviceType;

    err = ConvertBearerIdToServiceType( aBearerId, serviceType );

    if ( !err )

        {

        const TInt iapCount = iIapCache->Count();

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

            {

            if ( (*iIapCache)[i].iServiceType == serviceType )

                {

                (*iIapCache)[i].iAvailability = EConnMonAvailabilityAvailable;

                }

            }

        }

    //LOGEXITFN("CConnMonCommsDatCache::SetAvailableIapsWithBearerId()")

    }

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

// Set as available the IAP with matching ID.

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

//

void CConnMonCommsDatCache::SetAvailableIapWithId( const TUint aId )

    {

    //LOGENTRFN("CConnMonCommsDatCache::SetAvailableIapWithId()")

    TInt index = iIapCache->FindInOrder<TInt>( aId, TConnMonIapEntry::FindCompare );

    if ( index >= 0)

        {

        (*iIapCache)[index].iAvailability = EConnMonAvailabilityAvailable;

        }

    //LOGEXITFN("CConnMonCommsDatCache::SetAvailableIapWithId()")

    }

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

// Get available IAP IDs for the requested bearer ID. IAP availability is

// re-solved first.

// Maximum number of IAP IDs is limited by KConnMonMaxIAPCount.

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

//

TInt CConnMonCommsDatCache::GetAvailableIaps(

        const TUint aBearerId,

        TConnMonIapInfo& aIapInfo )

    {

    LOGENTRFN("CConnMonCommsDatCache::GetAvailableIaps()")

    TInt err( KErrNone );

    TBool availabilityEventsEnabled( EFalse );