diff -r 05bc53fe583b -r 83ca720e2b9a cmmanager/cmmgr/Framework/Src/cmdestinationimpl.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/cmmanager/cmmgr/Framework/Src/cmdestinationimpl.cpp Wed Sep 01 12:23:51 2010 +0100 @@ -0,0 +1,3499 @@ +/* +* 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 +#include +#include +#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS +#include +#include +#endif +#include "cmlogger.h" +#include "cmmanager.hrh" +#include +#include "datamobilitycommsdattypes.h" +#include +#include +#include +#include +#include // icons +#include +#include + +// System includes +#include // For REComSession +#include + +#include + +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( + 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( + 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( + 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( + 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* ptrRecordSet = + new (ELeave) CMDBRecordSet( KCDTIdAccessPointRecord ); + CleanupStack::PushL( ptrRecordSet ); + + // Prime record + CCDAccessPointRecord* record = static_cast + ( 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* ptrRecordSet = + new (ELeave) CMDBRecordSet( + 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( + CCDRecordBase::RecordFactoryL( KCDTIdNetworkRecord ) ); + + iData->iDestAPRecord = static_cast( + 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 +// --------------------------------------------------------------------------- +// +void CCmDestinationImpl::RollbackTransaction() + { + LOGGER_ENTERFN( "CCmDestinationImpl::RollbackTransaction" ); + + iCmMgr.RollbackTransaction(); + } + + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::NameLC() +// ----------------------------------------------------------------------------- +// +EXPORT_C HBufC* CCmDestinationImpl::NameLC( ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::NameLC" ); + + HBufC* name = NULL; + const TUint32 KSnapMetadataNameMask = 0x0000000F; + + TUint32 val = TUint32(iData->iMetaDataRec->iMetadata) & KSnapMetadataNameMask; + TUint32 val2 = (TUint32(iData->iMetaDataRec->iMetadata) & ESnapMetadataDestinationIsLocalised) + >> 4; + + if( (val == ESnapMetadataInternet) || + (val2 == ELocalisedDestInternet) ) + { + name = iCmMgr.AllocReadL( R_CMMANAGERUI_DEST_INTERNET ); + } + else if ( val2 == ELocalisedDestWap ) + { + name = iCmMgr.AllocReadL( R_CMMANAGERUI_DEST_WAP ); + } + else if ( val2 == ELocalisedDestMMS ) + { + name = iCmMgr.AllocReadL( R_CMMANAGERUI_DEST_MMS ); + } + else if ( val2 == ELocalisedDestIntranet ) + { + name = iCmMgr.AllocReadL( R_CMMANAGERUI_DEST_INTRANET ); + } + else + { + name = TPtrC(iData->iNetworkRecord->iRecordName).AllocL(); + } + + CleanupStack::PushL( name ); + + return name; + }; + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::SetNameL() +// ----------------------------------------------------------------------------- +// +EXPORT_C void CCmDestinationImpl::SetNameL( const TDesC& aName ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::SetNameL" ); + + // Destination cannot be renamed if it's + // - protected + // - Internet + if ( ProtectionLevel() == EProtLevel1 || + ProtectionLevel() == EProtLevel2 || + MetadataL( ESnapMetadataInternet ) ) + { + CCmManagerImpl::HasCapabilityL( ECapabilityNetworkControl ); + } + + OpenTransactionLC(); + CheckIfDestinationNameExistL( aName ); + CommitTransactionL( KErrNone ); + + iData->iNetworkRecord->iRecordName.SetL( aName ); + iData->iDestAPRecord->iRecordName.SetL( aName ); + }; + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::ConnectionMethodCount() +// ----------------------------------------------------------------------------- +// +TInt CCmDestinationData::ConnectionMethodCount() + { + LOGGER_ENTERFN( "CCmDestinationImpl::ConnectionMethodCount" ); + + return iConnMethodArray->Count() - KCmInitIndex; + }; + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::ConnectionMethodCount() +// ----------------------------------------------------------------------------- +// +EXPORT_C TInt CCmDestinationImpl::ConnectionMethodCount() + { + LOGGER_ENTERFN( "CCmDestinationImpl::ConnectionMethodCount" ); + + return iData->ConnectionMethodCount(); + }; + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::ConnectionMethodL +// ----------------------------------------------------------------------------- +// +EXPORT_C CCmPluginBaseEng* CCmDestinationImpl::ConnectionMethodL( TInt /*aIndex*/ ) + { + LOGGER_ENTERFN( "Error: Obsolete function CCmDestinationImpl::ConnectionMethodL used" ); + User::Panic( _L("CMManager"), KErrNotSupported ); + return NULL; + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::ConnectionMethodL +// ----------------------------------------------------------------------------- +// +EXPORT_C CCmPluginBase* CCmDestinationImpl::GetConnectionMethodL( TInt aIndex ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::ConnectionMethodL" ); + // Initial entry! + + CCmPluginBase* retVal = NULL; + TInt index = KCmInitIndex + aIndex; + CPluginItem* item = (*(iData->iConnMethodArray))[index]; + + LoadPluginL( *item ); + retVal = item->iPlugin; + + return retVal; + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::ConnectionMethodByIDL +// ----------------------------------------------------------------------------- +// +CCmPluginBase* CCmDestinationImpl::ConnectionMethodByIDL( TUint32 aCmId ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::ConnectionMethodByIDL" ); + + TInt found = ConnectionMethodIndex( aCmId ); + + if( found == KErrNotFound ) + { + User::Leave( KErrNotFound ); + } + + CPluginItem* item = (*(iData->iConnMethodArray))[found]; + + LoadPluginL( *item ); + + return item->iPlugin; + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::ConnectMethodIdArrayL +// ----------------------------------------------------------------------------- +// +void CCmDestinationImpl::ConnectMethodIdArrayL( RArray& aCmIds ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::ConnectMethodIdArrayL" ); + + TInt count = iData->iConnMethodArray->Count(); + + for( TInt i = KCmInitIndex; i < count; ++i ) + { + CPluginItem* item = (*(iData->iConnMethodArray))[i]; + + TUint32 elementId = item->iDNRecord->iIAP ? + RECORD_FROM_ELEMENT_ID( TUint32(item->iDNRecord->iIAP) ) : + TUint32( item->iDNRecord->iEmbeddedSNAP ); + + User::LeaveIfError( aCmIds.Append( elementId ) ); + } + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::AddToArrayL +// ----------------------------------------------------------------------------- +// +TInt CCmDestinationImpl::AddToArrayL( CPluginItem* aItem ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::AddToArrayL" ); + + TInt count = iData->iConnMethodArray->Count(); + if ( 0 == count ) + { + iData->iConnMethodArray->AppendL( aItem ); + CLOG_WRITE_1( "inserted: [%d]", count ); + return count; + } + + // Fill in SNAP record with IAP/EmbSNAP/SNAP values + TMDBElementId iapElemetid( 0 ); + TInt embDestId( 0 ); + + // No plugin means this is the template record. + TBool isDestination = aItem->iPlugin->GetBoolAttributeL( ECmDestination ); + if ( isDestination ) + { + embDestId = aItem->iPlugin->Destination()->Id(); + } + else + { + iapElemetid = aItem->iPlugin->IAPRecordElementId(); + } + + aItem->iDNRecord->iIAP = iapElemetid; + aItem->iDNRecord->iEmbeddedSNAP = embDestId; + + TUint32 prio = 0; + TUint32 bearerType = 0; + TUint32 extLevel = 0; + + TBool isVirtual( EFalse ); + + if ( count == KCmInitIndex ) + { + if( !aItem->iDNRecord->iIAP && !aItem->iDNRecord->iEmbeddedSNAP ) + { + iData->iConnMethodArray->AppendL( aItem ); + } + else + { + isVirtual = PrioDataL( aItem, prio, bearerType, extLevel ); + aItem->iDNRecord->iPriority = prio; + iData->iConnMethodArray->AppendL( aItem ); + } + return count; + } + + TInt insertedAt( -1 ); + + if ( !isDestination ) + { + // This function returns the info necessary for determining the priority + // It is the cm data in none VPN case + // It is the data of the underlying cm in case of VPN over cm + // It is wildcard prio in case of VPN over destination + isVirtual = PrioDataL( aItem, prio, bearerType, extLevel ); + + CLOG_WRITE_3( "inserted item prio: [%d], bearer: [%x] ext: [%d]", + prio, bearerType, extLevel ); + + // wildcard priority goes to back + if ( KDataMobilitySelectionPolicyPriorityWildCard == prio ) + { + // Set the default priority of a wildcard bearer + aItem->iDNRecord->iPriority = prio; + } + else + { + insertedAt = InsertSameMethodL( bearerType, isVirtual ); + if( insertedAt == -1 ) + { + insertedAt = InsertPriorityMethodL( prio, extLevel ); + } + + } // if wildcard + } // if !destination + + if( insertedAt == -1 ) + { + //Add to the end of the list + iData->iConnMethodArray->AppendL( aItem ); + insertedAt = iData->iConnMethodArray->Count()-1; + CLOG_WRITE_1( "inserted as last: [%d]", insertedAt ); + } + else + { + iData->iConnMethodArray->InsertL( insertedAt, aItem ); + } + + CLOG_WRITE_1( "inserted at: [%d]", insertedAt ); + + return insertedAt; + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::PrioDataL +// ----------------------------------------------------------------------------- +// +TBool CCmDestinationImpl::PrioDataL( CPluginItem* aItem, TUint32& aRetPrio, + TUint32& aRetBearer, TUint32& aRetExtLevel ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::PrioDataL" ); + + // Gets the data affecting the priority of the plugin in the list. + // It means the VPN priory based on the barer priority of the underlying cm + // or "wildcard" if VPN points to a destination + aRetPrio = aItem->iPlugin->GetIntAttributeL( ECmDefaultPriority ); + aRetBearer = aItem->iPlugin->GetIntAttributeL( ECmBearerType ); + aRetExtLevel = aItem->iPlugin->GetIntAttributeL( ECmExtensionLevel ); + + TBool isVirtual = aItem->iPlugin->GetBoolAttributeL( ECmVirtual ); + if( isVirtual ) + { + // Embeded destination is also virtual but further checking should + // not be done. + TBool isDestination = aItem->iPlugin->GetBoolAttributeL( ECmDestination ); + if( !isDestination ) + { + TUint32 underlying = aItem->iPlugin->GetIntAttributeL( + ECmNextLayerIapId ); + if ( underlying != 0 ) + { + // Gets the bearer of the underlying cm + aRetBearer = iCmMgr.BearerTypeFromCmIdL( underlying ); + // Gets the prio of the bearer + aRetPrio = + iCmMgr.GetBearerInfoIntL( aRetBearer, ECmDefaultPriority ); + aRetExtLevel = + iCmMgr.GetBearerInfoIntL( aRetBearer, ECmExtensionLevel ); + } + else + { + // VPN points to a destination so its priority is "wildcard" + aRetPrio = KDataMobilitySelectionPolicyPriorityWildCard; + } + } + } + + return isVirtual; + } + + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::InsertSameMethodL +// ----------------------------------------------------------------------------- +// +TInt CCmDestinationImpl::InsertSameMethodL( TUint32 aBearerType, TBool aIsVirtual ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::InsertSameMethodL" ); + + TInt insertedAt( -1 ); + TUint32 bearerInList( 0 ); + TUint32 prioInList( 0 ); + TUint32 extLevelInList( 0 ); + TBool isVirtualInList( EFalse ); + + TInt count = iData->iConnMethodArray->Count(); + // Loops throught the items in the list + for ( TInt i = count-1; ( i >= KCmInitIndex ) && ( insertedAt == -1) ; i-- ) + { + // Loads the plugin + CPluginItem* item = (*(iData->iConnMethodArray))[i]; + LoadPluginL( *item ); + + // Gets the data of the list item + isVirtualInList = PrioDataL( item, + prioInList, bearerInList, extLevelInList ); + + CLOG_WRITE_4( "actual item [%d] prio: [%d], bearer: [%x] ext: [%d]", + i, prioInList, bearerInList, extLevelInList ); + + // Bearer type the same + if( aBearerType == bearerInList ) + { + // puts Virt/Virt or !Virt/!Virt or !Virt/Virt + if( ( aIsVirtual == isVirtualInList ) || ( aIsVirtual && !isVirtualInList )) + { + insertedAt = i+1; + CLOG_WRITE_1( "inserted same bearer: [%d]", insertedAt ); + } + } // if bearer + } // for + return insertedAt; + } + + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::InsertPriorityMethodL +// ----------------------------------------------------------------------------- +// +TInt CCmDestinationImpl::InsertPriorityMethodL( TUint32 aPrio, TUint32 aExtLevel ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::InsertPriorityMethodL" ); + + TInt insertedAt = -1; + TUint32 bearerInList( 0 ); + TUint32 prioInList( 0 ); + TUint32 extLevelInList( 0 ); + + TInt count = iData->iConnMethodArray->Count(); + // Loops throught the items in the list + ////for ( TInt i = KCmInitIndex; ( i < count ) && ( insertedAt == -1) ; i++ ) + TInt i ( count-1 ); + for ( ; ( i >= KCmInitIndex ) && ( insertedAt == -1) ; i-- ) + { + // Loads the plugin + CPluginItem* item = (*(iData->iConnMethodArray))[i]; + LoadPluginL( *item ); + + // Gets the data of the list item + PrioDataL( item, prioInList, bearerInList, extLevelInList ); + + CLOG_WRITE_4( "actual item [%d] prio: [%d], bearer: [%x] ext: [%d]", + i, prioInList, bearerInList, extLevelInList ); + + // If the priority is the same then it should be inserted near here + if ( aPrio == prioInList ) + { + if( aExtLevel <= extLevelInList ) + { + insertedAt = i+1; + CLOG_WRITE_1( "inserted same bearer non virtual: [%d]", insertedAt ); + } + } + // Insert in front of the higher priority (prio 1 is the highest ...) + else if ( aPrio > prioInList ) + { + insertedAt = i+1; + CLOG_WRITE_1( "inserted higher prio: [%d]", insertedAt ); + } // if same prio + + } // for + + // This is the highest priority one. It should be inserted at the first pos. + if( -1 == insertedAt ) + { + insertedAt = KCmInitIndex; + CLOG_WRITE_1( "inserted first position: [%d]", insertedAt ); + } // if same prio + + return insertedAt; + } + +// ----------------------------------------------------------------------------- +// CCmDestinationData::ProtectionLevel() +// ----------------------------------------------------------------------------- +// +TProtectionLevel CCmDestinationData::ProtectionLevel() + { + TInt protection = TUint32(iMetaDataRec->iMetadata) & + KSnapMetadataProtecionLevelMask; + return TProtectionLevel(protection >> 28); + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::ProtectionLevel() +// ----------------------------------------------------------------------------- +// +EXPORT_C + TProtectionLevel CCmDestinationImpl::ProtectionLevel() + { + return iData->ProtectionLevel(); + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::SetAttributeL() +// ----------------------------------------------------------------------------- +// +EXPORT_C void CCmDestinationImpl::SetProtectionL( TProtectionLevel aProtectionLevel ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::SetProtectionL" ); + + CLOG_WRITE_1( "Level: [%d]", aProtectionLevel ); + + CCmManagerImpl::HasCapabilityL( ECapabilityNetworkControl ); + + // Make a destination protected. + TUint32 mask = ~KSnapMetadataProtecionLevelMask; + TUint32 temp = TUint32(iData->iMetaDataRec->iMetadata) & mask; + iData->iMetaDataRec->iMetadata = aProtectionLevel << 28; + iData->iMetaDataRec->iMetadata = temp | TUint32(iData->iMetaDataRec->iMetadata); + + iData->iProtectionChanged = ETrue; + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::CreateConnectionMethodL() +// ----------------------------------------------------------------------------- +// +CCmPluginBase* CCmDestinationImpl::CreateConnectionMethodL( + TUint32 aImplementationUid ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::CreateConnectionMethodL" ); + + CCmPluginBase* retval = NULL; + if( ProtectionLevel() == EProtLevel1 ) + { + CCmManagerImpl::HasCapabilityL( ECapabilityNetworkControl ); + } + retval = iCmMgr.CreateConnectionMethodL(aImplementationUid, this); + CleanupStack::PushL(retval); + AddConnectionMethodL(*retval); + CleanupStack::Pop(retval); + return retval; + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::CreateConnectionMethodL() +// ----------------------------------------------------------------------------- +// +CCmPluginBase* CCmDestinationImpl::CreateConnectionMethodL( + TUint32 aImplementationUid, + TUint32 aConnMthId ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::CreateConnectionMethodL" ); + + CCmPluginBase* retval = NULL; + if( ProtectionLevel() == EProtLevel1 ) + { + CCmManagerImpl::HasCapabilityL( ECapabilityNetworkControl ); + } + + retval = iCmMgr.CreateConnectionMethodL( aImplementationUid, + aConnMthId, + this ); + CleanupStack::PushL(retval); + AddConnectionMethodL(*retval); + CleanupStack::Pop(retval); + return retval; + } + + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::AddConnectionMethodL() +// ----------------------------------------------------------------------------- +// +TInt CCmDestinationImpl::AddConnectionMethodL( + CCmPluginBase& aConnectionMethod ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::AddConnectionMethodL" ); + + if( ProtectionLevel() == EProtLevel1 ) + { + CCmManagerImpl::HasCapabilityL( ECapabilityNetworkControl ); + } + + TUint cmId = aConnectionMethod.GetIntAttributeL( ECmId ); + + CPluginItem* item = new (ELeave) CPluginItem; + CleanupStack::PushL( item ); // 1 + + // get the plugin + CCmPluginBase* connMethod = new (ELeave) + CCmPluginBase(aConnectionMethod.Plugin()); + CleanupStack::PushL( connMethod );// 2 + connMethod->IncrementRefCounter(); + item->iPlugin = connMethod; + + // create the new record + item->iDNRecord = iCmMgr.SNAPRecordL( 0 ); + + CleanupStack::PushL( item->iDNRecord ); // 3 + + // if the destination is protection level 1, the connection method must be protected + if ( ProtectionLevel() == EProtLevel1 ) + { + item->iPlugin->SetBoolAttributeL( ECmProtected, ETrue ); + } + + TInt index = AddToArrayL( item ); + index = index - KCmInitIndex; //the array contains one initial item, so subtract KCmInitIndex from the index to get cm index! + + CleanupStack::Pop( 3, item ); // item, connMethod, iDNRecord + + return index; + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::AddEmbeddedDestinationL() +// ----------------------------------------------------------------------------- +// +TInt CCmDestinationImpl::AddEmbeddedDestinationL( + CCmDestinationImpl& aDestination ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::AddEmbeddedDestinationL" ); + + if( ProtectionLevel() == EProtLevel1 ) + { + CCmManagerImpl::HasCapabilityL( ECapabilityNetworkControl ); + } + + //Check to avoid multiple levels of embedding + CheckIfEmbeddedL( Id() ); + + //Check to avoid multiple levels of embedding + if ( aDestination.HasEmbeddedL() ) + { + User::Leave( KErrNotSupported ); + } + + // Only one embedded destination per destination is allowed + if ( HasEmbeddedL() ) + { + User::Leave( KErrNotSupported ); + } + + CPluginItem* item = new (ELeave) CPluginItem; + CleanupStack::PushL( item ); // 1 + + CreateEmbeddedDestinationPluginL( *item, aDestination.Id() ); + // create the new record + item->iDNRecord = iCmMgr.SNAPRecordL( 0 ); + item->iDNRecord->iPriority = KDataMobilitySelectionPolicyPriorityWildCard; + + CleanupStack::PushL( item->iDNRecord ); // 2 + TInt index = AddToArrayL( item ); + index = index - KCmInitIndex; //the array contains one initial item, so subtract KCmInitIndex from the index to get cm index! + + CleanupStack::Pop( 2, item ); // item, iDNRecord + + return index; + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::DeleteConnectionMethodL() +// ----------------------------------------------------------------------------- +// +void CCmDestinationImpl::DeleteConnectionMethodL( + CCmPluginBase& aConnectionMethod ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::DeleteConnectionMethodL" ); + + if( ProtectionLevel() == EProtLevel1 || + ProtectionLevel() == EProtLevel3 ) + { + CCmManagerImpl::HasCapabilityL( ECapabilityNetworkControl ); + } + + if ( aConnectionMethod.GetBoolAttributeL( ECmConnected ) ) + { + User::Leave( KErrInUse ); + } + + TInt index = FindConnectionMethodL( aConnectionMethod ); + + // move this method to the 'to be deleted' array + CPluginItem* item = (*(iData->iConnMethodArray))[index]; + + LoadPluginL( *item ); + + if( item->iPlugin->GetBoolAttributeL( ECmIsLinked ) ) + { + User::Leave( KErrLocked ); + } + + if ( ConnectionMethodCount() == 1 ) + { + // Check if this destination is referenced by Virtual CM + CheckIfReferencedByVirtualCML(); + } + + iData->iDeleteCmArray->AppendL( item ); + iData->iConnMethodArray->Delete( index ); + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::RemoveConnectionMethodL() +// ----------------------------------------------------------------------------- +// +void CCmDestinationImpl::RemoveConnectionMethodL( + const CCmPluginBase& aConnectionMethod ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::DeleteConnectionMethodL" ); + + if( ProtectionLevel() == EProtLevel1 || + ProtectionLevel() == EProtLevel3 ) + { + CCmManagerImpl::HasCapabilityL( ECapabilityNetworkControl ); + } + + if ( ConnectionMethodCount() == 1 ) + { + // Check if this destination is referenced by Virtual CM + CheckIfReferencedByVirtualCML(); + } + + TInt index = FindConnectionMethodL( aConnectionMethod ); + + // move this method to the 'to be deleted' array, but + // set remove only from, not to delete it on update. + CPluginItem* item = (*(iData->iConnMethodArray))[index]; + + item->iFlags |= CPluginItem::ERemoveCm; + + iData->iDeleteCmArray->AppendL( item ); + iData->iConnMethodArray->Delete( index ); + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::CheckIfReferencedByVirtualCML() +// ----------------------------------------------------------------------------- +// +void CCmDestinationImpl::CheckIfReferencedByVirtualCML() + { + // for each IAP in CM manager + // 1. check if it is virtual + // if not => goto 1. + // if yes: + // 2. check if it links to the destination of this CM + // if yes => carryOn = EFalse, ERROR + // if not: carryOn = ETrue + CommsDat::CMDBRecordSet* iaps = iCmMgr.AllIapsL(); + CleanupStack::PushL( iaps ); + + TBool carryOn = ETrue; + TUint32 destId = Id(); + + // for each IAP in CM manager + for ( TInt i = KCmInitIndex; carryOn && i < iaps->iRecords.Count(); ++i ) + { + CommsDat::CCDIAPRecord* rec = (*iaps)[i]; + TUint32 bearerType = 0; + + TRAP_IGNORE( bearerType = iCmMgr.BearerTypeFromIapRecordL( rec ) ); + if ( !bearerType ) + { + continue; + } + + // check if it is virtual + if ( iCmMgr.GetBearerInfoBoolL( bearerType, ECmVirtual ) ) + { + // check if it links to the current destination + CCmPluginBase* plugin = NULL; + TRAP_IGNORE( plugin = iCmMgr.GetConnectionMethodL( rec->RecordId() ) ); + + if ( !plugin ) + { + continue; + } + + if ( plugin->IsLinkedToSnap( destId ) ) + { + // the CM links to this destination, deletion not allowed + carryOn = EFalse; + } + + delete plugin; + } + } + + CleanupStack::PopAndDestroy( iaps ); + + if ( !carryOn ) + { + User::Leave( KErrLocked ); + } + } +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::RemoveConnectionMethodL() +// ----------------------------------------------------------------------------- +// +void CCmDestinationImpl::RemoveConnectionMethodL( + const CCmPluginBaseEng& aConnectionMethod ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::DeleteConnectionMethodL" ); + + if( ProtectionLevel() == EProtLevel1 || + ProtectionLevel() == EProtLevel3 ) + { + CCmManagerImpl::HasCapabilityL( ECapabilityNetworkControl ); + } + + TInt index = FindConnectionMethodL( aConnectionMethod ); + + // move this method to the 'to be deleted' array, but + // set remove only from, not to delete it on update. + CPluginItem* item = (*(iData->iConnMethodArray))[index]; + + item->iFlags |= CPluginItem::ERemoveCm; + + iData->iDeleteCmArray->AppendL( item ); + iData->iConnMethodArray->Delete( index ); + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::ConnectionMethodDeletedL() +// ----------------------------------------------------------------------------- +// +void CCmDestinationImpl::ConnectionMethodDeletedL( + const CCmPluginBase& aConnectionMethod ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::ConnectionMethodDeletedL" ); + + TInt found( KErrNotFound ); + TUint32 aCmId = aConnectionMethod.GetIntAttributeL( ECmId ); + + found = ConnectionMethodIndex( aCmId ); + + if( found != KErrNotFound ) + { + CPluginItem* item = (*(iData->iConnMethodArray))[found]; + + (*(iData->iConnMethodArray))[found] = NULL; + iData->iConnMethodArray->Delete( found ); + iData->iConnMethodArray->Compress(); + + // The iPlugin is deleted in plugin interface function + // that called this function. + delete item->iDNRecord; + delete item; + } + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::FindConnectionMethodL() +// ----------------------------------------------------------------------------- +// +TInt CCmDestinationImpl::FindConnectionMethodL( + const CCmPluginBase& aConnectionMethod ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::FindConnectionMethodL" ); + + TInt cmId = aConnectionMethod.GetIntAttributeL( ECmId ); + TBool embeded = aConnectionMethod.GetBoolAttributeL( ECmDestination ) ? + ETrue : + EFalse; + + CLOG_WRITE_2( "ID: [%d], embDest: [%d]", + cmId, + aConnectionMethod.GetBoolAttributeL( ECmDestination ) ); + + for ( TInt i = KCmInitIndex; i < iData->iConnMethodArray->Count(); ++i ) + { + CPluginItem* item = (*(iData->iConnMethodArray))[i]; + if( embeded ) + { + if( item->iDNRecord->iEmbeddedSNAP == cmId ) + { + return i; + } + } + else + { + if( RECORD_FROM_ELEMENT_ID(item->iDNRecord->iIAP) == cmId ) + { + return i; + } + } + } + + CLOG_WRITE( "Not found" ); + User::Leave( KErrNotFound ); + + // dummy return value. never used. + return -1; + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::FindConnectionMethodL() +// ----------------------------------------------------------------------------- +// +TInt CCmDestinationImpl::FindConnectionMethodL( + const CCmPluginBaseEng& aConnectionMethod ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::FindConnectionMethodL" ); + + TInt cmId = aConnectionMethod.GetIntAttributeL( ECmId ); + TBool embeded = aConnectionMethod.GetBoolAttributeL( ECmDestination ) ? + ETrue : + EFalse; + + CLOG_WRITE_2( "ID: [%d], embDest: [%d]", + cmId, + aConnectionMethod.GetBoolAttributeL( ECmDestination ) ); + + for ( TInt i = KCmInitIndex; i < iData->iConnMethodArray->Count(); ++i ) + { + CPluginItem* item = (*(iData->iConnMethodArray))[i]; + if( embeded ) + { + if( item->iDNRecord->iEmbeddedSNAP == cmId ) + { + return i; + } + } + else + { + if( RECORD_FROM_ELEMENT_ID(item->iDNRecord->iIAP) == cmId ) + { + return i; + } + } + } + + CLOG_WRITE( "Not found" ); + User::Leave( KErrNotFound ); + + // dummy return value. never used. + return -1; + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::ModifyPriorityL() +// ----------------------------------------------------------------------------- +// +void CCmDestinationImpl::ModifyPriorityL( CCmPluginBase& aCCMItem, + TUint aIndex ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::ModifyPriorityL" ); + + if (aCCMItem.GetBoolAttributeL(ECmDestination) || + (aCCMItem.GetBoolAttributeL(ECmVirtual) && + aCCMItem.GetIntAttributeL(ECmNextLayerSNAPId))) + { + // Priority can not be changed for this cm + return; + } + + if( ProtectionLevel() == EProtLevel1 || + ProtectionLevel() == EProtLevel3 ) + { + CCmManagerImpl::HasCapabilityL( ECapabilityNetworkControl ); + } + + TBool found( EFalse ); + TInt cm2 = aCCMItem.GetIntAttributeL( ECmId ); + + if ( aIndex >= ( iData->iConnMethodArray->Count() - KCmInitIndex ) ) + { + User::Leave( KErrArgument ); + } + + for ( TInt i = KCmInitIndex; i < iData->iConnMethodArray->Count(); i++ ) + { + LoadPluginL( *(*(iData->iConnMethodArray))[i] ); + + // Compare the IAP IDs + TInt cm1 = (*(iData->iConnMethodArray))[i]->iPlugin->GetIntAttributeL( ECmId ); + + if ( cm1 == cm2 ) + { + CPluginItem* item = (*(iData->iConnMethodArray))[i]; + + TInt pri = (*(iData->iConnMethodArray))[i]->iDNRecord->iPriority; + if ( pri == KDataMobilitySelectionPolicyPriorityWildCard ) + { + TUint32 prio = 0; + TUint32 bearerType = 0; + TUint32 extLevel = 0; + + TBool isVirtual = PrioDataL( item, prio, bearerType, extLevel ); + if (prio != KDataMobilitySelectionPolicyPriorityWildCard) + { + // The priority will be changed later when UpdateL is called + // So, the priority will simply be chnaged from + // KDataMobilitySelectionPolicyPriorityWildCard to value i + (*(iData->iConnMethodArray))[i]->iDNRecord->iPriority = i; + } + } + + (*(iData->iConnMethodArray))[i] = NULL; + + // remove from array + iData->iConnMethodArray->Delete( i ); + iData->iConnMethodArray->Compress(); + iData->iConnMethodArray->InsertL( KCmInitIndex + aIndex, item ); + + found = ETrue; + break; + } + } + + if ( !found ) + { + User::Leave( KErrArgument ); + } + + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::PriorityL() +// ----------------------------------------------------------------------------- +// +TUint CCmDestinationImpl::PriorityL( CCmPluginBaseEng& aCCMItem ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::PriorityL" ); + + TInt index = FindConnectionMethodL( aCCMItem ); + + return (*(iData->iConnMethodArray))[index]->iDNRecord->iPriority; + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::PriorityL() +// ----------------------------------------------------------------------------- +// +TUint CCmDestinationImpl::PriorityL( CCmPluginBase& aCCMItem ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::PriorityL" ); + + TInt index = FindConnectionMethodL( aCCMItem ); + + return (*(iData->iConnMethodArray))[index]->iDNRecord->iPriority; + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::UpdateL() +// ----------------------------------------------------------------------------- +// +EXPORT_C void CCmDestinationImpl::UpdateL() + { + LOGGER_ENTERFN( "CCmDestinationImpl::UpdateL" ); + + // Connection methods and destination records are updated in + // one transaction. + OpenTransactionLC(); + + DeleteConnectionMethodsL(); + + // Update protection level of connection methods if it's changed in + // the destination + UpdateProtectionL(); + // Updates all modified connection methods. + UpdateConnectionMethodsL(); + UpdateNetworkRecordL(); + UpdateDestAPRecordL(); + UpdateSNAPTableL(); + UpdateSNAPMetadataTableL(); + + CommitTransactionL( KErrNone ); + + // set the last updated protection level of the destination + iData->iLastProtectionLevel = ProtectionLevel(); + + // Clear the modified flag + iData->iProtectionChanged = EFalse; + + // empty the array, but do not delete it + iData->ResetAndDestroyArray( iData->iDeleteCmArray, EFalse ); + + iCmMgr.DestinationUpdated(this); + iData->iIdIsValid = ETrue; + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::DeleteLD() +// ----------------------------------------------------------------------------- +// +EXPORT_C void CCmDestinationImpl::DeleteLD() + { + LOGGER_ENTERFN( "CCmDestinationImpl::DeleteLD" ); + + if( ProtectionLevel() == EProtLevel1 ) + { + CCmManagerImpl::HasCapabilityL( ECapabilityNetworkControl ); + } + + TInt count = iData->iConnMethodArray->Count(); + + if( IsConnectedL() ) + { + User::Leave( KErrInUse ); + } + + // Check first that any of the CMs in this Destination is not + // referenced by Virtual CM + TInt i( 0 ); + + for( i = KCmInitIndex; i < count; ++i ) + { + CPluginItem* item = (*(iData->iConnMethodArray))[i]; + + LoadPluginL( *item ); + + if( item->iPlugin->GetBoolAttributeL( ECmIsLinked ) ) + { + User::Leave( KErrLocked ); + } + } + // Check that this Destination is not referenced by any Virtual CM + if ( ConnectionMethodCount() > 0 ) + { + CheckIfReferencedByVirtualCML(); + } + + OpenTransactionLC(); + TRAPD( err, DeleteRelatedRecordsL( count ) ); + if ( err ) + { + RollbackTransaction(); + User::Leave( err ); + } + CommitTransactionL(KErrNone); + + delete this; + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::DeleteRelatedRecordsL() +// ----------------------------------------------------------------------------- +// +void CCmDestinationImpl::DeleteRelatedRecordsL( TInt aCount ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::DeleteRelatedRecordsL" ); + + CleanUpEmbeddedL( Id() ); + + TCmDefConnValue deletedItem; + deletedItem.iType = ECmDefConnDestination; + deletedItem.iId = Id(); + iCmMgr.HandleDefConnDeletedL( deletedItem ); + CMDBRecordBase* dnIapRecord; + TInt i; + + // Here we don't use KCmInitIndex becouse initial entry should be deleted + // too! + for ( i = 0; i < aCount; i++ ) + { + CPluginItem* item = (*(iData->iConnMethodArray))[i]; + + // Delete the plugin + if ( i >= KCmInitIndex ) + { + if ( !item->iPlugin->Plugin()->IdIsValid() ) + { + // Delete incomplete plugin + delete item->iPlugin; + item->iPlugin = NULL; + } + else + { + TRAPD( err, item->iPlugin->DeleteL( EFalse ) ); + + if( err != KErrLocked && + err != KErrNotReady ) + { + User::LeaveIfError( err ); + } + + delete item->iPlugin; + item->iPlugin = NULL; + } + } + + // Delete the DN-IAP record + dnIapRecord = item->iDNRecord; + + if ( dnIapRecord->RecordId() ) + // If we have record Id, this record is already in CommsDat + { + dnIapRecord->DeleteL( Session() ); + } + delete item->iDNRecord; + item->iDNRecord = NULL; + } + + iData->iDestAPRecord->DeleteL( Session() ); // deletes a record + iData->iNetworkRecord->DeleteL( Session() ); // deletes a record + + // Delete SNAPMetadata table + CMDBRecordSet* ptrRecordSet = + new (ELeave) CMDBRecordSet( + iCmMgr.IconTableId() ); + CleanupStack::PushL( ptrRecordSet ); + + // Prime record + CCDSNAPMetadataRecord* record = + new (ELeave) CCDSNAPMetadataRecord( iCmMgr.IconTableId() ); + CleanupStack::PushL( record ); + record->iSNAP = Id(); + ptrRecordSet->iRecords.AppendL( record ); + + CleanupStack::Pop( record ); + record = NULL; + + if ( ptrRecordSet->FindL( Session() ) ) + { + (*ptrRecordSet)[0]->DeleteL( Session() ); + } + + ptrRecordSet->iRecords.ResetAndDestroy(); + CleanupStack::PopAndDestroy( ptrRecordSet ); + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::CheckIfEmbeddedL() +// ----------------------------------------------------------------------------- +// +void CCmDestinationImpl::CheckIfEmbeddedL( TInt aId ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::CheckIfEmbeddedL" ); + + CMDBRecordSet* ptrRecordSet = + new (ELeave) CMDBRecordSet( + iCmMgr.DestinationTableId() ); + CleanupStack::PushL( ptrRecordSet ); + + // Prime record + CCDSnapRecord* record = iCmMgr.SNAPRecordL( 0 ); + CleanupStack::PushL( record ); + record->iEmbeddedSNAP = aId; + ptrRecordSet->iRecords.AppendL( record ); + + CleanupStack::Pop( record ); + record = NULL; + + OpenTransactionLC(); + if( ptrRecordSet->FindL( Session() ) ) + // Match found - it's embedded + { + User::Leave( KErrNotSupported ); + } + RollbackTransaction(); + + ptrRecordSet->iRecords.ResetAndDestroy(); + + CleanupStack::PopAndDestroy( ptrRecordSet ); + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::HasEmbeddedL +// ----------------------------------------------------------------------------- +// +TBool CCmDestinationImpl::HasEmbeddedL() + { + LOGGER_ENTERFN( "CCmDestinationImpl::HasEmbeddedL" ); + + return ( EmbeddedL() != NULL )? ETrue : EFalse; + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::EmbeddedL +// ----------------------------------------------------------------------------- +// +CCmDestinationImpl* CCmDestinationImpl::EmbeddedL() + { + LOGGER_ENTERFN( "CCmDestinationImpl::EmbeddedL" ); + + CCmDestinationImpl* retVal = NULL; + // Check if the destination contains embedded destinations + for ( TInt i = KCmInitIndex; i < iData->iConnMethodArray->Count(); i++ ) + { + LoadPluginL( *(*(iData->iConnMethodArray))[i] ); + // It's an embedded destination ( this is also true for VPN CMs ) + retVal = (*(iData->iConnMethodArray))[i]->iPlugin->Destination(); + if ( retVal ) + { + // as there can be only one + // embedded destination, the first one is enough + break; + } + } + + return retVal; + } + + // ----------------------------------------------------------------------------- +// CCmDestinationImpl::CanUseToConnectL +// ----------------------------------------------------------------------------- +// +TBool CCmDestinationImpl::CanUseToConnectL() + { + LOGGER_ENTERFN( "CCmDestinationImpl::CanUseToConnectL" ); + + const TInt KZeroItem = 0; + const TInt KOneItem = 1; + TInt cmCount = ConnectionMethodCount(); //without KCmInitIndex !!! + switch ( cmCount ) + { + case KZeroItem:// no items at all + { + return EFalse; + } + case KOneItem:// One item, a possible empty embedded destination! + { + CCmDestinationImpl* embeddedDest = EmbeddedL(); + if ( embeddedDest ) + { + // If embeddedDest->ConnectionMethodCount() is not zero, + // we have something in the embedded destination + // which cannot be another embedded destination, + // since multiple embedding is not allowed. + return embeddedDest->ConnectionMethodCount(); + } + else + { + return ETrue; //not an embedded destination + } + } + default: // more than one item, only one can be an empty embedded + // destination, so we surely contain a valid cm + { + return ETrue; + } + + } + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::UpdateNetworkRecordL() +// ----------------------------------------------------------------------------- +// +void CCmDestinationImpl::UpdateNetworkRecordL() + { + LOGGER_ENTERFN( "CCmDestinationImpl::UpdateNetworkRecordL" ); + + if ( !iData->iNetworkRecord->RecordId() || iData->iNewWithId ) + { + CLOG_WRITE( "New Destination, create it!" ); + //Create a network record, set the host name and add it to the database + + if ( !iData->iNewWithId ) + { + iData->iNetworkRecord->SetRecordId(KCDNewRecordRequest); + } + + SetAttribute( iData->iNetworkRecord, + ECDProtectedWrite, + ProtectionLevel() == EProtLevel1 ); + + iData->iNetworkRecord->StoreL( Session() ); //adds a new record + iData->iNewWithId = EFalse; + } + else + { + SetAttribute( iData->iNetworkRecord, + ECDProtectedWrite, + ProtectionLevel() == EProtLevel1 ); + + iData->iNetworkRecord->ModifyL( Session() ); + } + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::UpdateDestAPRecordL() +// ----------------------------------------------------------------------------- +// +void CCmDestinationImpl::UpdateDestAPRecordL() + { + LOGGER_ENTERFN( "CCmDestinationImpl::UpdateDestAPRecordL" ); + + if ( !iData->iDestAPRecord->RecordId() ) + { + CLOG_WRITE( "New Destination, create AP for it!" ); + //Create an AP record, set the selection policy(network id) + //and add it to the database + iData->iDestAPRecord->SetRecordId(KCDNewRecordRequest); + iData->iDestAPRecord->iRecordTag = CreateDestinationAPTagIdL(); + iData->iDestAPRecord->iCustomSelectionPolicy = iData->iNetworkRecord->RecordId(); + iData->iDestAPRecord->iRecordName.SetL(iData->iNetworkRecord->iRecordName); + iData->iDestAPRecord->StoreL( Session() ); //adds a new record + } + else + { + iData->iDestAPRecord->iCustomSelectionPolicy = iData->iNetworkRecord->RecordId(); + iData->iDestAPRecord->iRecordName.SetL(iData->iNetworkRecord->iRecordName); + iData->iDestAPRecord->ModifyL( Session() ); //modifies the existing + } + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::CreateDestinationAPTagId() +// ----------------------------------------------------------------------------- +// +TUint32 CCmDestinationImpl::CreateDestinationAPTagIdL() + { + LOGGER_ENTERFN( "CCmDestinationImpl::CreateDestinationAPTagId" ); + + return KCmDefaultDestinationAPTagId + iData->iNetworkRecord->RecordId(); + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::GetDestinationAPTagId() +// ----------------------------------------------------------------------------- +// +TUint32 CCmDestinationImpl::GetDestinationAPTagId( ) + { + return iData->iNetworkRecord->RecordId() + KCmDefaultDestinationAPTagId; + } + + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::UpdateProtectionL() +// ----------------------------------------------------------------------------- +// +void CCmDestinationImpl::UpdateProtectionL() + { + LOGGER_ENTERFN( "CCmDestinationImpl::UpdateProtectionL" ); + + if( !iData->iProtectionChanged ) + // protection level not changed -> nothing to update here + { + return; + } + + for ( TInt i = KCmInitIndex; i < iData->iConnMethodArray->Count(); i++ ) + { + CPluginItem* item = (*(iData->iConnMethodArray))[i]; + + LoadPluginL( *item ); + + switch ( ProtectionLevel() ) + { + case EProtLevel0: + case EProtLevel2: + { + // from the protection level 0 to 2 and vice versa + // the ECmProtected value of the CM is not changed + if( iData->iLastProtectionLevel == EProtLevel1 || + iData->iLastProtectionLevel == EProtLevel3 ) + { + item->iPlugin->SetBoolAttributeL( ECmProtected, EFalse ); + } + } + break; + case EProtLevel1: + case EProtLevel3: + { + item->iPlugin->SetBoolAttributeL( ECmProtected, ETrue ); + } + break; + default: + { + // + } + break; + } + } + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::UpdateConnectionMethodsL() +// ----------------------------------------------------------------------------- +// +void CCmDestinationImpl::UpdateConnectionMethodsL() + { + LOGGER_ENTERFN( "CCmDestinationImpl::UpdateConnectionMethodsL" ); + + for( TInt i = KCmInitIndex; i < iData->iConnMethodArray->Count(); ++i ) + { + CPluginItem* item = (*(iData->iConnMethodArray))[i]; + + // If the plugin is not loaded, it means that this a old one, or nothing + // modified in it -> there's no need to update it. + if( item->iPlugin ) + { + item->iPlugin->UpdateL(); + } + } + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::SetAttribute() +// ----------------------------------------------------------------------------- +// +void CCmDestinationImpl::SetAttribute( CMDBRecordBase* aRecord, + TUint32 aAttribute, TBool aSet ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::SetAttribute" ); + + if ( aSet && !aRecord->IsSetAttribute( aAttribute ) ) + { + aRecord->SetAttributes( aAttribute ); + } + else if( !aSet && aRecord->IsSetAttribute( aAttribute ) ) + { + aRecord->ClearAttributes( aAttribute ); + } + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::UpdateSNAPTableL() +// ----------------------------------------------------------------------------- +// +void CCmDestinationImpl::UpdateSNAPTableL() + { + LOGGER_ENTERFN( "CCmDestinationImpl::UpdateSNAPTableL" ); + + TInt i; + CCDSnapRecord* dnIapRecord; + + // Now we have only records of which are new or needs to be updated + for ( i = KCmInitIndex; i < iData->iConnMethodArray->Count(); ++i ) + { + TInt pri = (*(iData->iConnMethodArray))[i]->iDNRecord->iPriority; + + if ( pri != i && + pri != KDataMobilitySelectionPolicyPriorityWildCard ) + // wildcard priority CM have to be the last one in the array. + // In theory they cannot be re-prioritized. + { + (*(iData->iConnMethodArray))[i]->iDNRecord->iPriority = i; + } + } + + // Here we don't use KCmInitIndex becouse initial entry should be updated + // too! + for ( i = 0; i < iData->iConnMethodArray->Count(); ++i ) + { + dnIapRecord = (*(iData->iConnMethodArray))[i]->iDNRecord; + + if( dnIapRecord->iIAP ) + { + if( !RECORD_FROM_ELEMENT_ID( dnIapRecord->iIAP ) ) + { + dnIapRecord->iIAP = (*(iData->iConnMethodArray))[i]->iPlugin->IAPRecordElementId(); + } + } + + // Set protection on connection methods + SetAttribute( dnIapRecord, + ECDProtectedWrite, + ProtectionLevel() == EProtLevel1 ? ETrue : EFalse ); + // Metadata is used instead of ECDHidden Attribute + //SetAttribute( dnIapRecord, ECDHidden, iData->iNetworkRecord->Attributes() & ECDHidden ); + CheckIfNameModifiedL( dnIapRecord ); + + if ( dnIapRecord->RecordId() ) + { + dnIapRecord->ModifyL( Session() ); + } + else + // this is a new record + { + dnIapRecord->SetRecordId(KCDNewRecordRequest); + dnIapRecord->iSNAP = Id(); + dnIapRecord->StoreL( Session() ); + } + } + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::UpdateSNAPMetadataTableL() +// ----------------------------------------------------------------------------- +// +void CCmDestinationImpl::UpdateSNAPMetadataTableL() + { + LOGGER_ENTERFN( "CCmDestinationImpl::UpdateSNAPMetadataTableL" ); + + if( !iData->iMetaDataRec->RecordId() ) + // new record + { + iData->iMetaDataRec->iSNAP = Id(); + iData->iMetaDataRec->SetRecordId( KCDNewRecordRequest ); + iData->iMetaDataRec->StoreL( Session() ); + } + else + { + iData->iMetaDataRec->ModifyL( Session() ); + } + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::LoadSNAPMetadataTableL() +// ----------------------------------------------------------------------------- +// +void CCmDestinationImpl::LoadSNAPMetadataTableL() + { + LOGGER_ENTERFN( "CCmDestinationImpl::LoadSNAPMetadataTableL" ); + + iData->iMetaDataRec = new (ELeave) CCDSNAPMetadataRecord( + iCmMgr.IconTableId() ); + + iData->iMetaDataRec->iSNAP = Id(); + + if ( !iData->iMetaDataRec->FindL( Session() ) ) + // Not found -> fill in with default values + { + iData->iMetaDataRec->iSNAP = Id(); + iData->iMetaDataRec->iIcon = 0; + iData->iMetaDataRec->iMetadata = 0; + } + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::LoadNetworkRecordL() +// ----------------------------------------------------------------------------- +// +void CCmDestinationImpl::LoadNetworkRecordL( TUint32 /*aDestinationId*/ ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::LoadNetworkRecordL" ); + + // set the record ID + iData->iNetworkRecord->SetRecordId( iData->iDestAPRecord->iCustomSelectionPolicy ); + + // load the record ID + iData->iNetworkRecord->LoadL( Session() ); + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::LoadDestAPRecordL() +// ----------------------------------------------------------------------------- +// +void CCmDestinationImpl::LoadDestAPRecordL( TUint32 aDestinationId ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::LoadDestAPRecordL" ); + + if ( aDestinationId > KCmDefaultDestinationAPTagId ) + { + // set the record ID + iData->iDestAPRecord->iRecordTag = aDestinationId; + // load the record ID + if ( iData->iDestAPRecord->FindL( Session() ) ) + { + iData->iDestAPRecord->LoadL( Session() ); + } + else + { + User::Leave( KErrNotFound ); + } + } + else + { + User::Leave( KErrArgument ); + } + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::LoadConnectionMethodsL() +// ----------------------------------------------------------------------------- +// +void CCmDestinationImpl::LoadConnectionMethodsL() + { + LOGGER_ENTERFN( "CCmDestinationImpl::LoadConnectionMethodsL" ); + + CMDBRecordSet* ptrRecordSet = + new (ELeave) CMDBRecordSet( + iCmMgr.DestinationTableId() ); + CleanupStack::PushL( ptrRecordSet ); + + // Prime record + CCDSnapRecord* snapRec = iCmMgr.SNAPRecordL( 0 ); + CleanupStack::PushL( snapRec ); + snapRec->iSNAP = Id(); + ptrRecordSet->iRecords.AppendL( snapRec ); + + CleanupStack::Pop( snapRec ); + snapRec = NULL; + + OpenTransactionLC(); + if ( !ptrRecordSet->FindL(Session()) ) + // no conn method is to this destination -> it was not us who made it + { + CLOG_WRITE( "Empty destination" ); + User::Leave( KErrUnderflow ); + } + + TLinearOrder orderbyId( + CCmDestinationImpl::SortRecordsByPriority ); + ptrRecordSet->iRecords.Sort(orderbyId); + + TInt count = ptrRecordSet->iRecords.Count(); + + //Load IAP records to be used to check if the IAPs are existing + CMDBRecordSet* ptrIapSet = + new (ELeave) CMDBRecordSet( KCDTIdIAPRecord ); + CleanupStack::PushL( ptrIapSet ); + + TRAPD( err, ptrIapSet->LoadL( Session() ) ); + + if( !err ) + { + CLOG_WRITE_1_PTR( NULL, "Record num [%d]", ptrIapSet->iRecords.Count() ); + + // Here we don't use CM_INIT_INDEX because initial entry should be + // loaded too! + for ( TInt i = 0; i < count; i++ ) + { + snapRec = (*ptrRecordSet)[i]; + TBool exist( EFalse ); + + // Check if CM really exists, if not + // it should be cleared from selection policy table + TInt32 embedded = QUERY_INT_FIELD( + snapRec, + KCDTIdDataMobilitySelectionPolicyEmbeddedSNAP ); + TInt32 iap = RECORD_FROM_ELEMENT_ID( + QUERY_INT_FIELD( + snapRec, + KCDTIdDataMobilitySelectionPolicyIAP ) ); + // Item could be embedded destination or iap + if ( embedded ) + { + CCDAccessPointRecord * destAPRecord = static_cast( + CCDRecordBase::RecordFactoryL( KCDTIdAccessPointRecord ) ); + CleanupStack::PushL( destAPRecord ); + destAPRecord->iRecordTag = embedded; + if ( !destAPRecord->FindL( Session() ) ) + { + CleanUpSnapMetadataTableL( embedded ); + (*ptrRecordSet)[i]->DeleteL( Session() ); + } + else + { + exist = ETrue; + } + + CleanupStack::PopAndDestroy( destAPRecord ); + } + else if ( iap ) + // This is an AP + { + for ( TInt iapInd = 0; iapInd < ptrIapSet->iRecords.Count(); ++iapInd ) + { + CMDBRecordBase* iapRec = (*ptrIapSet)[iapInd]; + + if ( iap == iapRec->RecordId() ) + { + exist = ETrue; + delete iapRec; + // this way we can filter out duplicated CMs + ptrIapSet->iRecords.Remove( iapInd ); + break; + } + } + if ( !exist ) + { + DeleteIAPRecordsL( snapRec ); + } + } + + // The first record is a dummy one where iap and snap are zero + if ( exist || ( !embedded && !iap ) ) + { + // The item may have to be loaded at this stage so that the supported can be checked + // before it is put into iData->iConnMethodArray for the item may be unsupported. + TInt err( 0 ); + + if ( i != 0 ) + { + if ( embedded ) + { + TRAP( err, TUint32 bearerType = iCmMgr.BearerTypeFromCmIdL( embedded ) ); + } + else if ( iap ) + { + TRAP( err, TUint32 bearerType = iCmMgr.BearerTypeFromCmIdL( iap ) ); + } + } + + if ( !err ) + { + CPluginItem* item = new (ELeave) CPluginItem; + CleanupStack::PushL( item ); + + item->iDNRecord = iCmMgr.SNAPRecordL( snapRec->RecordId() ); + item->iPlugin = NULL; + + iData->iConnMethodArray->AppendL( item ); + + CleanupStack::Pop( item ); + } + } + } + } + else + // There's no connection method in the phone + { + CPluginItem* item = new (ELeave) CPluginItem; + + CleanupStack::PushL( item ); + + item->iDNRecord = iCmMgr.SNAPRecordL( (*ptrRecordSet)[0]->RecordId() ); + + iData->iConnMethodArray->AppendL( item ); + + CleanupStack::Pop( item ); + } + + CleanupStack::PopAndDestroy( ptrIapSet ); + RollbackTransaction(); + + ptrRecordSet->iRecords.ResetAndDestroy(); + CleanupStack::PopAndDestroy( ptrRecordSet ); + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::ReLoadConnectionMethodsL() +// ----------------------------------------------------------------------------- +// +void CCmDestinationImpl::ReLoadConnectionMethodsL() + { + TInt count = iData->iConnMethodArray->Count(); + //TInt index = KCmInitIndex; + TInt index = 0; + + while ( index < count ) + { + CPluginItem* item = (*(iData->iConnMethodArray))[index]; + item->iFlags |= CPluginItem::ERemoveCm; + + iData->iDeleteCmArray->AppendL( item ); + iData->iConnMethodArray->Delete( index ); + iData->iConnMethodArray->Compress(); + + count = iData->iConnMethodArray->Count(); + } + + // Empty the array, but do not delete it + iData->ResetAndDestroyArray( iData->iDeleteCmArray, EFalse ); + + LoadConnectionMethodsL(); + } + +// --------------------------------------------------------- +// CCmDestinationImpl::CleanUpEmbeddedL +// --------------------------------------------------------- +// +void CCmDestinationImpl::CleanUpEmbeddedL(TUint32 aDestId) + { + LOGGER_ENTERFN( "CCmDestinationImpl::CleanUpEmbeddedL" ); + + TBool found = EFalse; + CMDBRecordSet* ptrRecordSet = + new (ELeave) CMDBRecordSet( + iCmMgr.DestinationTableId() ); + CleanupStack::PushL( ptrRecordSet ); + // Prime record + CCDSnapRecord* snapRec = iCmMgr.SNAPRecordL( 0 ); + CleanupStack::PushL( snapRec ); + snapRec->iEmbeddedSNAP = aDestId; + ptrRecordSet->iRecords.AppendL( snapRec ); + CleanupStack::Pop( snapRec ); + snapRec = NULL; + + if ( ptrRecordSet->FindL(Session()) ) + { + for ( TInt i = 0; i iRecords.Count(); i++ ) + { + (*ptrRecordSet)[i]->DeleteL( Session() ); + } + found = ETrue; + } + CleanupStack::PopAndDestroy( ptrRecordSet ); + if (found) + { + CleanUpSnapMetadataTableL(aDestId); + } + } +// --------------------------------------------------------- +// CCmDestinationImpl::CleanUpSnapMetadataTableL +// --------------------------------------------------------- +// +void CCmDestinationImpl::CleanUpSnapMetadataTableL( TUint32 aSnap ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::CleanUpSnapMetadataTableL" ); + + // Just to test how many record we have + CMDBRecordSet* ptrRecordSet + = new (ELeave) CMDBRecordSet( + iCmMgr.IconTableId() ); + CleanupStack::PushL( ptrRecordSet ); + + // Prime record + CCDSNAPMetadataRecord* record = + new (ELeave) CCDSNAPMetadataRecord( iCmMgr.IconTableId() ); + CleanupStack::PushL( record ); + + record->iSNAP = aSnap; + ptrRecordSet->iRecords.AppendL( record ); + + CleanupStack::Pop( record ); + record = NULL; + + if ( ptrRecordSet->FindL( Session() ) ) + { + for ( TInt i = 0; i iRecords.Count(); i++ ) + { + (*ptrRecordSet)[i]->DeleteL( Session() ); + } + } + + CleanupStack::PopAndDestroy( ptrRecordSet ); //ptrRecordSet + } + +// --------------------------------------------------------- +// CCmDestinationImpl::CleanUpSeamlessnessTableL +// --------------------------------------------------------- +// +void CCmDestinationImpl::CleanUpSeamlessnessTableL( TUint32 aIapId ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::CleanUpSeamlessnesstableL" ); + + // Just to test how many record we have + CMDBRecordSet* ptrRecordSet + = new (ELeave) CMDBRecordSet( + iCmMgr.SeamlessnessTableId() ); + CleanupStack::PushL( ptrRecordSet ); + + // Prime record + CCDIAPMetadataRecord* record = + new (ELeave) CCDIAPMetadataRecord( iCmMgr.SeamlessnessTableId() ); + CleanupStack::PushL( record ); + + TMDBElementId elementid = iCmMgr.SeamlessnessTableId() & + KCDTIdIAPMetadataIAP & + aIapId; + record->iSeamlessness = elementid; + ptrRecordSet->iRecords.AppendL( record ); + + CleanupStack::Pop( record ); + record = NULL; + + if ( ptrRecordSet->FindL( Session() ) ) + { + for ( TInt i = 0; i iRecords.Count(); i++ ) + { + (*ptrRecordSet)[i]->DeleteL( Session() ); + } + } + + CleanupStack::PopAndDestroy( ptrRecordSet ); + } + +// --------------------------------------------------------- +// CCmDestinationImpl::SortRecordsByPriority +// --------------------------------------------------------- +// +TInt CCmDestinationImpl::SortRecordsByPriority( const CMDBRecordBase& aLeft, + const CMDBRecordBase& aRight ) + { + TUint left = QUERY_INT_FIELD( const_cast(&aLeft), + KCDTIdDataMobilitySelectionPolicyPriority ); + TUint right = QUERY_INT_FIELD( const_cast(&aRight), + KCDTIdDataMobilitySelectionPolicyPriority ); + + /* + * - negative value, if aLeft is less than aRight; + * - 0, if aLeft equals to aRight; + * - positive value, if aLeft is greater than aRight. + */ + if ( left == right ) + { + return 0; + } + + return ( left < right ) ? -1 : 1; + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::IconL() +// ----------------------------------------------------------------------------- +// +EXPORT_C CGulIcon* CCmDestinationImpl::IconL() + { + LOGGER_ENTERFN( "CCmDestinationImpl::IconL" ); + + return IconL( iData->iMetaDataRec->iIcon ); + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::SetIconL() +// ----------------------------------------------------------------------------- +// +void CCmDestinationImpl::SetIconL( TUint32 anIndex ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::SetIconL" ) + + if( ProtectionLevel() == EProtLevel1 ) + { + CCmManagerImpl::HasCapabilityL( ECapabilityNetworkControl ); + } + + iData->iMetaDataRec->iIcon = anIndex; + } + +// ----------------------------------------------------------------------------- +// CCmDestinationData::MetadataL() +// ----------------------------------------------------------------------------- +// +TUint32 CCmDestinationData::MetadataL( TSnapMetadataField aMetaField ) const + { + LOGGER_ENTERFN( "CCmDestinationImpl::MetadataL" ) + + TUint retVal( 0 ); + + switch( aMetaField ) + { + case ESnapMetadataInternet: + { + retVal = TUint32(iMetaDataRec->iMetadata) & + ESnapMetadataInternet; + } + break; + + case ESnapMetadataHighlight: + { + retVal = TUint32(iMetaDataRec->iMetadata) & + ESnapMetadataHighlight; + } + break; + + case ESnapMetadataHiddenAgent: + { + retVal = TUint32(iMetaDataRec->iMetadata) & + ESnapMetadataHiddenAgent; + } + break; + + case ESnapMetadataDestinationIsLocalised: + { + retVal = (TUint32(iMetaDataRec->iMetadata) & + ESnapMetadataDestinationIsLocalised) >> 4; + } + break; + + case ESnapMetadataPurpose: + { + retVal = (TUint32(iMetaDataRec->iMetadata) & + ESnapMetadataPurpose) >> 8; + } + break; + + default: + { + User::Leave( KErrArgument ); + } + } + + return retVal; + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::MetadataL() +// ----------------------------------------------------------------------------- +// +TUint32 CCmDestinationImpl::MetadataL( TSnapMetadataField aMetaField ) const + { + LOGGER_ENTERFN( "CCmDestinationImpl::MetadataL" ) + return iData->MetadataL(aMetaField); + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::SetMetadataL() +// ----------------------------------------------------------------------------- +// +void CCmDestinationImpl::SetMetadataL( TSnapMetadataField aMetaField, + TUint32 aValue ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::SetMetadata" ); + + if( ProtectionLevel() == EProtLevel1 ) + { + CCmManagerImpl::HasCapabilityL( ECapabilityNetworkControl ); + } + + switch( aMetaField ) + { + case ESnapMetadataInternet: + { + if( aValue ) + { + CheckIfInternetExistsL(); + + iData->iMetaDataRec->iMetadata = + ESnapMetadataInternet | iData->iMetaDataRec->iMetadata; + + // Set the new way, too!!! + SetMetadataL( ESnapMetadataDestinationIsLocalised, + ELocalisedDestInternet ); + } + else + { + iData->iMetaDataRec->iMetadata = + ~ESnapMetadataInternet & iData->iMetaDataRec->iMetadata; + // Clear the new way, too!!! + SetMetadataL( ESnapMetadataDestinationIsLocalised, + ENotLocalisedDest ); + } + } + break; + + case ESnapMetadataDestinationIsLocalised: + { + // Check that aValue is within valid range. + if ( aValue > ELocalisedDestIntranet ) + { + User::Leave( KErrArgument ); + } + + TUint32 oldVal = TUint32(iData->iMetaDataRec->iMetadata) & + ESnapMetadataInternet; + if ( aValue != ENotLocalisedDest ) + { + // check if already exists... + CheckIfLocalisedDestExistL( aValue ); + // does not exists, first clear original value + // if old one was Internet, clear that, too: + if ( oldVal ) + { + // copied here to avoid recursivity!!! + // SetMetadataL(ESnapMetadataInternet, 0 ); + iData->iMetaDataRec->iMetadata = + ~ESnapMetadataInternet & iData->iMetaDataRec->iMetadata; + } + // clearing + iData->iMetaDataRec->iMetadata = + ~ESnapMetadataDestinationIsLocalised & + iData->iMetaDataRec->iMetadata; + // set new value + TUint32 mask = aValue << 4; + iData->iMetaDataRec->iMetadata = + mask | + iData->iMetaDataRec->iMetadata; + // for backward compatibility, if it is internet, + // set it the old way, too + if ( aValue == ELocalisedDestInternet ) + { + // copied here to avoid recursivity!!! + iData->iMetaDataRec->iMetadata = + ESnapMetadataInternet | iData->iMetaDataRec->iMetadata; + // SetMetadataL(ESnapMetadataInternet, 1 ); + } + } + else + { + // not localised, set to ENotLocalisedDest = 0 + // for backward compatibility, if it was internet, + // set it the old way, too + if ( oldVal ) + { + SetMetadataL(ESnapMetadataInternet, 0 ); + } + // clear the new way... + iData->iMetaDataRec->iMetadata = + ~ESnapMetadataDestinationIsLocalised & + iData->iMetaDataRec->iMetadata; + } + + break; + } + + case ESnapMetadataPurpose: + { + // Check that aValue is within valid range. + if ( aValue > ESnapPurposeIntranet ) + { + User::Leave( KErrArgument ); + } + + // Check if destination with the given purpose already + // exists + CheckIfPurposeExistL( aValue ); + + // ESnapPurposeInternet and ESnapPurposeMMS need special + // handling + switch( aValue ) + { + case ESnapPurposeUnknown: + { + // This also clears ESnapMetadataInternet + SetMetadataL( ESnapMetadataDestinationIsLocalised, ENotLocalisedDest ); + break; + } + case ESnapPurposeInternet: + { + // This sets ESnapMetadataInternet and + // ELocalisedDestInternet + SetMetadataL( ESnapMetadataInternet, 1 ); + } + break; + case ESnapPurposeOperator: + { + SetMetadataL( ESnapMetadataDestinationIsLocalised, + ELocalisedDestWap ); + } + break; + case ESnapPurposeMMS: + { + SetMetadataL( ESnapMetadataDestinationIsLocalised, + ELocalisedDestMMS ); + iData->iMetaDataRec->iMetadata = + ESnapMetadataHiddenAgent | iData->iMetaDataRec->iMetadata; + } + break; + case ESnapPurposeIntranet: + { + SetMetadataL( ESnapMetadataDestinationIsLocalised, + ELocalisedDestIntranet ); + } + break; + default: + break; + } + + TUint32 value = aValue << 8; + // reset the purpose bit + iData->iMetaDataRec->iMetadata = ~ESnapMetadataPurpose & iData->iMetaDataRec->iMetadata; + // set the purpose bit + iData->iMetaDataRec->iMetadata = value | iData->iMetaDataRec->iMetadata; + } + break; + + case ESnapMetadataHighlight: + { + if( aValue ) + { + iData->iMetaDataRec->iMetadata = + ESnapMetadataHighlight | iData->iMetaDataRec->iMetadata; + } + else + { + iData->iMetaDataRec->iMetadata = + ~ESnapMetadataHighlight & iData->iMetaDataRec->iMetadata; + } + } + break; + + case ESnapMetadataHiddenAgent: + { + TUint32 internet = iData->iMetaDataRec->iMetadata & ESnapMetadataInternet; + TUint32 internetLocal = ( iData->iMetaDataRec->iMetadata & ESnapMetadataDestinationIsLocalised ) >> 4; + TUint32 internetPurpose = ( iData->iMetaDataRec->iMetadata & ESnapMetadataPurpose ) >> 8; + if( aValue ) + { + if ( internet + || ( internetLocal == ELocalisedDestInternet ) + || ( internetPurpose == ESnapPurposeInternet ) ) + { + User::Leave( KErrArgument ); + } + + iData->iMetaDataRec->iMetadata = + ESnapMetadataHiddenAgent | iData->iMetaDataRec->iMetadata; + } + else + { + iData->iMetaDataRec->iMetadata = + ~ESnapMetadataHiddenAgent & iData->iMetaDataRec->iMetadata; + } + } + break; + + default: + { + User::Leave( KErrArgument ); + } + } + } +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::CreateEmbeddedDestinationPluginL() +// ----------------------------------------------------------------------------- +// +void CCmDestinationImpl::CreateEmbeddedDestinationPluginL( + CPluginItem& aItem, + TInt aDestinationId ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::CreateEmbeddedDestinationPluginL" ); + + aItem.iPlugin = iCmMgr.CreateConnectionMethodL(KUidEmbeddedDestination, this); + CleanupStack::PushL( aItem.iPlugin ); + // Load this destination + aItem.iPlugin->LoadL( aDestinationId ); + CleanupStack::Pop( aItem.iPlugin ); + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::LoadEmbeddedDestinationPluginL() +// ----------------------------------------------------------------------------- +// +void CCmDestinationImpl::LoadEmbeddedDestinationPluginL( + CPluginItem& aItem ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::LoadEmbeddedDestinationPluginL" ); + + CreateEmbeddedDestinationPluginL(aItem, aItem.iDNRecord->ElementId()); + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::LoadPluginL() +// ----------------------------------------------------------------------------- +// +void CCmDestinationImpl::LoadPluginL( CPluginItem& aItem ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::LoadPluginL" ); + + if( aItem.iPlugin ) + { + return; + } + + TUint32 cmId; + if ( aItem.iDNRecord->iEmbeddedSNAP ) + // This is an embedded destination + { + cmId = aItem.iDNRecord->iEmbeddedSNAP; + + } + else + // Normal IAP id + { + cmId = RECORD_FROM_ELEMENT_ID( aItem.iDNRecord->iIAP ); + } + + aItem.iPlugin = iCmMgr.DoFindConnMethodL( + cmId, + this ); + + CLOG_ATTACH( aItem.iPlugin, this ); + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::PluginClosed() +// ----------------------------------------------------------------------------- +// +void CCmDestinationImpl::PluginClosed( CCmPluginBase* aPlugin ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::PluginClosed" ); + + if (iData->iConnMethodArray) + { + for ( TInt i = 0; i < iData->iConnMethodArray->Count(); ++i ) + { + if ( (*(iData->iConnMethodArray))[i]->iPlugin == aPlugin ) + { + // Must NOT delete it here. Simply forget that + // we had this plugin instance. + (*(iData->iConnMethodArray))[i]->iPlugin = NULL; + + break; + } + } + } + } + +// ----------------------------------------------------------------------------- +// CCmDestinationData::IsHiddenL() +// ----------------------------------------------------------------------------- +// +TBool CCmDestinationData::IsHiddenL() + { + TSnapMetadataField hiddenValue = ( TSnapMetadataField )MetadataL( ESnapMetadataHiddenAgent ); + if ( hiddenValue == ESnapMetadataHiddenAgent ) + { + return ETrue; + } + else + { + return EFalse; + } + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::IsHiddenL() +// ----------------------------------------------------------------------------- +// +EXPORT_C TBool CCmDestinationImpl::IsHidden() + { + TBool hidden( EFalse ); + TRAPD( err, hidden = iData->IsHiddenL() ); + __ASSERT_ALWAYS( err == KErrNone, User::Panic(_L( "CMManager" ), err ) ); + + return hidden; + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::SetHiddenL() +// ----------------------------------------------------------------------------- +// +EXPORT_C void CCmDestinationImpl::SetHiddenL( TBool aHidden ) + { + if( ProtectionLevel() == EProtLevel1 ) + { + CCmManagerImpl::HasCapabilityL( ECapabilityNetworkControl ); + } + SetMetadataL( ESnapMetadataHiddenAgent, aHidden ); + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::DeleteConnectionMethodsL +// +// Can be called only during opened transaction. +// Array is emptied only after transaction commited! +// +// ----------------------------------------------------------------------------- +// +void CCmDestinationImpl::DeleteConnectionMethodsL() + { + LOGGER_ENTERFN( "DeleteConnectionMethodsL" ); + + TInt i; + + for ( i = 0; i < iData->iDeleteCmArray->Count(); ++i ) + { + CPluginItem* item = (*iData->iDeleteCmArray)[i]; + + LoadPluginL( *item ); + + if( !(item->iFlags & CPluginItem::ERemoveCm) ) + { + item->iPlugin->DeleteL( EFalse ); + } + + item->iDNRecord->DeleteL( Session() ); + } + } + +// ----------------------------------------------------------------------------- +// CCmDestinationData::ResetAndDestroyArray +// ----------------------------------------------------------------------------- +// +void CCmDestinationData::ResetAndDestroyArray( CCmArray* &aArray, TBool aDestroy ) + { + if( aArray ) + { + for ( TInt i = 0; i < aArray->Count(); ++i ) + { + CPluginItem* item = (*aArray)[i]; + + delete item->iPlugin; + delete item->iDNRecord; + } + + aArray->ResetAndDestroy(); + + if( aDestroy ) + { + delete aArray; aArray = NULL; + } + } + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::DeleteIAPRecordsL +// ----------------------------------------------------------------------------- +// +void CCmDestinationImpl::DeleteIAPRecordsL( CMDBRecordBase* aSnapRecord ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::DeleteIAPRecordsL" ); + + // First delete the metadata record + CCDIAPMetadataRecord* metaRec = new (ELeave) CCDIAPMetadataRecord( + iCmMgr.SeamlessnessTableId() ); + + CleanupStack::PushL( metaRec ); + + metaRec->iIAP = RECORD_FROM_ELEMENT_ID( + QUERY_INT_FIELD( + aSnapRecord, + KCDTIdDataMobilitySelectionPolicyIAP ) ); + + if( metaRec->FindL( Session() ) ) + { + metaRec->DeleteL( Session() ); + } + + CleanupStack::PopAndDestroy( metaRec ); + + // and now delete the SNAP record + aSnapRecord->DeleteL( Session() ); + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::CheckIfNameModifiedL +// ----------------------------------------------------------------------------- +void CCmDestinationImpl::CheckIfNameModifiedL( CCDSnapRecord* aRecord ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::CheckIfNameModifiedL" ); + + if ( !TPtrC(iData->iDestAPRecord->iRecordName).CompareF( TPtrC(aRecord->iRecordName) ) ) + // names matches + { + return; + } + + aRecord->iRecordName.SetL( TPtrC(iData->iDestAPRecord->iRecordName) ); + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::IsConnectedL +// ----------------------------------------------------------------------------- +EXPORT_C TBool CCmDestinationImpl::IsConnectedL() const + { + LOGGER_ENTERFN( "CCmDestinationImpl::IsConnectedL" ); + + CCmDestinationImpl* myThis = const_cast( this ); + TBool retVal( EFalse ); + TInt i; + + for( i = KCmInitIndex; i < iData->iConnMethodArray->Count(); ++i ) + { + CPluginItem* item = (*(iData->iConnMethodArray))[i]; + + myThis->LoadPluginL( *item ); + + if( item->iPlugin->GetBoolAttributeL( ECmConnected ) ) + { + retVal = ETrue; + break; + } + } + + return retVal; + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::CheckIfInternetExistsL +// +// There can be only one SNAP with Internet metadata field set. +// ----------------------------------------------------------------------------- +void CCmDestinationImpl::CheckIfInternetExistsL() + { + LOGGER_ENTERFN( "CCmDestinationImpl::CheckIfInternetExistsL" ); + + OpenTransactionLC(); + + CMDBRecordSet* metaSet = + new ( ELeave ) CMDBRecordSet( + iCmMgr.IconTableId() ); + CleanupStack::PushL( metaSet ); + + TRAP_IGNORE( metaSet->LoadL( Session() ) ); + + for ( TInt i = 0; i < metaSet->iRecords.Count(); ++i ) + { + TInt meta = QUERY_INT_FIELD( metaSet->iRecords[i], + KCDTIdSNAPMetadataMetadata ); + + if( meta & ESnapMetadataInternet ) + { + if( Id() != QUERY_INT_FIELD( metaSet->iRecords[i], + KCDTIdSNAPMetadataSNAP ) ) + { + User::Leave( KErrAlreadyExists ); + } + } + } + + CleanupStack::PopAndDestroy( metaSet ); + + RollbackTransaction(); + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::ConnectionMethodIndex +// ----------------------------------------------------------------------------- +TInt CCmDestinationImpl::ConnectionMethodIndex( TUint32 aCmId ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::ConnectionMethodIndex" ); + + TInt found( KErrNotFound ); + + for ( TInt i = KCmInitIndex; i < iData->iConnMethodArray->Count(); ++i ) + { + CPluginItem* item = (*(iData->iConnMethodArray))[i]; + if ( RECORD_FROM_ELEMENT_ID(item->iDNRecord->iIAP) == aCmId || + (item->iDNRecord->iEmbeddedSNAP == aCmId && aCmId != 0) ) + { + found = i; + break; + } + } + + return found; + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::IconIdL +// ----------------------------------------------------------------------------- +CGulIcon* CCmDestinationImpl::IconIdL( CCmManagerImpl& aCmMgr, + TMDBElementId aId ) + { + CGulIcon* retVal = NULL; + CCDSNAPMetadataRecord* metaDataRec = new (ELeave) CCDSNAPMetadataRecord( + aCmMgr.IconTableId() ); + CleanupStack::PushL( metaDataRec ); + metaDataRec->iSNAP = aId; + + if ( metaDataRec->FindL( aCmMgr.Session() ) ) + // Not found -> fill in with default values + { + retVal = IconL( metaDataRec->iIcon ); + } + else + { + User::Leave( KErrNotFound ); + } + + CleanupStack::PopAndDestroy( metaDataRec ); + + return retVal; + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::ProtectionLevelL +// ----------------------------------------------------------------------------- +TProtectionLevel CCmDestinationImpl::ProtectionLevelL( CCmManagerImpl& aCmMgr, + TMDBElementId aId ) + { + TProtectionLevel retVal( EProtLevel0 ); + CCDSNAPMetadataRecord* metaDataRec = new (ELeave) CCDSNAPMetadataRecord( + aCmMgr.IconTableId() ); + CleanupStack::PushL( metaDataRec ); + metaDataRec->iSNAP = aId; + + if ( metaDataRec->FindL( aCmMgr.Session() ) ) + // Not found -> fill in with default values + { + retVal = ProtectionLevel( metaDataRec ); + } + else + { + User::Leave( KErrNotFound ); + } + + CleanupStack::PopAndDestroy( metaDataRec ); + return retVal; + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::ProtectionLevel +// ----------------------------------------------------------------------------- +TProtectionLevel CCmDestinationImpl::ProtectionLevel( + CCDSNAPMetadataRecord* aMetaDataRec ) + { + TInt protection = TUint32(aMetaDataRec->iMetadata) & + KSnapMetadataProtecionLevelMask; + return TProtectionLevel(protection >> 28); + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::ProtectionLevelL +// ----------------------------------------------------------------------------- +CGulIcon* CCmDestinationImpl::IconL( TInt aIconIndex ) + { + MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance(); + + TParse mbmFile; + User::LeaveIfError( mbmFile.Set( KManagerIconFilename, + &KDC_BITMAP_DIR, + NULL ) ); + + TAknsItemID aknItemID; + aknItemID.Set( KDestinationIconConvTable[aIconIndex][0], + KDestinationIconConvTable[aIconIndex][1] ); + + CGulIcon* icon = AknsUtils::CreateGulIconL( + skinInstance, + aknItemID, + mbmFile.FullName(), + KDestinationIconConvTable[aIconIndex][2], + KDestinationIconConvTable[aIconIndex][3] ); + + return icon; + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::RemoveFromPool +// ----------------------------------------------------------------------------- +EXPORT_C void CCmDestinationImpl::RemoveFromPool() + { + iCmMgr.RemoveDestFromPool(this); + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::IncrementRefCounter +// ----------------------------------------------------------------------------- +void CCmDestinationImpl::IncrementRefCounter() + { + iData->IncrementRefCounter(); + } +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::DecrementRefCounter +// ----------------------------------------------------------------------------- +void CCmDestinationImpl::DecrementRefCounter() + { + iData->DecrementRefCounter(); + } +// ----------------------------------------------------------------------------- +// CCmDestinationData::IncrementRefCounter +// ----------------------------------------------------------------------------- +void CCmDestinationData::IncrementRefCounter() + { + iRefCounter++; + } +// ----------------------------------------------------------------------------- +// CCmDestinationData::DecrementRefCounter +// ----------------------------------------------------------------------------- +void CCmDestinationData::DecrementRefCounter() + { + iRefCounter--; + } + +// ----------------------------------------------------------------------------- +// CCmDestinationData::GetRefCounter +// ----------------------------------------------------------------------------- +TInt CCmDestinationData::GetRefCounter() + { + return iRefCounter; + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::GetRefCounter +// ----------------------------------------------------------------------------- +TInt CCmDestinationImpl::GetRefCounter() + { + return iData->iRefCounter; + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::GetData +// ----------------------------------------------------------------------------- +CCmDestinationData* CCmDestinationImpl::GetData() + { + return iData; + } +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::SetData +// ----------------------------------------------------------------------------- +void CCmDestinationImpl::SetData(CCmDestinationData* aData) + { + iData = aData; + } + +// ----------------------------------------------------------------------------- +// CCmDestinationData::IdIsValid +// ----------------------------------------------------------------------------- +TBool CCmDestinationData::IdIsValid() + { + return iIdIsValid; + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::IdIsValid +// ----------------------------------------------------------------------------- +TBool CCmDestinationImpl::IdIsValid() + { + return iData->iIdIsValid; + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::Cmmgr +// ----------------------------------------------------------------------------- +CCmManagerImpl* CCmDestinationData::Cmmgr() + { + return &iCmMgr; + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::Cmmgr +// ----------------------------------------------------------------------------- +CCmManagerImpl* CCmDestinationImpl::Cmmgr() + { + return &iCmMgr; + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::CheckIfLocalisedDestExistL +// +// There can be only one SNAP with a certain localised metadata field set. +// ----------------------------------------------------------------------------- +void CCmDestinationImpl::CheckIfLocalisedDestExistL( TUint32 aValue ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::CheckIfLocalisedDestExistL" ); + + OpenTransactionLC(); + + CMDBRecordSet* metaSet = + new ( ELeave ) CMDBRecordSet( iCmMgr.IconTableId() ); + CleanupStack::PushL( metaSet ); + + TRAP_IGNORE( metaSet->LoadL( Session() ) ); + + for ( TInt i = 0; i < metaSet->iRecords.Count(); ++i ) + { + TInt meta = QUERY_INT_FIELD( metaSet->iRecords[i], + KCDTIdSNAPMetadataMetadata ); + + if ( meta & ESnapMetadataDestinationIsLocalised ) + { + TInt locval = (meta & ESnapMetadataDestinationIsLocalised) >> 4; + if ( aValue == locval ) + { + if( Id() != QUERY_INT_FIELD( metaSet->iRecords[i], KCDTIdSNAPMetadataSNAP ) ) + { + User::Leave( KErrAlreadyExists ); + } + } + if ( aValue == ELocalisedDestInternet ) + { // internet might also be set the 'old way', check it! + if( meta & ESnapMetadataInternet ) + { + if( Id() != QUERY_INT_FIELD( metaSet->iRecords[i], KCDTIdSNAPMetadataSNAP ) ) + { + User::Leave( KErrAlreadyExists ); + } + } + } + } + } + + CleanupStack::PopAndDestroy( metaSet ); + + RollbackTransaction(); + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::CheckIfPurposeExistL +// +// There can be only one SNAP with a certain purpose metadata field set. +// ----------------------------------------------------------------------------- +void CCmDestinationImpl::CheckIfPurposeExistL( TUint32 aValue ) + { + LOGGER_ENTERFN( "CCmDestinationImpl::CheckIfPurposeExistL" ); + + OpenTransactionLC(); + + CMDBRecordSet* metaSet = + new ( ELeave ) CMDBRecordSet( iCmMgr.IconTableId() ); + CleanupStack::PushL( metaSet ); + + TRAP_IGNORE( metaSet->LoadL( Session() ) ); + + for ( TInt i = 0; i < metaSet->iRecords.Count(); ++i ) + { + TInt meta = QUERY_INT_FIELD( metaSet->iRecords[i], + KCDTIdSNAPMetadataMetadata ); + + if ( meta & ESnapMetadataPurpose ) + { + TInt purVal = ( meta & ESnapMetadataPurpose ) >> 8; + if ( aValue == purVal ) + { + if( Id() != QUERY_INT_FIELD( metaSet->iRecords[i], + KCDTIdSNAPMetadataSNAP ) ) + { + User::Leave( KErrAlreadyExists ); + } + } + } + } + + CleanupStack::PopAndDestroy( metaSet ); + + RollbackTransaction(); + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::InitializeDestAPRecordL +// +// +// ----------------------------------------------------------------------------- +void CCmDestinationImpl::InitializeDestAPRecordL() + { + LOGGER_ENTERFN( "CCmDestinationImpl::InitializeDestAPRecordL" ); + + SetDefaultTierManagerL(); + SetDefaultMCprL(); + SetDefaultCprL(); + SetDefaultSCprL(); + SetDefaultProtocolL(); + iData->iDestAPRecord->iCustomSelectionPolicy = 0; + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::SetDefaultTierManagerL +// +// +// ----------------------------------------------------------------------------- +void CCmDestinationImpl::SetDefaultTierManagerL() + { + LOGGER_ENTERFN( "CCmDestinationImpl::SetDefaultTierManagerL" ); + + CCDTierRecord* tierRec = static_cast + ( CCDRecordBase::RecordFactoryL( KCDTIdTierRecord ) ); + CleanupStack::PushL( tierRec ); + + tierRec->iRecordTag = KDefaultTierManagerTagId; + + if ( tierRec->FindL( Session() ) ) + { + iData->iDestAPRecord->iTier = tierRec->ElementId(); + } + else + { + User::Leave( KErrNotFound ); + } + + CleanupStack::PopAndDestroy(); + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::SetDefaultMCprL +// +// +// ----------------------------------------------------------------------------- +void CCmDestinationImpl::SetDefaultMCprL() + { + LOGGER_ENTERFN( "CCmDestinationImpl::SetDefaultMCprL" ); + + CCDMCprRecord* mcprRec = static_cast + ( CCDRecordBase::RecordFactoryL( KCDTIdMCprRecord ) ); + CleanupStack::PushL( mcprRec ); + + mcprRec->SetRecordId( 1 ); + + mcprRec->LoadL( Session() ); + + iData->iDestAPRecord->iMCpr = mcprRec->ElementId(); + + CleanupStack::PopAndDestroy(); + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::SetDefaultCprL +// +// +// ----------------------------------------------------------------------------- +void CCmDestinationImpl::SetDefaultCprL() + { + LOGGER_ENTERFN( "CCmDestinationImpl::SetDefaultCprL" ); + + CCDCprRecord* cprRec = static_cast + ( CCDRecordBase::RecordFactoryL( KCDTIdCprRecord ) ); + CleanupStack::PushL( cprRec ); + + cprRec->SetRecordId( 1 ); + + cprRec->LoadL( Session() ); + iData->iDestAPRecord->iCpr = cprRec->ElementId(); + + CleanupStack::PopAndDestroy(); + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::SetDefaultSCprL +// +// +// ----------------------------------------------------------------------------- +void CCmDestinationImpl::SetDefaultSCprL() + { + LOGGER_ENTERFN( "CCmDestinationImpl::SetDefaultSCprL" ); + + CCDSCprRecord* scprRec = static_cast + ( CCDRecordBase::RecordFactoryL( KCDTIdSCprRecord ) ); + CleanupStack::PushL( scprRec ); + + scprRec->SetRecordId( 1 ); + + scprRec->LoadL( Session() ); + iData->iDestAPRecord->iSCpr = scprRec->ElementId(); + + CleanupStack::PopAndDestroy(); + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::SetDefaultProtocolL +// +// +// ----------------------------------------------------------------------------- +void CCmDestinationImpl::SetDefaultProtocolL() + { + LOGGER_ENTERFN( "CCmDestinationImpl::SetDefaultProtocolL" ); + + CCDProtocolRecord* protocolRec = static_cast + ( CCDRecordBase::RecordFactoryL( KCDTIdProtocolRecord ) ); + CleanupStack::PushL( protocolRec ); + + protocolRec->SetRecordId( 1 ); + + protocolRec->LoadL( Session() ); + iData->iDestAPRecord->iProtocol = protocolRec->ElementId(); + + CleanupStack::PopAndDestroy(); + } + +// ----------------------------------------------------------------------------- +// CCmDestinationImpl::CheckIfCMExists +// +// +// ----------------------------------------------------------------------------- +TBool CCmDestinationImpl::CheckIfCMExistsL( CCmPluginBase& aConnectionMethod ) + { + TRAPD( err, (void)FindConnectionMethodL( aConnectionMethod ) ); + if ( err ) + { + if ( err == KErrNotFound ) + { + return EFalse; + } + else + { + User::Leave( err ); + } + } + + return ETrue; + }