/*

* 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 the class CDataMobilityTables

*

*/

// INCLUDE FILES

#include "cdcdatamobilitytables.h"

#include "cdclogger.h"

#include <commsdattypesv1_1.h>

#include <datamobilitycommsdattypes.h>

#include <cmmanagerext.h>

#include <wlancontainer.h>

#include <cmmanagerdef.h>

// CONSTANTS

// Maximum bearer type name length

const TUint KMaxNameLength = 50;

// Default bearer priorities

const TUint KDefaultPriorityLan = 0;

const TUint KDefaultPriorityWlan = 1;

const TUint KDefaultPriorityPan = 2;

const TUint KDefaultPriorityGprsOut = 3;

const TUint KDefaultPriorityGprsIn = 4;

const TUint KDefaultPriorityDialOut = 6;

const TUint KDefaultPriorityDialIn = 7;

const TUint KDefaultUIPriorityVpn = 253;

const TUint KDefaultUIPriorityMip = 254;

// ================= MEMBER FUNCTIONS =======================

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

// CDataMobilityTables::NewL

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

//

CDataMobilityTables* CDataMobilityTables::NewL()

    {

    CDataMobilityTables* self = new ( ELeave ) CDataMobilityTables;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CDataMobilityTables::CDataMobilityTables

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

//

CDataMobilityTables::CDataMobilityTables()

    {

    //no implementation needed

    }

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

// CDataMobilityTables::ConstructL

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

//

void CDataMobilityTables::ConstructL()

    {

    //no implementation needed

    iSession = CMDBSession::NewL( CMDBSession::LatestVersion() );

    }

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

// CDataMobilityTables::~CDataMobilityTables

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

//

CDataMobilityTables::~CDataMobilityTables()

    {

    if ( iSession )

        {

        iSession->Close();

        delete iSession; 

        }

    }

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

// CDataMobilityTables::CheckAndCreateAlrTablesL

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

//

void CDataMobilityTables::CheckAndCreateAlrTablesL()

    {

    CreateVirtualIAPNextLayerTableL();

    CreateGlobalBearerTypeTableL();

    PopulateGlobalBearerTypeTableL();

    CreateDataMobilitySelectionPolicyTableL();

    CreateSNAPMetadataTableL();

    CreateIAPMetadataTableL();

    CreateDestNetworkTableL();

    }

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

// CDataMobilityTables::CheckAndCreateMipTablesL

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

//

void CDataMobilityTables::CheckAndCreateMipTablesL()

    {

    CreateMIPServiceTableL();

    CreateMIP4TableL();

    CreateMIP6TableL();

    }

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

// CDataMobilityTables::CreateGlobalBearerTypeTableL

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

//

void CDataMobilityTables::CreateGlobalBearerTypeTableL()

    {

    //Check whether Global Bearer Type Priorization table exists

    TInt error( KErrNone );

    TRAP( error, CCDGlobalBearerTypePriorizationRecord::TableIdL( *iSession ) );

    //Table not found -> create it

    if( error == KErrNotFound )

        {

        //Add table to CommsDat

        CCDGlobalBearerTypePriorizationRecord::CreateTableL( *iSession );

        //check result

        TInt id( KErrNone );

        TRAP( id, CCDGlobalBearerTypePriorizationRecord::TableIdL( *iSession ) );

        if( id >= KErrNone )

            {

            CLOG_WRITE( "Added Global Bearer Type Priorization table\n" )

            }

        else

            {

            CLOG_WRITE_FORMAT( "Failed to add Global Bearer Type Priorization\

                             table: %d\n", id )

            }

        }

    //Table already exists

    else if ( error == KErrNone)

        {

        CLOG_WRITE ( "Global Bearer Type Priorization table already exists" )

        }

    else

        {

        //do nothing             

        }

    }

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

// CDataMobilityTables::CreateDataMobilitySelectionPolicyTableL

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

//

void CDataMobilityTables::CreateDataMobilitySelectionPolicyTableL()

    {

    //Check whether Data Mobility Selection Policy table exists

    TInt error( KErrNone );

    TRAP( error, CCDDataMobilitySelectionPolicyRecord::TableIdL( *iSession ) );

    //Table not found -> create it

    if( error == KErrNotFound )

        {

        //Add table to CommsDat

        CCDDataMobilitySelectionPolicyRecord::CreateTableL( *iSession );

        //check result

        TInt id( KErrNone );

        TRAP( id, CCDDataMobilitySelectionPolicyRecord::TableIdL( *iSession ) );

        if( id >= KErrNone )

            {

            CLOG_WRITE( "Added Data Mobility Selection Policy table\n" )

            }

        else

            {

            CLOG_WRITE_FORMAT( 

            "Failed to add Data Mobility Selection Policy table. %d\n", id )

            }

        }

    //Table already exists

    else if ( error == KErrNone)

        {

        CLOG_WRITE( "Data Mobility Selection Policy table already exists" )

        }

    else

        {

        //do nothing             

        }

    }

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

// CDataMobilityTables::CreateMIPServiceTableL

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

//

void CDataMobilityTables::CreateMIPServiceTableL()

    {

    //Check whether MIP Service table exists

    TInt error( KErrNone );

    TRAP( error, CCDMIPServiceExtRecord::TableIdL( *iSession ) );

    //Table not found -> create it

    if( error == KErrNotFound )

        {

        //Add table to CommsDat

        CCDMIPServiceExtRecord::CreateTableL( *iSession );

        //check result

        TInt id( KErrNone );

        TRAP( id, CCDMIPServiceExtRecord::TableIdL( *iSession ) );

        if( KErrNone <= id )

            {

            CLOG_WRITE( "Added MIP Service table\n" )

            }

        else

            {

            CLOG_WRITE_FORMAT( "Failed to add MIP Service table: %d\n", id )

            }

        }

    //Table already exists

    else if ( error == KErrNone)

        {

        CLOG_WRITE( "MIP Service table already exists" )

        }

    else

        {

        //do nothing             

        }

    }

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

// CDataMobilityTables::CreateMIP4TableL

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

//

void CDataMobilityTables::CreateMIP4TableL()

    {

    //Check whether MIP4 table exists

    TInt error( KErrNone );

    TRAP( error, CCDMIP4Record::TableIdL( *iSession ) );

    //Table not found -> create it

    if( error == KErrNotFound )

        {

        //Add table to CommsDat

        CCDMIP4Record::CreateTableL( *iSession );

        //check result

        TInt id( KErrNone );

        TRAP( id, CCDMIP4Record::TableIdL( *iSession ) );

        if( KErrNone <= id )

            {

            CLOG_WRITE( "Added MIP4 table\n" )

            }

        else

            {

            CLOG_WRITE_FORMAT( "Failed to add MIP4 table: %d\n", id )

            }

        }

    //Table already exists

    else if ( error == KErrNone)

        {

        CLOG_WRITE( "MIP4 table already exists" )

        }

    else

        {

        //do nothing             

        }

    }

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

// CDataMobilityTables::CreateMIP6TableL

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

//

void CDataMobilityTables::CreateMIP6TableL()

    {

    //Check whether MIP6 table exists

    TInt error( KErrNone );

    TRAP( error, CCDMIP6Record::TableIdL( *iSession ) );

    //Table not found -> create it

    if( error == KErrNotFound )

        {

        //Add table to CommsDat

        CCDMIP6Record::CreateTableL( *iSession );

        //check result

        TInt id( KErrNone );

        TRAP( id, CCDMIP6Record::TableIdL( *iSession ) );

        if( KErrNone <= id )

            {

            CLOG_WRITE( "Added MIP6 table\n" )

            }

        else

            {

            CLOG_WRITE_FORMAT( "Failed to add MIP6 table %d\n", id )

            }

        }

    //Table already exists

    else if ( error == KErrNone)

        {

            CLOG_WRITE( "MIP6 table already exists" )

        }

    else

        {

        //do nothing             

        }

    }

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

// CDataMobilityTables::CreateSNAPMetadataTableL

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

//

void CDataMobilityTables::CreateSNAPMetadataTableL()

    {

    //Check whether SNAP Metadata table exists

    TInt error( KErrNone );

    TRAP( error, CCDSNAPMetadataRecord::TableIdL( *iSession ) );

    //Table not found -> create it

    if( error == KErrNotFound )

        {

        //Add table to CommsDat

        CCDSNAPMetadataRecord::CreateTableL( *iSession );

        //check result

        TInt id( KErrNone );

        TRAP( id, CCDSNAPMetadataRecord::TableIdL( *iSession ) );

        if( KErrNone <= id )

            {

            CLOG_WRITE( "Added SNAP Metadata table\n" )

            }

        else

            {

            CLOG_WRITE_FORMAT( "Failed to add SNAP Metadata table? %d\n", id )

            }

        }

    //Table already exists

    else if ( error == KErrNone)

        {

        CLOG_WRITE( "SNAP Metadata table already exists" )

        }

    else

        {

        //do nothing             

        }

    }

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

// CDataMobilityTables::CreateIAPMetadataTableL

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

//

void CDataMobilityTables::CreateIAPMetadataTableL()

    {

    //Check whether IAP Metadata table exists

    TInt error( KErrNone );

    TRAP( error, CCDIAPMetadataRecord::TableIdL( *iSession ) );

    //Table not found -> create it

    if( error == KErrNotFound )

        {

        //Add table to CommsDat

        CCDIAPMetadataRecord::CreateTableL( *iSession );

        //check result

        TInt id( KErrNone );

        TRAP( id, CCDIAPMetadataRecord::TableIdL( *iSession ) );

        if( KErrNone <= id )

            {

            CLOG_WRITE( "Added IAP Metadata table\n" )

            }

        else

            {

            CLOG_WRITE_FORMAT( "Failed to add IAP Metadata table: %d\n", id )

            }

        }

    //Table already exists

    else if ( error == KErrNone)

        {

        CLOG_WRITE( "IAP Metadata table already exists" )

        }

    else

        {

        //do nothing             

        }

    }

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

// CDataMobilityTables::CreateVirtualIAPNextLayerTableL

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

//

void CDataMobilityTables::CreateVirtualIAPNextLayerTableL()

    {

    //Check whether IAP Metadata table exists

    TInt error( KErrNone );

    TRAP( error, CCDVirtualIAPNextLayerRecord::TableIdL( *iSession ) );

    //Table not found -> create it

    if( error == KErrNotFound )

        {

        //Add table to CommsDat

        CCDVirtualIAPNextLayerRecord::CreateTableL( *iSession );

        //check result

        TInt id( KErrNone );

        TRAP( id, CCDVirtualIAPNextLayerRecord::TableIdL( *iSession ) );

        if( KErrNone > id )

            {

            CLOG_WRITE_FORMAT( "Failed to add Virtual IAP Next Layer table %d\n", id )

            }

        else

            {

            CLOG_WRITE( "Added Virtual IAP Next Layer table\n" )

            }

        }

    //Table already exists

    else if ( error == KErrNone)

        {

        CLOG_WRITE( "Virtual IAP Next Layer table already exists" )

        }

    else

        {

        //do nothing             

        }

    }

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

// CreateDestNetworkTableL

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

//

void CDataMobilityTables::CreateDestNetworkTableL()

    {    

    //checks whether table exists

    TInt error( KErrNone );

    TRAP( error, CCDDestNWTable::TableIdL( *iSession ) );

    if( error == KErrNotFound )

        {    

        //table not found -- add new table

        CCDDestNWTable::CreateTableL( *iSession );

        //check result

        TRAP( error, CCDDestNWTable::TableIdL( *iSession ) );

        if ( error == KErrNone )

            {

            CLOG_WRITE( "Added Destination Network table" )

            }

        }

    else if ( error == KErrNone)

        {

            CLOG_WRITE( "Destination Network table already exists" )

        }

    else

        {

        //do nothing             

        }  

    }

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

// CDataMobilityTables::PopulateGlobalBearerTypeTableL

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

//

void CDataMobilityTables::PopulateGlobalBearerTypeTableL()

    {

    RCmManagerExt cmManager;

    cmManager.CreateTablesAndOpenL();

    CleanupClosePushL( cmManager );

    RArray< TBearerPriority >* bearerArray = new( ELeave )

                                            RArray< TBearerPriority >();

    CleanupStack::PushL( bearerArray );

    // Check if the bearer table has already been filled

    // (and skip populating in this case)

    cmManager.BearerPriorityArrayL( *bearerArray );

    if( !bearerArray->Count() )

        {

        // Prepare bearer priority array

        // Strings are needed to be available until the update of the bearer array

        // (TBearerPriority has a HBufC* member)

        HBufC* lanServiceName = HBufC::NewLC( KMaxNameLength );

        *lanServiceName = TPtrC( KCDTypeNameLANService );

        HBufC* wLanServiceName = HBufC::NewLC( KMaxNameLength );

        *wLanServiceName = TPtrC( KCDTypeNameWLANServiceExt );

        HBufC* panServiceName = HBufC::NewLC( KMaxNameLength );

        *panServiceName = TPtrC( KCDTypeNamePANServiceExt );

        HBufC* gprsOutServiceName = HBufC::NewLC( KMaxNameLength );

        *gprsOutServiceName = TPtrC( KCDTypeNameOutgoingWCDMA );

        HBufC* gprsInServiceName = HBufC::NewLC( KMaxNameLength );

        *gprsInServiceName = TPtrC( KCDTypeNameIncomingWCDMA );

        HBufC* dialOutServiceName = HBufC::NewLC( KMaxNameLength );

        *dialOutServiceName = TPtrC( KCDTypeNameDialOutISP );

        HBufC* dialInServiceName = HBufC::NewLC( KMaxNameLength );

        *dialInServiceName = TPtrC( KCDTypeNameDialInISP );

        HBufC* vpnServiceName = HBufC::NewLC( KMaxNameLength );

        *vpnServiceName = TPtrC( KCDTypeNameVPNService );

        HBufC* mipServiceName = HBufC::NewLC( KMaxNameLength );

        *mipServiceName = TPtrC( KCDTypeNameMIPServiceExt );