/*

* 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:

* Implementation of the bearer priority array cache.

*

*/

#include <datamobilitycommsdattypes.h>

#include <cmmanagerdef.h>

#include "cmmbearerprioritycache.h"

#include "cmmbearerpriority.h"

#include "cmmtransactionhandler.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmmbearerprioritycacheTraces.h"

#endif

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

// Two phased construction.

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

//

CCmmBearerPriorityCache* CCmmBearerPriorityCache::NewL(

        CCmmTransactionHandler* aTrans,

        CommsDat::TMDBElementId aBearerPriorityTableId )

    {

    OstTraceFunctionEntry0( CCMMBEARERPRIORITYCACHE_NEWL_ENTRY );

    CCmmBearerPriorityCache* self =

            CCmmBearerPriorityCache::NewLC( aTrans, aBearerPriorityTableId );

    CleanupStack::Pop( self );

    OstTraceFunctionExit0( CCMMBEARERPRIORITYCACHE_NEWL_EXIT );

    return self;

    }

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

// Two phased construction.

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

//

CCmmBearerPriorityCache* CCmmBearerPriorityCache::NewLC(

        CCmmTransactionHandler* aTrans,

        CommsDat::TMDBElementId aBearerPriorityTableId )

    {

    OstTraceFunctionEntry0( CCMMBEARERPRIORITYCACHE_NEWLC_ENTRY );

    CCmmBearerPriorityCache* self =

            new( ELeave ) CCmmBearerPriorityCache( aTrans, aBearerPriorityTableId );

    CleanupStack::PushL( self );

    self->ConstructL();

    OstTraceFunctionExit0( CCMMBEARERPRIORITYCACHE_NEWLC_EXIT );

    return self;

    }

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

// Destructor.

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

//

CCmmBearerPriorityCache::~CCmmBearerPriorityCache()

    {

    OstTraceFunctionEntry0( CCMMBEARERPRIORITYCACHE_CCMMBEARERPRIORITYCACHE_ENTRY );

    iArray.ResetAndDestroy();

    OstTraceFunctionExit0( CCMMBEARERPRIORITYCACHE_CCMMBEARERPRIORITYCACHE_EXIT );

    }

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

// Constructor.

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

//

CCmmBearerPriorityCache::CCmmBearerPriorityCache(

        CCmmTransactionHandler* aTrans,

        CommsDat::TMDBElementId aBearerPriorityTableId )

        :

        iTrans( aTrans ),

        iArray(),

        iBearerPriorityTableId( aBearerPriorityTableId )

    {

    OstTraceFunctionEntry0( DUP1_CCMMBEARERPRIORITYCACHE_CCMMBEARERPRIORITYCACHE_ENTRY );

    OstTraceFunctionExit0( DUP1_CCMMBEARERPRIORITYCACHE_CCMMBEARERPRIORITYCACHE_EXIT );

    }

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

// Second phase constructor.

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

//

void CCmmBearerPriorityCache::ConstructL()

    {

    OstTraceFunctionEntry0( CCMMBEARERPRIORITYCACHE_CONSTRUCTL_ENTRY );

    // Read initial bearer priority array from commsdat.

    ReadL();

    OstTraceFunctionExit0( CCMMBEARERPRIORITYCACHE_CONSTRUCTL_EXIT );

    }

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

// Updates the bearer priority array with the contents of aArray.

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

//

void CCmmBearerPriorityCache::UpdateL( const RPointerArray<CCmmBearerPriority>& aArray )

    {

    OstTraceFunctionEntry0( CCMMBEARERPRIORITYCACHE_UPDATEL_ENTRY );

    iTrans->OpenTransactionLC();

    CommsDat::CMDBRecordSet<CCDGlobalBearerTypePriorizationRecord>* bpRS =

            new( ELeave ) CommsDat::CMDBRecordSet<CCDGlobalBearerTypePriorizationRecord>(

                    iBearerPriorityTableId );

    CleanupStack::PushL( bpRS );

    // Delete the old records.

    TRAP_IGNORE( bpRS->LoadL( iTrans->Session() ) );

    for ( TInt i = 0; i < bpRS->iRecords.Count(); i++ )

        {

        bpRS->iRecords[i]->DeleteL( iTrans->Session() );

        }

    CleanupStack::PopAndDestroy( bpRS );

    bpRS = NULL;

    iArray.ResetAndDestroy();

    // Add new content.

    const TInt count( aArray.Count() );

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

        {

        if ( aArray[i]->ServiceType() && aArray[i]->ServiceType()->Length() > 0 )

            {

            CCDGlobalBearerTypePriorizationRecord* bpRcd =

                    new( ELeave ) CCDGlobalBearerTypePriorizationRecord(

                            iBearerPriorityTableId );

            CleanupStack::PushL( bpRcd );

            HBufC* serviceType = aArray[i]->ServiceType()->AllocLC();

            TUint priority = aArray[i]->Priority();

            TUint uiPriority = aArray[i]->UiPriority();

            bpRcd->SetRecordId( KCDNewRecordRequest );

            bpRcd->iServiceType.SetL( *serviceType );

            bpRcd->iPriority.SetL( priority );

            bpRcd->iUIPriority.SetL( uiPriority );

            bpRcd->StoreL( iTrans->Session() );

            TPtrC tempServiceType( serviceType->Des() );

            CCmmBearerPriority* item = CCmmBearerPriority::NewLC(

                    tempServiceType,

                    priority,

                    uiPriority );

            iArray.AppendL( item ); // Ownership transferred.

            CleanupStack::Pop( item );

            CleanupStack::PopAndDestroy( serviceType );

            CleanupStack::PopAndDestroy( bpRcd );

            }

        }

    iTrans->CommitTransactionL();

    OstTraceFunctionExit0( CCMMBEARERPRIORITYCACHE_UPDATEL_EXIT );

    }

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

// CopyL()

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

//

void CCmmBearerPriorityCache::CopyL( RPointerArray<CCmmBearerPriority>& aArray ) const

    {

    OstTraceFunctionEntry0( CCMMBEARERPRIORITYCACHE_COPYL_ENTRY );

    const TInt count( iArray.Count() );

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

        {

        if ( iArray[i]->ServiceType() )

            {

            TPtrC tempServiceType( iArray[i]->ServiceType()->Des() );

            if ( tempServiceType.Length() > 0 )

                {

                CCmmBearerPriority* item = CCmmBearerPriority::NewLC(

                        tempServiceType,

                        iArray[i]->Priority(),

                        iArray[i]->UiPriority() );

                aArray.AppendL( item );

                CleanupStack::Pop( item );

                }

            }

        }

    OstTraceFunctionExit0( CCMMBEARERPRIORITYCACHE_COPYL_EXIT );

    }

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

// Get the priority value for a service type from the bearer priority cache.

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

//

TUint CCmmBearerPriorityCache::GetPriority( const TDesC& aServiceType ) const

    {

    TUint priority = CMManager::KDataMobilitySelectionPolicyPriorityWildCard;

    if ( aServiceType.Length() > 0 )

        {

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

            {

            if ( iArray[i]->ServiceType()->Compare( aServiceType ) == 0 )

                {

                priority = iArray[i]->Priority();

                break;

                }

            }

        }

    return priority;

    }

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

// Reads the bearer priority array from CommsDat.

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

//

void CCmmBearerPriorityCache::ReadL()

    {

    OstTraceFunctionEntry0( CCMMBEARERPRIORITYCACHE_READL_ENTRY );

    CommsDat::CMDBRecordSet<CCDGlobalBearerTypePriorizationRecord>* bpRS =

            new( ELeave ) CommsDat::CMDBRecordSet<CCDGlobalBearerTypePriorizationRecord>(

                    iBearerPriorityTableId );

    CleanupStack::PushL( bpRS );

    CCDGlobalBearerTypePriorizationRecord* bpRcd =

            new( ELeave ) CCDGlobalBearerTypePriorizationRecord(

                    iBearerPriorityTableId );

    CleanupStack::PushL( bpRcd );

    TRAP_IGNORE( bpRS->LoadL( iTrans->Session() ) );

    // Read every record and store to cache.

    const TInt bpCount = bpRS->iRecords.Count();

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

        {

        bpRcd->SetElementId( bpRS->iRecords[i]->ElementId() );

        bpRcd->LoadL( iTrans->Session() );

        if ( !bpRcd->iServiceType.IsNull() )

            {

            TPtrC serviceType( bpRcd->iServiceType );

            TUint priority = bpRcd->iPriority;

            TUint uiPriority = bpRcd->iUIPriority;

            if ( serviceType.Length() > 0 )

                {

                CCmmBearerPriority* item = CCmmBearerPriority::NewLC(

                        serviceType,

                        priority,

                        uiPriority );

                iArray.AppendL( item );

                CleanupStack::Pop( item );

                }

            }

        }

    CleanupStack::PopAndDestroy( bpRcd );

    CleanupStack::PopAndDestroy( bpRS );

    OstTraceFunctionExit0( CCMMBEARERPRIORITYCACHE_READL_EXIT );

    }

// End of file