/*

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

*

*/

#include "cmdestinationimpl.h"

#include "cmmanagerimpl.h"

#include <cmpluginbaseeng.h>

#include <cmpluginbase.h>

#include <cmmanager.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <commsdattypeinfov1_1_internal.h>

#include <commsdattypesv1_1_partner.h> 

#endif

#include "cmlogger.h"

#include "cmmanager.hrh"

#include <cmcommonconstants.h>

#include "datamobilitycommsdattypes.h"

#include <cmpluginembdestinationdef.h>

#include <cmmanagerdef.h>

#include <data_caging_path_literals.hrh>

#include <cmmanager.rsg>

#include <cmmanager.mbg>   // icons

#include <AknsUtils.h>

#include <e32cmn.h>

// System includes

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

#include <commsdattypesv1_1.h>

#include <in_sock.h>

using namespace CMManager;

using namespace CommsDat;

const TUint KDefaultTierManagerTagId = KAfInet;

const TInt KDestinationIconConvTable[][4] = {

    { EAknsMajorGeneric, 

      EAknsMinorGenericQgnIndiSettProtectedAdd,

      EMbmCmmanagerQgn_prop_set_conn_dest_internet, 

      EMbmCmmanagerQgn_prop_set_conn_dest_internet_mask },

    { EAknsMajorGeneric, 

      EAknsMinorGenericQgnPropWmlGprs,

      EMbmCmmanagerQgn_prop_set_conn_dest_wap, 

      EMbmCmmanagerQgn_prop_set_conn_dest_wap_mask },                   

    { EAknsMajorGeneric, 

      EAknsMinorGenericQgnPropWmlGprs,

      EMbmCmmanagerQgn_prop_set_conn_dest_mms, 

      EMbmCmmanagerQgn_prop_set_conn_dest_mms_mask },

    { EAknsMajorGeneric, 

      EAknsMinorGenericQgnPropWmlGprs,

      EMbmCmmanagerQgn_prop_set_conn_dest_intranet, 

      EMbmCmmanagerQgn_prop_set_conn_dest_intranet_mask },          

    { EAknsMajorGeneric, 

      EAknsMinorGenericQgnPropWmlGprs,

      EMbmCmmanagerQgn_prop_set_conn_dest_operator, 

      EMbmCmmanagerQgn_prop_set_conn_dest_operator_mask },

    { EAknsMajorGeneric, 

      EAknsMinorGenericQgnPropWmlGprs,

      EMbmCmmanagerQgn_prop_set_conn_dest_icon1, 

      EMbmCmmanagerQgn_prop_set_conn_dest_icon1_mask },     

    { EAknsMajorGeneric, 

      EAknsMinorGenericQgnPropWmlGprs,

      EMbmCmmanagerQgn_prop_set_conn_dest_icon2, 

      EMbmCmmanagerQgn_prop_set_conn_dest_icon2_mask },

    { EAknsMajorGeneric, 

      EAknsMinorGenericQgnPropWmlGprs,

      EMbmCmmanagerQgn_prop_set_conn_dest_icon3, 

      EMbmCmmanagerQgn_prop_set_conn_dest_icon3_mask },            

    { EAknsMajorGeneric, 

      EAknsMinorGenericQgnPropWmlGprs,

      EMbmCmmanagerQgn_prop_set_conn_dest_icon4, 

      EMbmCmmanagerQgn_prop_set_conn_dest_icon4_mask },       

    { EAknsMajorGeneric, 

      EAknsMinorGenericQgnPropWmlGprs,

      EMbmCmmanagerQgn_prop_set_conn_dest_icon5, 

      EMbmCmmanagerQgn_prop_set_conn_dest_icon5_mask }, 

    { EAknsMajorGeneric, 

      EAknsMinorGenericQgnPropWmlGprs,

      EMbmCmmanagerQgn_prop_set_conn_dest_icon6, 

      EMbmCmmanagerQgn_prop_set_conn_dest_icon6_mask }, 

    { EAknsMajorGeneric, 

      EAknsMinorGenericQgnPropWmlGprs,

      EMbmCmmanagerQgn_prop_set_conn_dest_default, 

      EMbmCmmanagerQgn_prop_set_conn_dest_default_mask },            

    {0, 0, 0, 0}

    };

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

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

// CCmDestinationImpl::NewL()

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

//

EXPORT_C CCmDestinationImpl* 

                           CCmDestinationImpl::NewL( CCmManagerImpl& aCmMgr,

                                                     const TDesC& aName )

    {

    CCmDestinationImpl* dest = 

                    new (ELeave) CCmDestinationImpl( aCmMgr );

    CleanupStack::PushL( dest );

    dest->ConstructL( aName );

    CleanupStack::Pop( dest );

    return dest;        

    }

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

// CCmDestinationImpl::NewL()

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

//

EXPORT_C CCmDestinationImpl* 

                        CCmDestinationImpl::NewL( CCmManagerImpl& aCmMgr,

                                                  TUint aDestinationId )

    {

    CCmDestinationImpl* dest = 

                    new (ELeave) CCmDestinationImpl( aCmMgr );

    CleanupStack::PushL( dest );

    dest->ConstructL( aDestinationId );

    CleanupStack::Pop( dest );

    return dest;        

    }

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

// CCmDestinationImpl::NewL()

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

//

CCmDestinationImpl* CCmDestinationImpl::NewL( CCmManagerImpl& aCmMgr,

                                              CCmDestinationData* aData )

    {

    CCmDestinationImpl* dest = 

                    new (ELeave) CCmDestinationImpl( aCmMgr );

    dest->iData = aData;

    return dest;        

    }

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

// CCmDestinationImpl::NewL()

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

//

CCmDestinationImpl* CCmDestinationImpl::NewL( CCmManagerImpl& aCmMgr,

                                              const TDesC& aName,

                                              TUint32 aDestId)

    {

    CCmDestinationImpl* dest = 

                              new (ELeave) CCmDestinationImpl( aCmMgr );

    CleanupStack::PushL( dest );

    dest->ConstructL( aName, aDestId );

    CleanupStack::Pop( dest );

    return dest;        

    }

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

// CCmDestinationImpl::NewLC()

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

//

CCmDestinationImpl* CCmDestinationImpl::NewLC( CCmDestinationData* aData )

    {

    CCmDestinationImpl* dest = 

                    new (ELeave) CCmDestinationImpl( aData->iCmMgr );

    CleanupStack::PushL( dest );

    dest->iData = aData;

    return dest;        

    }

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

// CCmDestinationImpl::CCmDestinationImpl()

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

//

CCmDestinationImpl::CCmDestinationImpl( CCmManagerImpl& aCmMgr )

    : iCmMgr( aCmMgr )

    {

    }

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

// CCmDestinationData::CCmDestinationData()

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

//

CCmDestinationData::CCmDestinationData( CCmManagerImpl& aCmMgr )

    : iCmMgr( aCmMgr ),

    iNewWithId ( EFalse )

    {

    }

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

// CCmDestinationData::~CCmDestinationData()

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

//

CCmDestinationData::~CCmDestinationData()

    {

    delete iMetaDataRec;

    delete iNetworkRecord;

    delete iDestAPRecord;

    if (iConnMethodArray)

        {

        ResetAndDestroyArray( iConnMethodArray, ETrue );        

        }

    if (iDeleteCmArray)

        {

        ResetAndDestroyArray( iDeleteCmArray, ETrue );        

        }

    CLOG_CLOSE;

    }

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

// CCmDestinationImpl::~CCmDestinationImpl()

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

//

CCmDestinationImpl::~CCmDestinationImpl()

    {

    if (iData)

        {

        if (GetRefCounter())

            {

            iCmMgr.RemoveDestFromPool(this);        

            }

        else //if leaves during construction refcounter is 0

            {

            delete iData; 

            }        

        }

    }

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

// CCmDestinationImpl::ConstructL()

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

//    

void CCmDestinationImpl::ConstructL( const TDesC& aName )

    {

    CLOG_CREATE;

    CLOG_NAME_2( _L("Destination_0x%x_%S"), this, &aName );

    iData =  new (ELeave) CCmDestinationData(iCmMgr);

    iData->iNetworkRecord = static_cast<CCDNetworkRecord *>(

                         CCDRecordBase::RecordFactoryL( KCDTIdNetworkRecord ) );

    iData->iConnMethodArray = new (ELeave) CCmArray( KCmArrayBigGranularity );

    iData->iDeleteCmArray = new (ELeave) CCmArray( KCmArrayBigGranularity );

    iData->iMetaDataRec = new (ELeave) CCDSNAPMetadataRecord( 

                                       iCmMgr.IconTableId() );

    iData->iDestAPRecord = static_cast<CCDAccessPointRecord *>(

                    CCDRecordBase::RecordFactoryL( KCDTIdAccessPointRecord ) );

    SetNameL( aName );

    InitializeDestAPRecordL();

    CPluginItem* item = new (ELeave) CPluginItem;

    CleanupStack::PushL( item );

    // create the new record

    item->iDNRecord = iCmMgr.SNAPRecordL( 0 );

    CleanupStack::PushL( item->iDNRecord );

    AddToArrayL( item );

    CleanupStack::Pop( 2, item );  // iDNRecord, item

    iData->iIdIsValid = EFalse;// the Id is still zero here

    } 

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

// CCmDestinationImpl::ConstructL()

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

//    

void CCmDestinationImpl::ConstructL( const TDesC& aName, TUint32 aDestId )

    {

    CLOG_CREATE;

    CLOG_NAME_2( _L("Destination_0x%x_%S"), this, &aName );

    iData =  new (ELeave) CCmDestinationData(iCmMgr);

    iData->iNetworkRecord = static_cast<CCDNetworkRecord *>(

                    CCDRecordBase::RecordFactoryL( KCDTIdNetworkRecord ) );

    iData->iConnMethodArray = new (ELeave) CCmArray( KCmArrayBigGranularity );

    iData->iDeleteCmArray = new (ELeave) CCmArray( KCmArrayBigGranularity );

    iData->iMetaDataRec = new (ELeave) CCDSNAPMetadataRecord( iCmMgr.IconTableId() );

    iData->iDestAPRecord = static_cast<CCDAccessPointRecord *>(

                    CCDRecordBase::RecordFactoryL( KCDTIdAccessPointRecord ) );

    SetNameL( aName );

    TInt correctAPId = aDestId;

    TInt correctNetworkId = aDestId;

    if ( aDestId > 0 && aDestId < 255 )

        {

        correctAPId = aDestId + KCmDefaultDestinationAPTagId;

        }

    else if ( aDestId > KCmDefaultDestinationAPTagId 

              && ( aDestId < ( KCmDefaultDestinationAPTagId+255 ) ) )

        {

        correctNetworkId = aDestId - KCmDefaultDestinationAPTagId;

        }

    else

        {

        User::Leave( KErrArgument );

        }

    SetIdL( correctAPId );

    InitializeDestAPRecordL();

    CPluginItem* item = new (ELeave) CPluginItem;

    CleanupStack::PushL( item );

    // create the new record

    iData->iNetworkRecord->SetRecordId( correctNetworkId );

    iData->iNewWithId = ETrue;

    item->iDNRecord = iCmMgr.SNAPRecordL( 0 );

    CleanupStack::PushL( item->iDNRecord );

    AddToArrayL( item );

    CleanupStack::Pop( 2, item );  // iDNRecord, item

    iData->iIdIsValid = EFalse;// the Id is still zero here

    } 

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

// CCmDestinationImpl::SetIdL()

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

//        

void CCmDestinationImpl::SetIdL( TInt aDestId )

    {

    LOGGER_ENTERFN( "CCmDestinationImpl::SetIdL" );

    TInt correctAPId( aDestId );

    if ( aDestId > 0 && aDestId < 255 )

        {

        correctAPId = aDestId + KCmDefaultDestinationAPTagId;

        }

    else if ( aDestId < KCmDefaultDestinationAPTagId + 1

             || aDestId > KCmDefaultDestinationAPTagId + 255 )

        {

        User::Leave( KErrArgument );

        }

    CheckIfDestinationIdExistsL( correctAPId );

    iData->iDestAPRecord->iRecordTag = correctAPId;

    };

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

// CCmDestinationImpl::CheckIfDestinationIdExistsL()

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

//

void CCmDestinationImpl::CheckIfDestinationIdExistsL( TUint32 aDestId )

    {

    LOGGER_ENTERFN( "CCmDestinationImpl::CheckIfDestinationNameExistL" );

    CMDBRecordSet<CCDAccessPointRecord>*  ptrRecordSet = 

          new (ELeave) CMDBRecordSet<CCDAccessPointRecord>( KCDTIdAccessPointRecord );

    CleanupStack::PushL( ptrRecordSet );    

    // Prime record

    CCDAccessPointRecord* record = static_cast<CCDAccessPointRecord *>

                                   ( CCDRecordBase::RecordFactoryL( KCDTIdAccessPointRecord ) );

    CleanupStack::PushL( record );

    record->iRecordTag = ( TInt )aDestId;

    ptrRecordSet->iRecords.AppendL( record );

    CleanupStack::Pop( record );

    record = NULL;

    if ( ptrRecordSet->FindL( Session() ) )

        {

        User::Leave( KErrAlreadyExists );      

        }

    ptrRecordSet->iRecords.ResetAndDestroy();

    CleanupStack::PopAndDestroy( ptrRecordSet );

    iData->iDestAPRecord->iRecordTag = aDestId;

    }

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

// CCmDestinationImpl::CheckIfDestinationNameExistL()

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

//

void CCmDestinationImpl::CheckIfDestinationNameExistL( const TDesC& aName )

    {

    LOGGER_ENTERFN( "CCmDestinationImpl::CheckIfDestinationNameExistL" );

    CMDBRecordSet<CCDSnapRecord>*  ptrRecordSet = 

                            new (ELeave) CMDBRecordSet<CCDSnapRecord>( 

                                 iCmMgr.DestinationTableId() );

    CleanupStack::PushL( ptrRecordSet );    

    // Prime record

    CCDSnapRecord* record = iCmMgr.SNAPRecordL( 0 );

    CleanupStack::PushL( record );

    record->iRecordName.SetL( aName );

    ptrRecordSet->iRecords.AppendL( record );

    CleanupStack::Pop( record );

    record = NULL;

    if ( ptrRecordSet->FindL( Session() ) )

        {

        User::Leave( KErrAlreadyExists );          

        }

    ptrRecordSet->iRecords.ResetAndDestroy();

    CleanupStack::PopAndDestroy( ptrRecordSet );            

    }

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

// CCmDestinationImpl::ConstructL()

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

//    

void CCmDestinationImpl::ConstructL( TUint aDestinationId )

    {

    CLOG_CREATE;

    CLOG_NAME_2( _L("Destination_0x%x_%d"), this, aDestinationId );

    iData =  new (ELeave) CCmDestinationData(iCmMgr);

    OpenTransactionLC();

    iData->iNetworkRecord = static_cast<CCDNetworkRecord *>(

                         CCDRecordBase::RecordFactoryL( KCDTIdNetworkRecord ) );

    iData->iDestAPRecord = static_cast<CCDAccessPointRecord *>(

                         CCDRecordBase::RecordFactoryL( KCDTIdAccessPointRecord ) );

    iData->iConnMethodArray = new (ELeave) CCmArray( KCmArrayBigGranularity );

    iData->iDeleteCmArray = new (ELeave) CCmArray( KCmArrayBigGranularity );

    TInt correctAPId = aDestinationId;

    TInt correctNetworkId = aDestinationId;

    if ( aDestinationId > 0 && aDestinationId < 255 )

        {

        correctAPId = aDestinationId + KCmDefaultDestinationAPTagId;

        }

    else if ( aDestinationId > KCmDefaultDestinationAPTagId 

              && ( aDestinationId < ( KCmDefaultDestinationAPTagId+255 ) ) )

        {

        correctNetworkId = aDestinationId - KCmDefaultDestinationAPTagId;

        }

    else

        {

        User::Leave( KErrArgument );

        }

    LoadDestAPRecordL( correctAPId );

    LoadNetworkRecordL( correctNetworkId );

    LoadConnectionMethodsL();

    LoadSNAPMetadataTableL();

    RollbackTransaction();

    iData->iIdIsValid = ETrue;

    }

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

// CCmDestinationImpl::Session()

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

//        

CMDBSession& CCmDestinationImpl::Session()const

    {

    return iCmMgr.Session();

    }

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

// CCmDestinationImpl::OpenTransactionLC

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

//

void CCmDestinationImpl::OpenTransactionLC()

    {

    LOGGER_ENTERFN( "CCmDestinationImpl::OpenTransactionL" );

    // Do NOT call OpenTransactionLC() more then once!

    iCmMgr.OpenTransactionLC( ETrue );

    }

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

// CCmDestinationImpl::CommitTransactionL

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

//

void CCmDestinationImpl::CommitTransactionL( TInt aError )

    {

    LOGGER_ENTERFN( "CCmDestinationImpl::CommitTransactionL" );

    iCmMgr.CommitTransactionL( aError );

    }

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

// CCmDestinationImpl::RollbackTransaction