/*

* Copyright (c) 2006 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 CCmManagerImpl.

*

*/

#include "cmmanagerimpl.h"

#include <cmpluginbaseeng.h>

#include <cmpluginbase.h>

#include <cmdestination.h>

#include <cmdestinationext.h>

#include "cmdestinationimpl.h"

#include "cmtransactionhandler.h"

#include "cmlogger.h"

#include "cmmanager.hrh"

#include <cmcommonconstants.h>

#include <cmmanagerext.h>

#include <cmpluginembdestinationdef.h>

#include "cmobjectpool.h"

#include "cmcommsdatnotifier.h"

#include <sysutil.h>

#include <featmgr.h>

#include <wlancontainer.h>  // CCDWlanServiceRecord

#include <StringLoader.h>

#include <commsdattypesv1_1.h>

#include <e32cmn.h>

#include <bautils.h>        // BaflUtils

#include <cmmanager.rsg>    // resource

#include <data_caging_path_literals.hrh>

#include <ecom/ecom.h>        // For REComSession

#include <cmmanagerext.h> 

#include <cmmanager.mbg>   // icons

#include <AknsUtils.h>

#include <commsdattypesv1_1.h>

#include <rconnmon.h>

using namespace CMManager;

using namespace CommsDat;

// CONSTANTS

const TInt KResFileGranularity = 5;

const TInt KPluginGranularity = 3;

// if a CmId is grater than KMaxIapId, than it has no iap record

// Otherwise cmId is the same as the IapId

const TUint32 KMaxIapID = 255;

// Safety margin when checking disk space

const TUint32 KBytesToWrite = 8000; 

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

// Test functions

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

//

/*#ifdef _DEBUG

void DumIapTableL( CMDBSession& aSession )

    {

    CMDBRecordSet<CCDIAPRecord>*  ptrRecordSet = 

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

    CleanupStack::PushL( ptrRecordSet );

    TRAP_IGNORE( ptrRecordSet->LoadL( aSession ) );

    TInt iapRecords = ptrRecordSet->iRecords.Count();

    CLOG_WRITE_1_PTR( NULL, "Dumping IAP Table\nNo. of IAPs: [%d]", iapRecords );

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

        {

        CCDIAPRecord* iapRecord = (*ptrRecordSet)[i];

        CLOG_WRITE_4_PTR( NULL, "Rec id:[%d] - Name: [%S] - Service Type: [%S] - Bearer Type: [%S]",

                                iapRecord->RecordId(),

                                &FIELD_TO_TDESC( iapRecord->iRecordName ),

                                &FIELD_TO_TDESC( iapRecord->iServiceType ),

                                &FIELD_TO_TDESC( iapRecord->iBearerType )

                                );

        }

    CleanupStack::PopAndDestroy( ptrRecordSet );

    }

#endif */ // _DEBUG

//=============================================================================

// CONSTRUCTION / DESTRUCTION API

//=============================================================================

//

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

//  CCmManagerImpl::NewL()

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

//

CCmManagerImpl* CCmManagerImpl::NewL( TBool aCreateTables )

    {

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

    CleanupStack::PushL( self );

    self->iCreateTables = aCreateTables;

    self->ConstructL();

    CleanupStack::Pop( self );   // self

    return self;

    }

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

//  CCmManagerImpl::CCmManagerImpl()

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

//

CCmManagerImpl::CCmManagerImpl()

:iDefConnSupported(EFalse),iCreateTables(ETrue)

    {

    CLOG_CREATE;

    Dll::SetTls( this );

    }

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

//  CCmManagerImpl::CCmManagerImpl()

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

//

CCmManagerImpl::~CCmManagerImpl()

    {

    CLOG_WRITE( "CCmManagerImpl::~CCmManagerImpl" );

    if ( iBearerPriorityArray )

        {

        CleanupGlobalPriorityArray( *iBearerPriorityArray );

        delete iBearerPriorityArray;

        }

    if ( iPlugins )

        {

        iPlugins->ResetAndDestroy();

        delete iPlugins;

        }

    if ( iResourceFiles )

        {

        TInt resCount = iResourceFiles->Count();

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

            {

            // close the resource file

            (*iResourceFiles)[0]->iFile.Close();

            // delete the structure

            delete (*iResourceFiles)[0];

            // delete array item

            iResourceFiles->Delete( 0 );

            }

        iResourceFiles->Reset();        

        delete iResourceFiles;

        }

    iFs.Close();

    delete iPluginImpl;

    delete &Session();

    delete iTrans;

    if( iIsFeatureManagerInitialised )

        {

        FeatureManager::UnInitializeLib();

        }

    REComSession::FinalClose();

    delete iObjectPool;

    delete iCommsDatIapNotifier;

    delete iCommsDatSnapNotifier;

    CLOG_CLOSE;

    }

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

// CCmManagerImpl::CheckTablesL()

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

//     

void CCmManagerImpl::CheckTablesL()

    {

    LOGGER_ENTERFN( "CCmManagerImpl::CheckDestinationNetworkTableL" );

    TInt err( 0 );

    CLOG_WRITE( "Destination network" );

    if (iCreateTables)

        {

        TRAP( err, iDestinationTableId = 

                        CCDDataMobilitySelectionPolicyRecord::TableIdL( Session() ));

        CLOG_WRITE_1( "err: [%d]", err );

        if( err == KErrNotFound )

            {

            iDestinationTableId = 

                       CCDDataMobilitySelectionPolicyRecord::CreateTableL( Session() );

            }

        else

            {

            User::LeaveIfError( err );

            }        

        }

    else

        {

        iDestinationTableId = 

                        CCDDataMobilitySelectionPolicyRecord::TableIdL( Session() );        

        }

    CLOG_WRITE( "Global Bearer Type Priorization Table" );

    TRAP( err, iBearerTypePriorizationTableId = 

                CCDGlobalBearerTypePriorizationRecord::TableIdL( Session() ) );

    CLOG_WRITE_1( "err: [%d]", err );

    if( err == KErrNotFound )

        {

        iBearerTypePriorizationTableId = 

               CCDGlobalBearerTypePriorizationRecord::CreateTableL( Session() );

        }

    else

        {

        User::LeaveIfError( err );

        }

    CLOG_WRITE( "Destination network - Icon table" );        

    TRAP( err, iIconTableId = CCDSNAPMetadataRecord::TableIdL( Session() ) );

    if( err == KErrNotFound )

        {

        iIconTableId = CCDSNAPMetadataRecord::CreateTableL( Session() );

        }

    else

        {

        User::LeaveIfError( err );

        }

    CLOG_WRITE( "Seamlessness table" );

    TRAP( err, iSeamlessnessTableId = CCDIAPMetadataRecord::TableIdL( Session() ) );

    CLOG_WRITE_1( "err: [%d]", err );

    if( err == KErrNotFound )

        {

        iSeamlessnessTableId = CCDIAPMetadataRecord::CreateTableL( Session() );

        }

    else

        {

        User::LeaveIfError( err );

        }

    if ( IsDefConnSupported() )

        {

        CLOG_WRITE( "Default connection table" );

        TRAP( err, iDefConnTableId = CCDDefConnRecord::TableIdL( Session() ) );

        CLOG_WRITE_1( "err: [%d]", err );

        if( err == KErrNotFound )

            {

            iDefConnTableId = CCDDefConnRecord::CreateTableL( Session() );

            }

        else

            {

            User::LeaveIfError( err );

            }   

        }

    }

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

//  CCmManagerImpl::CreateBearerPriorityArrayL()

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

//

void CCmManagerImpl::CreateBearerPriorityArrayL()

    {

    LOGGER_ENTERFN( "CCmManagerImpl:CreateBearerPriorityArray" );

    iBearerPriorityArray = 

                new ( ELeave ) RArray<TBearerPriority>( KCmArrayBigGranularity );

    CMDBRecordSet<CCmBearerPriRec>* bpRS = 

                new (ELeave) CMDBRecordSet<CCmBearerPriRec>( 

                                               iBearerTypePriorizationTableId );

    CleanupStack::PushL( bpRS );

    OpenTransactionLC();        

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

    RollbackTransaction();

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

    TInt i( 0 );

    while ( i < bpCount ) // loop the Bearer Priority table

        {

        // Bearer Priority record ID

        HBufC* bpServiceType = QUERY_HBUFC_FIELD( (*bpRS)[i], 

                                                  KCDTIdGlobalServiceType );

        TInt bpPriority = ( QUERY_INT_FIELD( (*bpRS)[i], 

                                             KCDTIdGlobalServicePriority ) );

        TInt uiPriority = ( QUERY_INT_FIELD( (*bpRS)[i], 

                                             KCDTIdGlobalServiceUIPriority ) );                                    

        CLOG_WRITE( "Bearer Priority Table Values" );

        CLOG_WRITE_1( "Service Type: [%S]", bpServiceType );

        CLOG_WRITE_1( "Bearer Priority: [%d]", bpPriority );

        CLOG_WRITE_1( "UI Priority: [%d]", uiPriority );                          

        TBearerPriority bp;

        bp.iServiceType = bpServiceType->AllocL();

        bp.iPriority = bpPriority;

        bp.iUIPriority = uiPriority;

        iBearerPriorityArray->AppendL( bp );

        i++;

        }

    CleanupStack::PopAndDestroy( bpRS );

    }

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

//  CCmManagerImpl::BearerPriorityArrayL()

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

//

void CCmManagerImpl::BearerPriorityArrayL( RArray<TBearerPriority>& aArray ) const

    {

    LOGGER_ENTERFN( "CCmManagerImpl:BearerPriorityArray" );

    TRAPD( err, CopyBearerPriorityArrayL( aArray ) );

    if( err )

        // in case of any problem we clean up this array

        {

        User::Leave( err );

        }

    }

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

//  CCmManagerImpl::CopyBearerPriorityArrayL()

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

//

void CCmManagerImpl::CopyBearerPriorityArrayL( 

                                        RArray<TBearerPriority>& aArray ) const

    {

    LOGGER_ENTERFN( "CCmManagerImpl:BearerPriorityArray" );

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

        {

        TBearerPriority item;

        TBearerPriority* orgItem = &(*iBearerPriorityArray)[i];

        item.iServiceType = HBufC::NewLC( orgItem->iServiceType->Length() );

        item.iServiceType->Des().Copy( *orgItem->iServiceType );

        item.iPriority = orgItem->iPriority;

        item.iUIPriority = orgItem->iUIPriority;

        User::LeaveIfError( aArray.Append( item ) );

        CleanupStack::Pop(); // item->iServiceType

        }

    }

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

//  CCmManagerImpl::UpdateBearerPriorityArrayL()

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

//

void CCmManagerImpl::UpdateBearerPriorityArrayL( 

                                        const RArray<TBearerPriority>& aArray )

    {

    LOGGER_ENTERFN( "CCmManagerImpl::UpdateBearerPriorityArray" );    

    OpenTransactionLC();

    CMDBRecordSet<CCmBearerPriRec>* bpRS = new (ELeave) 

            CMDBRecordSet<CCmBearerPriRec>( iBearerTypePriorizationTableId );

    CleanupStack::PushL( bpRS ); // 1

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

    // Delete the old record

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

        {

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

        }

    CleanupGlobalPriorityArray( *iBearerPriorityArray );

    CleanupStack::PopAndDestroy( bpRS );

    bpRS = NULL;

    // Add the new content

    CCmBearerPriRec* bpRcd = 

            new (ELeave) CCmBearerPriRec( iBearerTypePriorizationTableId );

    CleanupStack::PushL( bpRcd ); // 2

    CLOG_WRITE( "Store bearer info to table" );

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

        {        

        bpRcd->SetRecordId( KCDNewRecordRequest );

        HBufC* serviceTypeVal = aArray[i].iServiceType;

        TInt priorityVal = aArray[i].iPriority;

        TInt uiPriorityVal = aArray[i].iUIPriority;

        CLOG_WRITE_FORMAT( "Set service type: [%S   ]", serviceTypeVal );

        SET_HBUFC_FIELD(    bpRcd, 

                            KCDTIdGlobalServiceType, 

                            serviceTypeVal );

        CLOG_WRITE_1( "Set priority: [%d]", priorityVal );

        SET_INT_FIELD(  bpRcd, 

                        KCDTIdGlobalServicePriority, 

                        priorityVal );

        CLOG_WRITE_1( "Set uipriority: [%d]", uiPriorityVal );

        SET_INT_FIELD(  bpRcd, 

                        KCDTIdGlobalServiceUIPriority, 

                        uiPriorityVal );                        

        bpRcd->StoreL( Session() );

        TBearerPriority item;

        item.iServiceType = serviceTypeVal->AllocLC();

        item.iPriority = priorityVal;

        item.iUIPriority = uiPriorityVal;

        iBearerPriorityArray->AppendL( item );

        CleanupStack::Pop( item.iServiceType );

        }

    CleanupStack::PopAndDestroy( bpRcd );

    CommitTransactionL( KErrNone );

    }

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

//  CCmManagerImpl::GlobalBearerPriority()

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

//

TInt CCmManagerImpl::GlobalBearerPriority( TBool aUiPriority, 

                                           const TDesC& aServiceType ) const

    {

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

        {

        if ( !aServiceType.CompareF( *(*iBearerPriorityArray)[i].iServiceType ) )

            {

            if( aUiPriority )

                {

                return (*iBearerPriorityArray)[i].iUIPriority;

                }

            else

                {

                return (*iBearerPriorityArray)[i].iPriority;

                }

            }

        }

    return KDataMobilitySelectionPolicyPriorityWildCard;

    }

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

//  CCmManagerImpl::CleanupGlobalPriorityArray()

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

//

void CCmManagerImpl::CleanupGlobalPriorityArray(

                                        RArray<TBearerPriority>& aArray ) const

    {

    LOGGER_ENTERFN( "CCmManagerImpl::CleanupGlobalPriorityArray" );

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

        {

        delete aArray[i].iServiceType;

        }

    aArray.Reset();

    aArray.Close();

    }

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

//  CCmManagerImpl::AddResourceFileL()

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

//

void CCmManagerImpl::AddResourceFileL( TFileName& aName )

    {

    LOGGER_ENTERFN( "CCmManagerImpl::AddResourceFileL" );

    TInt index = FindResourceFile( aName );

    if ( index != KErrNotFound )

        {

        ++(*iResourceFiles)[index]->iRefs;

        return;

        }

    TResourceFiles* newRes = new (ELeave) TResourceFiles;

    CleanupStack::PushL( newRes );

    RResourceFile resFile;

    resFile.OpenL( iFs, aName );

    CleanupClosePushL( resFile );

    resFile.ConfirmSignatureL(0); 

    newRes->iFile = resFile;

    newRes->iFName.Copy( aName );

    newRes->iRefs = 1;  // 1 reference to this resource file

    iResourceFiles->AppendL( newRes );

    CleanupStack::Pop( 2 ); // resFile, newRes

    }

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

//  CCmManagerImpl::RemoveResourceFile()

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

//

void CCmManagerImpl::RemoveResourceFile( TFileName& aName )

    {

    LOGGER_ENTERFN( "CCmManagerImpl::RemoveResourceFile" );

    TInt index = FindResourceFile( aName );

    if ( index == KErrNotFound )

        {

        return;

        }

    if ( !--(*iResourceFiles)[index]->iRefs )

        // it was the last reference

        {

        (*iResourceFiles)[index]->iFile.Close();

        delete (*iResourceFiles)[index];

        iResourceFiles->Delete( index );

        }