/*

* 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 plugin base class

*

*/

#include <datamobilitycommsdattypes.h>

#include <cmpluginbaseeng.h>

#include <cmpsettingsconsts.h>

#include <FeatMgr.h>

#include "ccmpluginbaseengtextresolver.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "ccmpluginbaseengTraces.h"

#endif

using namespace CMManager;

using namespace CommsDat;

const TInt KApMaxConnNameLength = 30;

_LIT( KFormatPostfix, "%02d" );

_LIT( KFormatLargePostfix, "%d" );

_LIT( KFormatNameWithPostfix, "%S(%S)" );

_LIT( KFormatNoPostfix, "%S" );

const TInt KMaxPostfixLength = 5;

_LIT( KDefWapGatewayIpAddress, "0.0.0.0" );

_LIT( KLocationName, "Mobile" );

_LIT( KDefaultIapName, "Connection Method" );

EXPORT_C CCmClientPluginInstance* CCmClientPluginInstance::NewLC()

    {

    OstTraceFunctionEntry0( CCMCLIENTPLUGININSTANCE_NEWLC_ENTRY );

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

    CleanupStack::PushL( self );

    self->ConstructL();

    OstTraceFunctionExit0( CCMCLIENTPLUGININSTANCE_NEWLC_EXIT );

    return self;

    }

EXPORT_C CCmClientPluginInstance* CCmClientPluginInstance::NewL()

    {

    OstTraceFunctionEntry0( CCMCLIENTPLUGININSTANCE_NEWL_ENTRY );

    CCmClientPluginInstance* self = CCmClientPluginInstance::NewLC();

    CleanupStack::Pop( self );

    OstTraceFunctionExit0( CCMCLIENTPLUGININSTANCE_NEWL_EXIT );

    return self;

    }

CCmClientPluginInstance::CCmClientPluginInstance()

        :

        iNamingMethod( ENamingUnique ),

        iLocationEnabled( EFalse ),

        iIapId( 0 )

    {

    }

EXPORT_C CCmClientPluginInstance::~CCmClientPluginInstance()

    {

    OstTraceFunctionEntry0( CCMCLIENTPLUGININSTANCE_CCMCLIENTPLUGININSTANCE_ENTRY );

    iGenRecordArray.ResetAndDestroy();

    iBearerSpecRecordArray.ResetAndDestroy();

    OstTraceFunctionExit0( CCMCLIENTPLUGININSTANCE_CCMCLIENTPLUGININSTANCE_EXIT );

    }

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

// Second phase constructor.

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

//

void CCmClientPluginInstance::ConstructL()

    {

    OstTraceFunctionEntry0( CCMCLIENTPLUGININSTANCE_CONSTRUCTL_ENTRY );

    OstTraceFunctionExit0( CCMCLIENTPLUGININSTANCE_CONSTRUCTL_EXIT );

    }

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

// TCmPluginInitParam::TCmPluginInitParam

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

//

EXPORT_C TCmPluginInitParam::TCmPluginInitParam( CommsDat::CMDBSession& aSession )

        :

        iSessionRef( aSession )

    {

    OstTraceFunctionEntry0( TCMPLUGININITPARAM_TCMPLUGININITPARAM_ENTRY );

    iNotused1 = NULL;

    iNotused2 = NULL;

    OstTraceFunctionExit0( TCMPLUGININITPARAM_TCMPLUGININITPARAM_EXIT );

    }

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

// CCmPluginBaseEng::CCmPluginBaseEng

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

//

EXPORT_C CCmPluginBaseEng::CCmPluginBaseEng( TCmPluginInitParam *aInitParam )

        :

        iSession( aInitParam->iSessionRef ),

        iNamingMethod( ENamingUnique )

    {

    OstTraceFunctionEntry0( CCMPLUGINBASEENG_CCMPLUGINBASEENG_ENTRY );

    iDtor_ID_Key.iUid = 0;

    iBearerType = 0;

    iIapRecord = NULL;

    iProxyRecord = NULL;

    iServiceRecord = NULL;

    iNetworkRecord = NULL;

    iLocationRecord = NULL;

    iWapAPRecord = NULL;

    iWapIPBearerRecord = NULL;

    iMetaDataRecord = NULL;

    iIapId = 0;

    iMetadataTableId = 0;

    iLocationEnabled = EFalse;

    OstTraceFunctionExit0( CCMPLUGINBASEENG_CCMPLUGINBASEENG_EXIT );

    }

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

// CCmPluginBaseEng::~CCmPluginBaseEng

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

//

EXPORT_C CCmPluginBaseEng::~CCmPluginBaseEng()

    {

    OstTraceFunctionEntry0( DUP1_CCMPLUGINBASEENG_CCMPLUGINBASEENG_ENTRY );

    iIapId = 0;

    delete iIapRecord; iIapRecord = NULL;

    delete iProxyRecord; iProxyRecord = NULL;

    delete iServiceRecord; iServiceRecord = NULL;

    delete iNetworkRecord; iNetworkRecord = NULL;

    delete iLocationRecord; iLocationRecord = NULL;

    delete iWapAPRecord; iWapAPRecord = NULL;

    delete iWapIPBearerRecord; iWapIPBearerRecord = NULL;

    delete iMetaDataRecord; iMetaDataRecord = NULL;

    iLocationEnabled = EFalse;

    REComSession::DestroyedImplementation( iDtor_ID_Key );

    OstTraceFunctionExit0( DUP1_CCMPLUGINBASEENG_CCMPLUGINBASEENG_EXIT );

    }

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

// CCmPluginBaseEng::ConstructL

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

//

EXPORT_C void CCmPluginBaseEng::ConstructL()

    {

    OstTraceFunctionEntry0( CCMPLUGINBASEENG_CONSTRUCTL_ENTRY );

    TRAPD( err, iMetadataTableId = CCDIAPMetadataRecord::TableIdL( iSession ) );

    if ( err )

        {

        if ( err == KErrNotFound )

            {

            iMetadataTableId = CCDIAPMetadataRecord::CreateTableL( iSession );

            }

        else

            {

            User::LeaveIfError( err );

            }

        }

    OstTraceFunctionExit0( CCMPLUGINBASEENG_CONSTRUCTL_EXIT );

    }

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

// CCmPluginBaseEng::UpdateL

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

//

EXPORT_C void CCmPluginBaseEng::UpdateL(

        CCmClientPluginInstance* aClientPluginInstance )

    {

    OstTraceFunctionEntry0( CCMPLUGINBASEENG_UPDATEL_ENTRY );

    PrepareToUpdateRecordsL( aClientPluginInstance );

    UpdateServiceRecordL( aClientPluginInstance );

    UpdateLocationRecordL( aClientPluginInstance );

    UpdateNetworkRecordL( aClientPluginInstance );

    UpdateIAPRecordL( aClientPluginInstance );

    UpdateWapRecordL( aClientPluginInstance );

    UpdateProxyRecordL( aClientPluginInstance );

    UpdateMetadataRecordL( aClientPluginInstance );

    UpdateConnPrefSettingL();

    UpdateBearerRecordsL(

            aClientPluginInstance->iGenRecordArray,

            aClientPluginInstance->iBearerSpecRecordArray );

    OstTraceFunctionExit0( CCMPLUGINBASEENG_UPDATEL_EXIT );

    }

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

// Delete this connection methond.

// Record ids are checked to be sure that we delete only records

// that were loaded before.

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

//

EXPORT_C void CCmPluginBaseEng::DeleteL()

    {

    OstTraceFunctionEntry0( CCMPLUGINBASEENG_DELETEL_ENTRY );

    PrepareToDeleteRecordsL();

    if ( iIapRecord && iIapRecord->RecordId() )

        {

        iIapRecord->DeleteL( iSession );

        }

    if ( iProxyRecord && iProxyRecord->RecordId() )

        {

        iProxyRecord->DeleteL( iSession );

        }

    if ( iServiceRecord && iServiceRecord->RecordId() )

        {

        iServiceRecord->DeleteL( iSession );

        }

    if ( iNetworkRecord && iNetworkRecord->RecordId() )

        {

        iNetworkRecord->DeleteL( iSession );

        }

    if ( iLocationRecord && iLocationRecord->RecordId() )

        {

        iLocationRecord->DeleteL( iSession );

        }

    if ( iWapAPRecord && iWapAPRecord->RecordId() )

        {

        iWapAPRecord->DeleteL( iSession );

        }

    if ( iWapIPBearerRecord && iWapIPBearerRecord->RecordId() )

        {

        iWapIPBearerRecord->DeleteL( iSession );

        }

    if ( iMetaDataRecord && iMetaDataRecord->RecordId() )

        {

        iMetaDataRecord->DeleteL( iSession );

        }

    DeleteBearerRecordsL();

    OstTraceFunctionExit0( CCMPLUGINBASEENG_DELETEL_EXIT );

    }

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

// CCmPluginBaseEng::ReLoad

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

//

EXPORT_C void CCmPluginBaseEng::ReLoadL()

    {

    OstTraceFunctionEntry0( CCMPLUGINBASEENG_RELOAD_ENTRY );

    delete iIapRecord; iIapRecord = NULL;

    delete iProxyRecord; iProxyRecord = NULL;

    delete iServiceRecord; iServiceRecord = NULL;

    delete iNetworkRecord; iNetworkRecord = NULL;

    delete iLocationRecord; iLocationRecord = NULL;

    delete iWapAPRecord; iWapAPRecord = NULL;

    delete iWapIPBearerRecord; iWapIPBearerRecord = NULL;

    delete iMetaDataRecord; iMetaDataRecord = NULL;

    iLocationEnabled = EFalse;

    ResetBearerRecords();

    LoadL( iIapId );

    OstTraceFunctionExit0( CCMPLUGINBASEENG_RELOAD_EXIT );

    }

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

// CCmPluginBaseEng::LoadL

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

//

EXPORT_C void CCmPluginBaseEng::LoadL( TUint32 aIapId )

    {

    OstTraceFunctionEntry0( CCMPLUGINBASEENG_LOADL_ENTRY );

    DoLoadL( aIapId );

    OstTraceFunctionExit0( CCMPLUGINBASEENG_LOADL_EXIT );

    }

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

// CCmPluginBaseEng::CreateNewL

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

//

EXPORT_C void CCmPluginBaseEng::CreateNewL( TUint32 aCmId )

    {

    OstTraceFunctionEntry0( CCMPLUGINBASEENG_CREATENEWL_ENTRY );

    if ( iIapId )

        // we already have IAP id ->

        {

        User::Leave( KErrAlreadyExists );

        }

    // optional record is disabled in default

    iLocationEnabled = EFalse;

    // create mandatory records

    iIapRecord = static_cast<CCDIAPRecord *>

                          (CCDRecordBase::RecordFactoryL(KCDTIdIAPRecord));

    iNetworkRecord = static_cast<CCDNetworkRecord *>

                          (CCDRecordBase::RecordFactoryL(KCDTIdNetworkRecord));

    iProxyRecord = static_cast<CCDProxiesRecord *>

                  (CCDRecordBase::RecordFactoryL(KCDTIdProxiesRecord));

    NewWapRecordL();

    iWapIPBearerRecord->iWAPGatewayAddress.SetL( KDefWapGatewayIpAddress );

    iMetaDataRecord = NewMetadataRecordL( ETrue );

    // call plugin to create its own records

    CreateServiceRecordL();

    // Update iaprecord servicetype name

    HBufC* servicetypeName( NULL );

    ServiceRecordNameLC( servicetypeName );

    iIapRecord->iServiceType.SetL( *servicetypeName );

    CleanupStack::PopAndDestroy( servicetypeName );

    // Update iaprecord bearertype name

    HBufC* bearerTypeName( NULL );

    BearerRecordNameLC( bearerTypeName );

    iIapRecord->iBearerType.SetL( *bearerTypeName );

    CleanupStack::PopAndDestroy( bearerTypeName );

    CreateBearerRecordsL();

    EnableProxyL( EFalse );

    _LIT(KDefaultConnNameTextId, "txt_occ_setlabel_connection_name_val_connection");

    HBufC* resolvedText( NULL );

    resolvedText = CCmPluginBaseEngTextResolver::ResolveTextL( KDefaultConnNameTextId );

    if ( resolvedText != NULL )

        {

        SetDefaultNameL( *resolvedText );

        }

    else

        {

        SetDefaultNameL( KDefaultIapName );

        }

    delete resolvedText;

    resolvedText = NULL;

    iIapRecord->iNetworkWeighting = 0; // it's always 0.

    if ( aCmId != 0 )

        {

        iIapRecord->SetRecordId( aCmId );

        iIapId = 0;

        }

    else

        {

        iIapRecord->SetRecordId( KCDNewRecordRequest );

        }

    OstTraceFunctionExit0( CCMPLUGINBASEENG_CREATENEWL_EXIT );

    }

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

// CCmPluginBaseEng::CreateCopyL

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

//

EXPORT_C CCmPluginBaseEng* CCmPluginBaseEng::CreateCopyL(

    CCmClientPluginInstance* /*aClientPluginInstance*/ )

    {

    OstTraceFunctionEntry0( CCMPLUGINBASEENG_CREATECOPYL_ENTRY );

    TCmPluginInitParam params( iSession );

    CCmPluginBaseEng* copyInst = CreateInstanceL( params );

    CleanupStack::PushL( copyInst );

    PrepareToCopyDataL( copyInst );

    CopyDataL( copyInst );

    CleanupStack::Pop( copyInst );

    OstTraceFunctionExit0( CCMPLUGINBASEENG_CREATECOPYL_EXIT );

    return copyInst;

    }

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

// CCmPluginBaseEng::GetGenericTableIdsToBeObserved

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

//

EXPORT_C void CCmPluginBaseEng::GetGenericTableIdsToBeObserved(

        RArray<TUint32>& aTableIdArray ) const

    {

    // Service and bearer records should be added by plugins

    aTableIdArray.Append( KCDTIdIAPRecord );

    aTableIdArray.Append( KCDTIdWAPAccessPointRecord );

    aTableIdArray.Append( KCDTIdProxiesRecord );

    aTableIdArray.Append( iMetadataTableId );

    }

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

// CCmPluginBaseEng::CopyDataL

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

//

void CCmPluginBaseEng::CopyDataL( CCmPluginBaseEng* aCopyInstance )

    {

    OstTraceFunctionEntry0( CCMPLUGINBASEENG_COPYDATAL_ENTRY );

    aCopyInstance->iLocationEnabled = iLocationEnabled;

    aCopyInstance->iNamingMethod = iNamingMethod;

    CopyRecordsL( aCopyInstance );

    OstTraceFunctionExit0( CCMPLUGINBASEENG_COPYDATAL_EXIT );

    }

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

// CCmPluginBaseEng::CopyRecordsL

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

//

void CCmPluginBaseEng::CopyRecordsL( CCmPluginBaseEng* aCopyInstance )

    {

    OstTraceFunctionEntry0( CCMPLUGINBASEENG_COPYRECORDSL_ENTRY );

    CopyRecordDataL( KIapRecordIndex, aCopyInstance );

    // Ensure that iap's name is set by the rules(Naming Method)

    SetNameL( iIapRecord->iRecordName.GetL(),

              aCopyInstance->iIapRecord,

              aCopyInstance->iNamingMethod );

    CopyRecordDataL( KServiceRecordIndex, aCopyInstance );

    CopyRecordDataL( KNetworkRecordIndex, aCopyInstance );

    CopyRecordDataL( KWAPAPRecordIndex, aCopyInstance );

    CopyRecordDataL( KWAPBearerRecordIndex, aCopyInstance );

    CopyRecordDataL( KMetaDataRecordIndex, aCopyInstance );

    CopyRecordDataL( KLocationRecordIndex, aCopyInstance );

    CopyRecordDataL( KProxyRecordIndex, aCopyInstance );

    CopyBearerRecordsL( aCopyInstance );

    OstTraceFunctionExit0( CCMPLUGINBASEENG_COPYRECORDSL_EXIT );

    }

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

// CCmPluginBaseEng::CopyRecordDataL

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

//

void CCmPluginBaseEng::CopyRecordDataL( TUint32 aRecordIdentifier,

                                        CCmPluginBaseEng* aCopyInstance )

    {

    OstTraceFunctionEntry0( CCMPLUGINBASEENG_COPYRECORDDATAL_ENTRY );

    switch( aRecordIdentifier )

        {

        case KIapRecordIndex:

            {

            aCopyInstance->iIapRecord =

                static_cast<CCDIAPRecord*>( CCDRecordBase::CreateCopyRecordL( *iIapRecord ) );

            }

            break;

        case KServiceRecordIndex:

            {

            aCopyInstance->iServiceRecord = CopyServiceRecordL();

            }

            break;

        case KNetworkRecordIndex:

            {

            aCopyInstance->iNetworkRecord =

                static_cast<CCDNetworkRecord*>( CCDRecordBase::CreateCopyRecordL( *iNetworkRecord ) );

            }

            break;

        case KWAPAPRecordIndex:

            {

            aCopyInstance->iWapAPRecord =

                static_cast<CCDWAPAccessPointRecord*>( CCDRecordBase::CreateCopyRecordL( *iWapAPRecord ) );

            }

            break;

        case KWAPBearerRecordIndex:

            {

            aCopyInstance->iWapIPBearerRecord =

                static_cast<CCDWAPIPBearerRecord*>( CCDRecordBase::CreateCopyRecordL( *iWapIPBearerRecord ) );

            }

            break;

        case KMetaDataRecordIndex:

            {

            aCopyInstance->iMetaDataRecord = new (ELeave) CCDIAPMetadataRecord( iMetadataTableId );

            aCopyInstance->iMetaDataRecord->iIAP = IAPRecordElementId();

            aCopyInstance->iMetaDataRecord->iMetadata.SetL( iMetaDataRecord->iMetadata );

            aCopyInstance->iMetaDataRecord->iSeamlessness.SetL( iMetaDataRecord->iSeamlessness );

            }

            break;