diff -r fc7b30ed2058 -r 05bc53fe583b cmmanager/cmmgr/Framework/Src/cmmanagerimpl.cpp --- a/cmmanager/cmmgr/Framework/Src/cmmanagerimpl.cpp Thu Aug 19 10:18:49 2010 +0300 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,3058 +0,0 @@ -/* -* Copyright (c) 2006-2010 Nokia Corporation and/or its subsidiary(-ies). -* All rights reserved. -* This component and the accompanying materials are made available -* under the terms of "Eclipse Public License v1.0" -* which accompanies this distribution, and is available -* at the URL "http://www.eclipse.org/legal/epl-v10.html". -* -* Initial Contributors: -* Nokia Corporation - initial contribution. -* -* Contributors: -* -* Description: Implementation of CCmManagerImpl. -* -*/ - -#include "cmmanagerimpl.h" -#include -#include -#include -#include -#include "cmdestinationimpl.h" -#include "cmtransactionhandler.h" -#include "cmlogger.h" -#include "cmmanager.hrh" -#include -#include -#include -#include "cmobjectpool.h" -#include "cmcommsdatnotifier.h" - -#include -#include -#include // CCDWlanServiceRecord -#include -#include -#include -#include // BaflUtils -#include // resource -#include -#include // For REComSession -#include - -#include // icons -#include - -#include -#include - -using namespace CMManager; -using namespace CommsDat; - -// CONSTANTS - -const TInt KResFileGranularity = 5; -const TInt KPluginGranularity = 3; -// if a CmId is grater than KMaxIapId, than it has no iap record -// Otherwise cmId is the same as the IapId -const TUint32 KMaxIapID = 255; -// Safety margin when checking disk space -const TUint32 KBytesToWrite = 8000; - -const TUint32 KEndOfArray = KMaxTUint; -/** -* This array lists all the bearerspecific attributes. -* The bearerspecific attributes can be queried via both -* the manager interface's and connection method interface's ::Get functions. -*/ -static const TUint32 KBearerSpecificAttributes[]= - { - /** - */ - ECmCoverage, - ECmDefaultPriority, - ECmDestination, - ECmBearerHasUi, - ECmIPv6Supported, - ECmDefaultUiPriority, - ECmBearerIcon, - ECmBearerAvailableIcon, - ECmBearerAvailableName, - ECmBearerSupportedName, - ECmBearerAvailableText, - ECmBearerNamePopupNote, - ECmCommsDBBearerType, - ECmBearerSettingName, - ECmVirtual, - ECmExtensionLevel, - ECmAddToAvailableList, - KEndOfArray - }; - -// ----------------------------------------------------------------------------- -// Test functions -// ----------------------------------------------------------------------------- -// -/*#ifdef _DEBUG -void DumIapTableL( CMDBSession& aSession ) - { - CMDBRecordSet* ptrRecordSet = - new (ELeave) CMDBRecordSet( KCDTIdIAPRecord ); - CleanupStack::PushL( ptrRecordSet ); - - TRAP_IGNORE( ptrRecordSet->LoadL( aSession ) ); - - TInt iapRecords = ptrRecordSet->iRecords.Count(); - CLOG_WRITE_1_PTR( NULL, "Dumping IAP Table\nNo. of IAPs: [%d]", iapRecords ); - for ( TInt i = 0; i < iapRecords; i++ ) - { - CCDIAPRecord* iapRecord = (*ptrRecordSet)[i]; - - CLOG_WRITE_4_PTR( NULL, "Rec id:[%d] - Name: [%S] - Service Type: [%S] - Bearer Type: [%S]", - iapRecord->RecordId(), - &FIELD_TO_TDESC( iapRecord->iRecordName ), - &FIELD_TO_TDESC( iapRecord->iServiceType ), - &FIELD_TO_TDESC( iapRecord->iBearerType ) - ); - } - - CleanupStack::PopAndDestroy( ptrRecordSet ); - } -#endif */ // _DEBUG - -//============================================================================= -// CONSTRUCTION / DESTRUCTION API -//============================================================================= -// - -//----------------------------------------------------------------------------- -// CCmManagerImpl::NewL() -//----------------------------------------------------------------------------- -// -CCmManagerImpl* CCmManagerImpl::NewL( TBool aCreateTables ) - { - CCmManagerImpl* self = new (ELeave) CCmManagerImpl(); - CleanupStack::PushL( self ); - self->iCreateTables = aCreateTables; - self->ConstructL(); - CleanupStack::Pop( self ); // self - - return self; - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::CCmManagerImpl() -//----------------------------------------------------------------------------- -// -CCmManagerImpl::CCmManagerImpl() -:iDefConnSupported(EFalse),iCreateTables(ETrue) - { - CLOG_CREATE; - - Dll::SetTls( this ); - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::~CCmManagerImpl() -//----------------------------------------------------------------------------- -// -CCmManagerImpl::~CCmManagerImpl() - { - CLOG_WRITE( "CCmManagerImpl::~CCmManagerImpl" ); - - if ( iBearerPriorityArray ) - { - CleanupGlobalPriorityArray( *iBearerPriorityArray ); - delete iBearerPriorityArray; - } - - if ( iPlugins ) - { - iPlugins->ResetAndDestroy(); - delete iPlugins; - } - - - if ( iResourceFiles ) - { - TInt resCount = iResourceFiles->Count(); - for ( TInt i = 0; i < resCount; ++i ) - { - // close the resource file - (*iResourceFiles)[0]->iFile.Close(); - // delete the structure - delete (*iResourceFiles)[0]; - // delete array item - iResourceFiles->Delete( 0 ); - } - - iResourceFiles->Reset(); - delete iResourceFiles; - } - - iFs.Close(); - - delete iPluginImpl; - - if (iTrans) - { - delete &Session(); - delete iTrans; - } - - if( iIsFeatureManagerInitialised ) - { - FeatureManager::UnInitializeLib(); - } - - REComSession::FinalClose(); - - delete iObjectPool; - - delete iCommsDatIapNotifier; - delete iCommsDatSnapNotifier; - - CLOG_CLOSE; - } - - -// ----------------------------------------------------------------------------- -// CCmManagerImpl::CheckTablesL() -// ----------------------------------------------------------------------------- -// -void CCmManagerImpl::CheckTablesL() - { - LOGGER_ENTERFN( "CCmManagerImpl::CheckDestinationNetworkTableL" ); - - TInt err( 0 ); - - CLOG_WRITE( "Destination network" ); - if (iCreateTables) - { - TRAP( err, iDestinationTableId = - CCDDataMobilitySelectionPolicyRecord::TableIdL( Session() )); - CLOG_WRITE_1( "err: [%d]", err ); - if( err == KErrNotFound ) - { - iDestinationTableId = - CCDDataMobilitySelectionPolicyRecord::CreateTableL( Session() ); - } - else - { - User::LeaveIfError( err ); - } - } - else - { - iDestinationTableId = - CCDDataMobilitySelectionPolicyRecord::TableIdL( Session() ); - } - - CLOG_WRITE( "Global Bearer Type Priorization Table" ); - TRAP( err, iBearerTypePriorizationTableId = - CCDGlobalBearerTypePriorizationRecord::TableIdL( Session() ) ); - CLOG_WRITE_1( "err: [%d]", err ); - if( err == KErrNotFound ) - { - iBearerTypePriorizationTableId = - CCDGlobalBearerTypePriorizationRecord::CreateTableL( Session() ); - } - else - { - User::LeaveIfError( err ); - } - - CLOG_WRITE( "Destination network - Icon table" ); - TRAP( err, iIconTableId = CCDSNAPMetadataRecord::TableIdL( Session() ) ); - if( err == KErrNotFound ) - { - iIconTableId = CCDSNAPMetadataRecord::CreateTableL( Session() ); - } - else - { - User::LeaveIfError( err ); - } - - CLOG_WRITE( "Seamlessness table" ); - TRAP( err, iSeamlessnessTableId = CCDIAPMetadataRecord::TableIdL( Session() ) ); - CLOG_WRITE_1( "err: [%d]", err ); - if( err == KErrNotFound ) - { - iSeamlessnessTableId = CCDIAPMetadataRecord::CreateTableL( Session() ); - } - else - { - User::LeaveIfError( err ); - } - if ( IsDefConnSupported() ) - { - CLOG_WRITE( "Default connection table" ); - TRAP( err, iDefConnTableId = CCDDefConnRecord::TableIdL( Session() ) ); - CLOG_WRITE_1( "err: [%d]", err ); - if( err == KErrNotFound ) - { - iDefConnTableId = CCDDefConnRecord::CreateTableL( Session() ); - } - else - { - User::LeaveIfError( err ); - } - } - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::CreateBearerPriorityArrayL() -//----------------------------------------------------------------------------- -// -void CCmManagerImpl::CreateBearerPriorityArrayL() - { - LOGGER_ENTERFN( "CCmManagerImpl:CreateBearerPriorityArray" ); - - iBearerPriorityArray = - new ( ELeave ) RArray( KCmArrayBigGranularity ); - - CMDBRecordSet* bpRS = - new (ELeave) CMDBRecordSet( - iBearerTypePriorizationTableId ); - CleanupStack::PushL( bpRS ); - - OpenTransactionLC(); - TRAP_IGNORE( bpRS->LoadL( Session() ) ); - RollbackTransaction(); - - TInt bpCount = bpRS->iRecords.Count(); - TInt i( 0 ); - - while ( i < bpCount ) // loop the Bearer Priority table - { - // Bearer Priority record ID - HBufC* bpServiceType = QUERY_HBUFC_FIELD( (*bpRS)[i], - KCDTIdGlobalServiceType ); - - TInt bpPriority = ( QUERY_INT_FIELD( (*bpRS)[i], - KCDTIdGlobalServicePriority ) ); - TInt uiPriority = ( QUERY_INT_FIELD( (*bpRS)[i], - KCDTIdGlobalServiceUIPriority ) ); - CLOG_WRITE( "Bearer Priority Table Values" ); - CLOG_WRITE_1( "Service Type: [%S]", bpServiceType ); - CLOG_WRITE_1( "Bearer Priority: [%d]", bpPriority ); - CLOG_WRITE_1( "UI Priority: [%d]", uiPriority ); - TBearerPriority bp; - bp.iServiceType = bpServiceType->AllocL(); - bp.iPriority = bpPriority; - bp.iUIPriority = uiPriority; - iBearerPriorityArray->AppendL( bp ); - i++; - } - - CleanupStack::PopAndDestroy( bpRS ); - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::BearerPriorityArrayL() -//----------------------------------------------------------------------------- -// -void CCmManagerImpl::BearerPriorityArrayL( RArray& aArray ) const - { - LOGGER_ENTERFN( "CCmManagerImpl:BearerPriorityArray" ); - TRAPD( err, CopyBearerPriorityArrayL( aArray ) ); - if( err ) - // in case of any problem we clean up this array - { - User::Leave( err ); - } - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::CopyBearerPriorityArrayL() -//----------------------------------------------------------------------------- -// -void CCmManagerImpl::CopyBearerPriorityArrayL( - RArray& aArray ) const - { - LOGGER_ENTERFN( "CCmManagerImpl:BearerPriorityArray" ); - for ( TInt i = 0; i < iBearerPriorityArray->Count(); i++ ) - { - TBearerPriority item; - - TBearerPriority* orgItem = &(*iBearerPriorityArray)[i]; - - item.iServiceType = HBufC::NewLC( orgItem->iServiceType->Length() ); - item.iServiceType->Des().Copy( *orgItem->iServiceType ); - item.iPriority = orgItem->iPriority; - item.iUIPriority = orgItem->iUIPriority; - - User::LeaveIfError( aArray.Append( item ) ); - - CleanupStack::Pop(); // item->iServiceType - } - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::UpdateBearerPriorityArrayL() -//----------------------------------------------------------------------------- -// -void CCmManagerImpl::UpdateBearerPriorityArrayL( - const RArray& aArray ) - { - LOGGER_ENTERFN( "CCmManagerImpl::UpdateBearerPriorityArray" ); - - OpenTransactionLC(); - - CMDBRecordSet* bpRS = new (ELeave) - CMDBRecordSet( iBearerTypePriorizationTableId ); - CleanupStack::PushL( bpRS ); // 1 - TRAP_IGNORE( bpRS->LoadL( Session() ) ); - - // Delete the old record - for ( TInt i = 0; i < bpRS->iRecords.Count(); ++i ) - { - bpRS->iRecords[i]->DeleteL( Session() ); - } - - CleanupGlobalPriorityArray( *iBearerPriorityArray ); - - CleanupStack::PopAndDestroy( bpRS ); - bpRS = NULL; - - // Add the new content - CCmBearerPriRec* bpRcd = - new (ELeave) CCmBearerPriRec( iBearerTypePriorizationTableId ); - CleanupStack::PushL( bpRcd ); // 2 - - CLOG_WRITE( "Store bearer info to table" ); - for ( TInt i = 0; i < aArray.Count(); ++i ) - { - bpRcd->SetRecordId( KCDNewRecordRequest ); - - HBufC* serviceTypeVal = aArray[i].iServiceType; - TInt priorityVal = aArray[i].iPriority; - TInt uiPriorityVal = aArray[i].iUIPriority; - - CLOG_WRITE_FORMAT( "Set service type: [%S ]", serviceTypeVal ); - SET_HBUFC_FIELD( bpRcd, - KCDTIdGlobalServiceType, - serviceTypeVal ); - CLOG_WRITE_1( "Set priority: [%d]", priorityVal ); - SET_INT_FIELD( bpRcd, - KCDTIdGlobalServicePriority, - priorityVal ); - CLOG_WRITE_1( "Set uipriority: [%d]", uiPriorityVal ); - SET_INT_FIELD( bpRcd, - KCDTIdGlobalServiceUIPriority, - uiPriorityVal ); - bpRcd->StoreL( Session() ); - - TBearerPriority item; - - item.iServiceType = serviceTypeVal->AllocLC(); - item.iPriority = priorityVal; - item.iUIPriority = uiPriorityVal; - iBearerPriorityArray->AppendL( item ); - CleanupStack::Pop( item.iServiceType ); - } - - CleanupStack::PopAndDestroy( bpRcd ); - - CommitTransactionL( KErrNone ); - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::GlobalBearerPriority() -//----------------------------------------------------------------------------- -// -TInt CCmManagerImpl::GlobalBearerPriority( TBool aUiPriority, - const TDesC& aServiceType ) const - { - for ( TInt i = 0; i < iBearerPriorityArray->Count(); ++i ) - { - if ( !aServiceType.CompareF( *(*iBearerPriorityArray)[i].iServiceType ) ) - { - if( aUiPriority ) - { - return (*iBearerPriorityArray)[i].iUIPriority; - } - else - { - return (*iBearerPriorityArray)[i].iPriority; - } - } - } - - return KDataMobilitySelectionPolicyPriorityWildCard; - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::CleanupGlobalPriorityArray() -//----------------------------------------------------------------------------- -// -void CCmManagerImpl::CleanupGlobalPriorityArray( - RArray& aArray ) const - { - LOGGER_ENTERFN( "CCmManagerImpl::CleanupGlobalPriorityArray" ); - - for ( TInt i = 0; i < aArray.Count(); ++i ) - { - delete aArray[i].iServiceType; - } - - aArray.Reset(); - aArray.Close(); - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::AddResourceFileL() -//----------------------------------------------------------------------------- -// -void CCmManagerImpl::AddResourceFileL( TFileName& aName ) - { - LOGGER_ENTERFN( "CCmManagerImpl::AddResourceFileL" ); - - TInt index = FindResourceFile( aName ); - - if ( index != KErrNotFound ) - { - ++(*iResourceFiles)[index]->iRefs; - return; - } - - TResourceFiles* newRes = new (ELeave) TResourceFiles; - CleanupStack::PushL( newRes ); - - RResourceFile resFile; - resFile.OpenL( iFs, aName ); - CleanupClosePushL( resFile ); - - resFile.ConfirmSignatureL(0); - - newRes->iFile = resFile; - newRes->iFName.Copy( aName ); - newRes->iRefs = 1; // 1 reference to this resource file - - iResourceFiles->AppendL( newRes ); - - CleanupStack::Pop( 2 ); // resFile, newRes - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::RemoveResourceFile() -//----------------------------------------------------------------------------- -// -void CCmManagerImpl::RemoveResourceFile( TFileName& aName ) - { - LOGGER_ENTERFN( "CCmManagerImpl::RemoveResourceFile" ); - - TInt index = FindResourceFile( aName ); - - if ( index == KErrNotFound ) - { - return; - } - - if ( !--(*iResourceFiles)[index]->iRefs ) - // it was the last reference - { - (*iResourceFiles)[index]->iFile.Close(); - delete (*iResourceFiles)[index]; - - iResourceFiles->Delete( index ); - } - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::FindResourceFile() -//----------------------------------------------------------------------------- -// -TInt CCmManagerImpl::FindResourceFile( TFileName& aName ) const - { - LOGGER_ENTERFN( "CCmManagerImpl::FindResourceFile" ); - - BaflUtils::NearestLanguageFile( iFs, aName ); - - for ( TInt i = 0; i < iResourceFiles->Count(); ++i ) - { - if ( !(*iResourceFiles)[i]->iFName.CompareF( aName ) ) - { - return i; - } - } - - return KErrNotFound; - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::AllocReadL() -//----------------------------------------------------------------------------- -// -HBufC* CCmManagerImpl::AllocReadL( TInt aResourceId ) const - { - LOGGER_ENTERFN( "CCmManagerImpl::AllocReadL" ); - - HBufC* retVal = NULL; - - // Scan all resource files to find owner - for (TInt i=0; i < iResourceFiles->Count(); i++) - { - RResourceFile& file=(*iResourceFiles)[i]->iFile; - if ( file.OwnsResourceId(aResourceId) ) - { - HBufC8* readBuffer = file.AllocReadLC( aResourceId ); - // as we are expecting HBufC16... - const TPtrC16 ptrReadBuffer( (TText16*) readBuffer->Ptr(), - readBuffer->Length() >> 1 ); - retVal=HBufC16::NewL( ptrReadBuffer.Length() ); - retVal->Des().Copy( ptrReadBuffer ); - CleanupStack::PopAndDestroy( readBuffer ); // readBuffer - - // exit from loop - break; - } - } - - return retVal; - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::ConstructL() -//----------------------------------------------------------------------------- -// -void CCmManagerImpl::ConstructL() - { - LOGGER_ENTERFN( "CCmManagerImpl::ConstructL" ); - CLOG_NAME_1( _L("ManagerImpl_0x%x"), this ); - - iObjectPool = new (ELeave) CCMObjectPool(*this); - - FeatureManager::InitializeLibL(); - iIsFeatureManagerInitialised = ETrue; - iHelp = FeatureManager::FeatureSupported( KFeatureIdHelp ); - iDefConnSupported = ETrue; - //iDefConnSupported = FeatureManager::FeatureSupported( KFeatureIdDefaultConnection ); - iWLan = FeatureManager::FeatureSupported( KFeatureIdProtocolWlan ); - - CMDBSession* db = CMDBSession::NewL( KCDVersion1_2 ); - - iTrans = CCmTransactionHandler::NewL( *db ); - CLOG_ATTACH( iTrans, this ); - - User::LeaveIfError( iFs.Connect() ); - - iResourceFiles = new (ELeave) CArrayPtrFlat( - KResFileGranularity ); - - TParse fp; - TInt err = fp.Set( KACMManagerResDirAndFileName, - &KDC_RESOURCE_FILES_DIR, - NULL ); - CLOG_WRITE_1( "Set: [%d]", err ); - if ( err != KErrNone) - { - User::Leave( err ); - } - - TFileName fName; - - fName.Copy( fp.FullName() ); - - AddResourceFileL( fName ); - - CheckTablesL(); - CreateBearerPriorityArrayL(); - - BuildPluginArrayL(); - - TCmPluginInitParam params( *this ); - - params.iParentDest = NULL; - iPluginImpl = CCmConnectionMethodInfo::NewL( ¶ms ); - CLOG_ATTACH( iPluginImpl, this ); - } - -// --------------------------------------------------------------------------- -// CCmManagerImpl::OpenTransactionLC -// --------------------------------------------------------------------------- -// -void CCmManagerImpl::OpenTransactionLC( TBool aSetAttribs ) - { - LOGGER_ENTERFN( "CCmManagerImpl::OpenTransactionL" ); - - iTrans->OpenTransactionLC( aSetAttribs ); - } - -// --------------------------------------------------------------------------- -// CCmDestinationImpl::CommitTransactionL -// --------------------------------------------------------------------------- -// -void CCmManagerImpl::CommitTransactionL( TInt aError ) - { - LOGGER_ENTERFN( "CCmManagerImpl::CommitTransactionL" ); - - iTrans->CommitTransactionL( aError ); - } - -// --------------------------------------------------------------------------- -// CCmDestinationImpl::CommitTransactionL -// --------------------------------------------------------------------------- -// -void CCmManagerImpl::RollbackTransaction() - { - LOGGER_ENTERFN( "CCmManagerImpl::RollbackTransaction" ); - CleanupStack::Pop( iTrans ); - iTrans->Close(); - } - -// --------------------------------------------------------------------------- -// CCmDestinationImpl::StartCommsDatNotifier -// --------------------------------------------------------------------------- -// -void CCmManagerImpl::StartCommsDatNotifierL() - { - // Two instances of class CCmCommsDatNotifier are created here and - // referred by all watchers in CmManager. One is to watch change in Iap Table - // and the other is to watch change in Snap Table. - - if ( iCommsDatIapNotifier == NULL ) - { - iCommsDatIapNotifier = CCmCommsDatNotifier::NewL( KCDTIdIAPRecord ); - } - - if ( iCommsDatSnapNotifier == NULL ) - { - TUint32 snapTableId = GetSnapTableIdL(); - iCommsDatSnapNotifier = CCmCommsDatNotifier::NewL( snapTableId ); - } - } - -//============================================================================= -// CREATION / DELETION API -//============================================================================= -// - -//----------------------------------------------------------------------------- -// CCmManagerImpl::CreateDestinationL( const TDesC& aName ) -//----------------------------------------------------------------------------- -// -CCmDestinationImpl* CCmManagerImpl::CreateDestinationL( const TDesC& aName ) - { - LOGGER_ENTERFN( "CCmManagerImpl::CreateDestinationL" ); - - CheckAvailableSpaceL(); - - if ( aName.Length() == 0 ) - { - User::Leave( KErrArgument ); - } - - return iObjectPool->GetDestinationL( aName ); - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::CreateDestinationL( const TDesC& aName, TUint32 -// aDestId ) -//----------------------------------------------------------------------------- -// -CCmDestinationImpl* CCmManagerImpl::CreateDestinationL( - const TDesC& aName, - TUint32 aDestId ) - { - LOGGER_ENTERFN( "CCmManagerImpl::CreateDestinationL" ); - - CheckAvailableSpaceL(); - - if ( aName.Length() == 0 ) - { - User::Leave( KErrArgument ); - } - - if ( aDestId == 0 ) - { - return CreateDestinationL( aName ); - } - - return iObjectPool->CreateDestinationL( aName, aDestId ); - } - - -//----------------------------------------------------------------------------- -// CCmManagerImpl::DestinationUpdated( CCmDestinationImpl* aDestination ) -//----------------------------------------------------------------------------- -// -void CCmManagerImpl::DestinationUpdated( CCmDestinationImpl* aDestination ) - { - LOGGER_ENTERFN( "CCmManagerImpl::DestinationUpdatedL" ); - iObjectPool->DestinationUpdated( aDestination ); - } - -// -------------------------------------------------------------------------- -// CCmManagerImpl::CreateConnectionMethodL() -// -------------------------------------------------------------------------- -// -CCmPluginBase* - CCmManagerImpl::CreateConnectionMethodL( CCmPluginBaseEng* pluginBaseEng ) - { - LOGGER_ENTERFN( "CCmManagerImpl::CreateConnectionMethodL 2" ); - - CheckAvailableSpaceL(); - - return iObjectPool->CreateConnectionMethodL( pluginBaseEng ); - } - -// -------------------------------------------------------------------------- -// CCmManagerImpl::InsertConnectionMethodL() -// -------------------------------------------------------------------------- -// -void CCmManagerImpl::InsertConnectionMethodL( CCmPluginBaseEng* pluginBaseEng ) - { - iObjectPool->InsertConnectionMethodL( pluginBaseEng ); - } - -// -------------------------------------------------------------------------- -// CCmManagerImpl::CreateConnectionMethodL() -// -------------------------------------------------------------------------- -// -CCmPluginBase* - CCmManagerImpl::CreateConnectionMethodL( TUint32 aImplementationUid, - CCmDestinationImpl* aParentDestination ) - { - LOGGER_ENTERFN( "CCmManagerImpl::CreateConnectionMethodL" ); - - CheckAvailableSpaceL(); - - TCmPluginInitParam params( *this ); - if (aParentDestination) - { - params.iParentDest = aParentDestination->Id(); - } - - return iObjectPool->CreateConnectionMethodL( aImplementationUid, params ); - } - -// -------------------------------------------------------------------------- -// CCmManagerImpl::CreateConnectionMethodL() -// -------------------------------------------------------------------------- -// -CCmPluginBase* - CCmManagerImpl::CreateConnectionMethodL( TUint32 aImplementationUid, - TUint32 aConnMethodId, - CCmDestinationImpl* aParentDestination ) - { - LOGGER_ENTERFN( "CCmManagerImpl::CreateConnectionMethodL" ); - - CheckAvailableSpaceL(); - - TCmPluginInitParam params( *this ); - if ( aParentDestination ) - { - params.iParentDest = aParentDestination->Id(); - } - - return iObjectPool->CreateConnectionMethodL( aImplementationUid, - params, - aConnMethodId); - } - -// -------------------------------------------------------------------------- -// CCmManagerImpl::DoCreateConnectionMethodL() -// -------------------------------------------------------------------------- -// -CCmPluginBaseEng* - CCmManagerImpl::DoCreateConnectionMethodL( TUint32 aImplementationUid, - TCmPluginInitParam& aParams ) - { - LOGGER_ENTERFN( "CCmManagerImpl::DoCreateConnectionMethodL" ); - - const TUid KMCMmImplementationUid = { aImplementationUid }; - TAny* ptr = REComSession::CreateImplementationL( KMCMmImplementationUid, - _FOFF( CCmPluginBaseEng, - iDtor_ID_Key ), - (TAny*)&aParams ); - - CCmPluginBaseEng* plugin = STATIC_CAST( CCmPluginBaseEng*, ptr ); - CleanupStack::PushL( plugin ); - - plugin->CreateNewL(); - plugin->SetIdValidity(EFalse); - CleanupStack::Pop( plugin ); // plugin - - return plugin; - } - -// -------------------------------------------------------------------------- -// CCmManagerImpl::DoCreateConnectionMethodL() -// -------------------------------------------------------------------------- -// -CCmPluginBaseEng* - CCmManagerImpl::DoCreateConnectionMethodL( TUint32 aImplementationUid, - TCmPluginInitParam& aParams, - TUint32 aConnMethodId ) - { - LOGGER_ENTERFN( "CCmManagerImpl::DoCreateConnectionMethodL" ); - - const TUid KMCMmImplementationUid = { aImplementationUid }; - TAny* ptr = REComSession::CreateImplementationL( KMCMmImplementationUid, - _FOFF( CCmPluginBaseEng, - iDtor_ID_Key ), - (TAny*)&aParams ); - - CCmPluginBaseEng* plugin = STATIC_CAST( CCmPluginBaseEng*, ptr ); - CleanupStack::PushL( plugin ); - - plugin->CreateNewL(); - plugin->SetIdValidity( EFalse ); - plugin->SetPreDefinedId( aConnMethodId ); - CleanupStack::Pop( plugin ); // plugin - - return plugin; - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::ConnectionMethodL( TUint aId ) -//----------------------------------------------------------------------------- -// -EXPORT_C CCmPluginBaseEng* - CCmManagerImpl::ConnectionMethodL( TUint32 /*aCmId*/ ) - { - LOGGER_ENTERFN( "Error: Obsolete function CCmManagerImpl::ConnectionMethodL used" ); - User::Panic( _L("CMManager"), KErrNotSupported ); - return NULL; - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::GetConnectionMethodL( TUint aId ) -//----------------------------------------------------------------------------- -// -EXPORT_C CCmPluginBase* - CCmManagerImpl::GetConnectionMethodL( TUint32 aCmId ) - { - LOGGER_ENTERFN( "CCmManagerImpl::GetConnectionMethodL" ); - - CCmPluginBase* plugin = DoFindConnMethodL( aCmId, NULL ); - - return plugin; - } - - -//----------------------------------------------------------------------------- -// CCmManagerImpl::AppendUncatCmListL -//----------------------------------------------------------------------------- -// -void CCmManagerImpl::AppendUncatCmListL( RPointerArray& aCMArray, - TBool aCheckBearerType, - TBool aLegacyOnly, - TBool aEasyWlan, - TBool aSortByBearer ) - { - LOGGER_ENTERFN( "CCmManagerImpl::AppendUncatCmListL" ); - - RArray cmUidArray; - CleanupClosePushL(cmUidArray); - ConnectionMethodL(cmUidArray, aCheckBearerType, aLegacyOnly, aEasyWlan, aSortByBearer); - AppendCmListFromUidsL( cmUidArray, aCMArray ); - - CleanupStack::PopAndDestroy(&cmUidArray); - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::AppendUncatCmListLC -//----------------------------------------------------------------------------- -// -void CCmManagerImpl::AppendUncatCmListLC( RPointerArray& aCMArray, - TBool aCheckBearerType, - TBool aLegacyOnly, - TBool aEasyWlan, - TBool aSortByBearer ) - { - LOGGER_ENTERFN( "CCmManagerImpl::AppendUncatCmListLC" ); - - AppendUncatCmListL( aCMArray, aCheckBearerType, aLegacyOnly, aEasyWlan, aSortByBearer); - - CleanupResetAndDestroyPushL< RPointerArray >( aCMArray ); - } - -// ----------------------------------------------------------------------------- -// CCmDestinationImpl::AppendCmListLC -// ----------------------------------------------------------------------------- -// -void CCmManagerImpl::AppendCmListLC( TUint32 aDestintaionId, RPointerArray& aCMArray ) - { - LOGGER_ENTERFN( "CCmManagerImpl::AppendCmListLC" ); - - AppendCmListL( aDestintaionId, aCMArray ); - CCmManagerImpl::CleanupResetAndDestroyPushL< RPointerArray >( aCMArray ); - } - -// ----------------------------------------------------------------------------- -// CCmDestinationImpl::AppendCmListL -// ----------------------------------------------------------------------------- -// -void CCmManagerImpl::AppendCmListL( TUint32 aDestintaionId, RPointerArray& aCMArray ) - { - LOGGER_ENTERFN( "CCmManagerImpl::AppendCmListL" ); - - CCmDestinationImpl* dest = DestinationL( aDestintaionId ); - CleanupStack::PushL(dest); - RArray cmIdList; - CleanupClosePushL(cmIdList); - dest->ConnectMethodIdArrayL( cmIdList ); - AppendCmListFromUidsL( cmIdList, aCMArray ); - CleanupStack::PopAndDestroy(&cmIdList); - CleanupStack::PopAndDestroy(dest); - } -// ----------------------------------------------------------------------------- -// CCmDestinationImpl::AppendCmListFromUidsL -// ----------------------------------------------------------------------------- -// -void CCmManagerImpl::AppendCmListFromUidsL( RArray& cmIdList, RPointerArray& aCMArray ) - { - LOGGER_ENTERFN( "CCmManagerImpl::AppendCmListFromUidsL" ); - - TInt count = cmIdList.Count(); - for ( TInt i = 0; i< count; i++ ) - { - CCmPluginBase* cm = NULL; - TRAPD( err,cm = GetConnectionMethodL( cmIdList[i] )); - if (err == KErrNone) - { - aCMArray.AppendL( cm ); - } - } - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::ConnectionMethodL -//----------------------------------------------------------------------------- -// -EXPORT_C void CCmManagerImpl::ConnectionMethodL( RArray& aCMArray, - TBool aCheckBearerType, - TBool aLegacyOnly, - TBool aEasyWlan, - TBool aSortByBearer ) - { - LOGGER_ENTERFN( "CCmManagerImpl::ConnectionMethodL" ); - - OpenTransactionLC(); - - CMDBRecordSet* ptrRecordSet = AllIapsL(); - CleanupStack::PushL( ptrRecordSet ); - - TInt iapRecords = ptrRecordSet->iRecords.Count(); - CLOG_WRITE_1_PTR( NULL, "Record num [%d]", iapRecords ); - - // Time optimization to load the entire destination table - TInt destTblId = DestinationTableId(); - CMDBRecordSet* ptrDestSet = - new (ELeave) CMDBRecordSet( - destTblId ); - CleanupStack::PushL( ptrDestSet ); - TRAP_IGNORE( ptrDestSet->LoadL( Session() ) ); - - for ( TInt i = 0; i < iapRecords; i++ ) - { - TUint32 iapId = (*ptrRecordSet)[i]->RecordId(); - CLOG_WRITE_1_PTR( NULL, "IAP ID [%d]", iapId ); - if ( aCheckBearerType ) - { - TUint32 bearerType( 0 ); - TRAPD( err, - bearerType = BearerTypeFromIapRecordL( (*ptrRecordSet)[i] )); - if ( !err && bearerType ) - { - // append the IAP id - if aLegacyOnly is ETrue, only for legacy IAPs - if ( !aLegacyOnly || - !NumOfConnMethodReferencesL( iapId, ptrDestSet ) ) - { - if( !aEasyWlan && IsEasyWLanL( (*ptrRecordSet)[i] ) ) - { - continue; - } - - aCMArray.Append( iapId ); - } - } - } - else - { - // append the IAP id - if aLegacyOnly is ETrue, only for legacy IAPs - if ( !aLegacyOnly || - !NumOfConnMethodReferencesL( iapId, ptrDestSet ) ) - { - if( !aEasyWlan && IsEasyWLanL( (*ptrRecordSet)[i] ) ) - { - continue; - } - - aCMArray.Append( iapId ); - } - } - } - - // Re-order the array according to the global bearer ordering rules - if ( aSortByBearer ) - { - RArray bearers( KCmArrayMediumGranularity ); - CleanupClosePushL( bearers ); - SupportedBearersL( bearers ); - - TInt prevInsertedPos = -1; - for ( TInt i = 0; i < bearers.Count(); i++ ) - { - for ( TInt j = prevInsertedPos + 1; j < aCMArray.Count(); j++ ) - { - // Check if CM belongs to this bearer - TUint cmBearerId = GetConnectionMethodInfoIntL( aCMArray[j], - ECmBearerType ); - if ( cmBearerId == bearers[i] ) - { - // copy the cm id to the next 'sorted position' in the array - // the item removed will always be after the insertion position - TUint cmId = aCMArray[j]; - aCMArray.Remove(j); - aCMArray.Insert( cmId, ++prevInsertedPos ); - } - } - } - - CleanupStack::PopAndDestroy( &bearers ); - } - - CleanupStack::PopAndDestroy( 2, ptrRecordSet ); - - RollbackTransaction(); - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::DoFindConnMethodL -//----------------------------------------------------------------------------- -// -CCmPluginBase* CCmManagerImpl::DoFindConnMethodL( TUint32 aCmId, - CCmDestinationImpl* aParentDest ) - { - LOGGER_ENTERFN( "CCmManagerImpl::DoFindConnMethodL" ); - return iObjectPool->GetConnectionMethodL(aCmId, aParentDest); - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::FindConnMethodL -//----------------------------------------------------------------------------- -// -CCmPluginBaseEng* CCmManagerImpl::DoFindConnMethL( TUint32 aCmId, - CCmDestinationImpl* aParentDest ) - { - LOGGER_ENTERFN( "CCmManagerImpl::FindConnMethodL" ); - - // Step through each bearer to find which the CMId belongs to - CCmPluginBaseEng* plugin = NULL; - - TCmPluginInitParam params( *this ); - if (aParentDest) - { - params.iParentDest = aParentDest->Id(); - } - else - { - params.iParentDest = ParentDestinationL( aCmId ); - } - - TUint32 bearerType = BearerTypeFromCmIdL( aCmId ); - - for ( TInt i=0; iCount(); i++ ) - { - if( (*iPlugins)[i]->GetIntAttributeL( ECmBearerType ) == bearerType ) - { - plugin = (*iPlugins)[i]->CreateInstanceL( params ); - break; - } - } - - if ( !plugin ) - { - return plugin; - } - - CleanupStack::PushL( plugin ); - - plugin->LoadL( aCmId ); - - CleanupStack::Pop( plugin ); // 1 - plugin->SetIdValidity(ETrue); - - return plugin; - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::BearerTypeFromIapL( TUint aId ) -//----------------------------------------------------------------------------- -// -TUint32 CCmManagerImpl::BearerTypeFromCmIdL( TUint32 aCmId ) - { - LOGGER_ENTERFN( "CCmManagerImpl::BearerTypeFromIapL" ); - TUint32 bearerType; - if ( aCmId > KMaxIapID ) - { - bearerType = KUidEmbeddedDestination; - } - else - {//aCmId is an IapId - // Load this IAP record from the IAP table - // This is an optimization that plugins doesn't have - // to do it every time the CanHandleIapIdL() is called. - CCDIAPRecord *iapRecord = static_cast - (CCDRecordBase::RecordFactoryL(KCDTIdIAPRecord)); - CleanupStack::PushL( iapRecord ); // 1 - iapRecord->SetRecordId( aCmId ); - - OpenTransactionLC(); - iapRecord->LoadL( Session() ); - RollbackTransaction(); - - bearerType = BearerTypeFromIapRecordL( iapRecord ); - - CleanupStack::PopAndDestroy( iapRecord ); // 0 - } - return bearerType; - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::BearerTypeFromIapRecordL( CCDIAPRecord* aIapRecord ) -//----------------------------------------------------------------------------- -// -TUint32 CCmManagerImpl::BearerTypeFromIapRecordL( CCDIAPRecord* aIapRecord ) const - { - LOGGER_ENTERFN( "CCmManagerImpl::BearerTypeFromIapRecordL" ); - - CLOG_WRITE_1( "Plugin count: [%d]", iPlugins->Count() ); - - TInt err( KErrNone ); - TUint32 extLevel( 0 ); - TInt bearerType( 0 ); - TBool canHandle( EFalse ); - - // Check which bearer handles the given IAPid - for ( TInt i=0; iCount(); i++ ) - { - // a defective, or a wrong AP can't cause any trouble. - TRAP( err, canHandle = (*iPlugins)[i]->CanHandleIapIdL( aIapRecord ) ); - CLOG_WRITE_3( "plugin [%d] returned with error %d, CanH: %d", - i, err, TUint32(canHandle) ); - if ( !err && canHandle ) - { - if ( extLevel < - (*iPlugins)[i]->GetIntAttributeL( ECmExtensionLevel ) ) - { - extLevel = (*iPlugins)[i]->GetIntAttributeL(ECmExtensionLevel); - bearerType = (*iPlugins)[i]->GetIntAttributeL( ECmBearerType ); - } - } - else if ( err == KErrNoMemory ) - { - User::Leave( err ); - } - } - - if ( !bearerType ) - // No supporting plugin found. - { - CLOG_WRITE( "Plugin not found, Leaving." ); - User::Leave( KErrNotSupported ); - } - CLOG_WRITE_1( "Returning bearertype: [%d]", bearerType ); - return bearerType; - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::AllDestinationsL() -//----------------------------------------------------------------------------- -// -EXPORT_C void CCmManagerImpl::AllDestinationsL( RArray& aDestArray ) - { - LOGGER_ENTERFN( "CCmManagerImpl::AllDestinationsL" ); - - OpenTransactionLC(); - - CMDBRecordSet* destRecordSet = - new ( ELeave ) CMDBRecordSet( - iDestinationTableId ); - CleanupStack::PushL( destRecordSet ); - - TRAP_IGNORE( destRecordSet->LoadL( Session() ) ); - - iDestinationCount = destRecordSet->iRecords.Count(); - - //========================================================================= - // Step through every item in the NW Table and check whether it is linked - // in the DN_IAP table - // - for ( TInt i = 0; i < iDestinationCount; ++i ) - { - TInt nwId = QUERY_INT_FIELD( destRecordSet->iRecords[i], - KCDTIdDataMobilitySelectionPolicyNetwork ); - TBool found( EFalse ); - - for ( TInt j = 0; j < aDestArray.Count(); ++j ) - { - if ( aDestArray[j] == nwId ) - { - found = ETrue; - break; - } - } - - if ( !found ) - { - aDestArray.AppendL( nwId ); - CLOG_WRITE_2( "Dest(%d): [%d]", aDestArray.Count(), nwId ); - } - } - - CleanupStack::PopAndDestroy( destRecordSet ); - - RollbackTransaction(); - - CLOG_WRITE_1( "No. of dests found: [%d] ", aDestArray.Count() ); - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::DestinationL() -//----------------------------------------------------------------------------- -// -EXPORT_C CCmDestinationImpl* CCmManagerImpl::DestinationL( TUint32 aId ) - { - LOGGER_ENTERFN( "CCmManagerImpl::DestinationL" ); - - // Create destination object - return iObjectPool->GetDestinationL( aId ); - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::RemoveDestFromPool -//----------------------------------------------------------------------------- -// -EXPORT_C void CCmManagerImpl::RemoveDestFromPool( CCmDestinationImpl* aDestination ) - { - LOGGER_ENTERFN( "CCmManagerImpl::RemoveDestFromPool" ); - iObjectPool->RemoveDestination(aDestination); - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::RemoveDestFromPool -//----------------------------------------------------------------------------- -// -void CCmManagerImpl::RemoveDestFromPool( CCmDestinationData* aDestination ) - { - LOGGER_ENTERFN( "CCmManagerImpl::RemoveDestFromPool" ); - iObjectPool->RemoveDestination(aDestination); - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::RemoveCMFromPool -//----------------------------------------------------------------------------- -// -void CCmManagerImpl::RemoveCMFromPoolL( CCmPluginBaseEng* aCM ) - { - LOGGER_ENTERFN( "CCmManagerImpl::RemoveCMFromPool" ); - iObjectPool->RemoveConnectionMethodL( aCM ); - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::RemoveCMFromPool -//----------------------------------------------------------------------------- -// -void CCmManagerImpl::RemoveCMFromPoolL( CCmPluginBase* aCM ) - { - LOGGER_ENTERFN( "CCmManagerImpl::RemoveCMFromPool" ); - iObjectPool->RemoveConnectionMethodL( aCM ); - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::CopyConnectionMethodL() -//----------------------------------------------------------------------------- -// -TInt CCmManagerImpl::CopyConnectionMethodL( - CCmDestinationImpl& aTargetDestination, - CCmPluginBase& aConnectionMethod ) - { - LOGGER_ENTERFN( "CCmManagerImpl::CopyConnectionMethodL" ); - - OpenTransactionLC(); - TInt index = aTargetDestination.AddConnectionMethodL( aConnectionMethod ); - aTargetDestination.UpdateL(); - CommitTransactionL( 0 ); - - return index; - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::MoveConnectionMethodL() -//----------------------------------------------------------------------------- -// -TInt CCmManagerImpl::MoveConnectionMethodL( - CCmDestinationImpl& aSourceDestination, - CCmDestinationImpl& aTargetDestination, - CCmPluginBase& aConnectionMethod ) - { - LOGGER_ENTERFN( "CCmManagerImpl::MoveConnectionMethodL" ); - - OpenTransactionLC(); - - TInt index = CopyConnectionMethodL( aTargetDestination, aConnectionMethod ); - aSourceDestination.RemoveConnectionMethodL( aConnectionMethod ); - aSourceDestination.UpdateL(); - - CommitTransactionL( KErrNone ); - - return index; - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::RemoveConnectionMethodL() -//----------------------------------------------------------------------------- -// -void CCmManagerImpl::RemoveConnectionMethodL( - CCmDestinationImpl& aDestination, - CCmPluginBase& aConnectionMethod ) - { - LOGGER_ENTERFN( "CCmManagerImpl::RemoveConnectionMethodL" ); - - OpenTransactionLC(); - aDestination.RemoveConnectionMethodL( aConnectionMethod ); - aDestination.UpdateL(); - CommitTransactionL( 0 ); - } - -//----------------------------------------------------------------------------- -// RCmManagerExt::SupportedBearers() -//----------------------------------------------------------------------------- -// -void CCmManagerImpl::SupportedBearersL( RArray& aArray ) const - { - LOGGER_ENTERFN( "CCmManagerImpl::SupportedBearersL" ); - - for ( TInt i = 0; i < iPlugins->Count(); i++ ) - { - TUint32 bearerType( (*iPlugins)[i]->GetIntAttributeL(ECmBearerType) ); - - if ( KUidEmbeddedDestination != bearerType ) - { - aArray.AppendL( (*iPlugins)[i]->GetIntAttributeL(ECmBearerType) ); - } - } - } - -// ----------------------------------------------------------------------------- -// CCmManagerImpl::NumOfConnMethodReferencesL() -// ----------------------------------------------------------------------------- -// -TUint32 CCmManagerImpl::NumOfConnMethodReferencesL( - TUint32 aId, - CMDBRecordSet* aRecSet ) - { - LOGGER_ENTERFN( "CCmManagerImpl::NumOfConnMethodReferencesL" ); - - OpenTransactionLC(); - - TUint32 retVal( 0 ); - - if ( aRecSet ) - { - TMDBElementId id( IAP_ELEMENT_ID(aId) ); - - for ( TInt i = 0; i < aRecSet->iRecords.Count(); ++i ) - { - if ( QUERY_UINT32_FIELD( (*aRecSet)[i], - KCDTIdDataMobilitySelectionPolicyIAP ) == - id ) - { - ++retVal; - } - } - } - else - { - // Just to test how many record we have - TInt destTblId = DestinationTableId(); - CMDBRecordSet* ptrRecordSet = - new (ELeave) CMDBRecordSet( - destTblId ); - CleanupStack::PushL( ptrRecordSet ); - - // Prime record - CCDDataMobilitySelectionPolicyRecord* record = - new (ELeave) CCDDataMobilitySelectionPolicyRecord( - DestinationTableId() ); - CleanupStack::PushL( record ); - - record->iIAP = IAP_ELEMENT_ID( aId ); - ptrRecordSet->iRecords.AppendL( record ); - - CleanupStack::Pop( record ); - record = NULL; - - if ( ptrRecordSet->FindL(Session()) ) - { - // we have a match - retVal = ptrRecordSet->iRecords.Count(); - CLOG_WRITE_1( "Found: [%d]", retVal ); - } - else - { - CLOG_WRITE( "Nothing" ); - } - - CleanupStack::PopAndDestroy( ); // ptrRecordSet - } - - RollbackTransaction(); - - return retVal; - } - -// ----------------------------------------------------------------------------- -// CCmManagerImpl::HasUnprotectedDestinationsL -// ----------------------------------------------------------------------------- -// -TBool CCmManagerImpl::HasUnprotectedDestinationsL() - { - LOGGER_ENTERFN( "CCmManagerImpl::HasUnprotectedDestinationsL" ); - - TBool hasUnprotectedDests( EFalse ); - - RArray destIdArray( KCmArrayBigGranularity ); - AllDestinationsL( destIdArray ); - CleanupClosePushL( destIdArray ); - - CCmDestinationImpl* dest = NULL; - for ( TInt i = 0; i < destIdArray.Count(); i++ ) - { - dest = DestinationL( destIdArray[i] ); - CleanupStack::PushL( dest ); - if ( dest->ProtectionLevel() != EProtLevel1 ) - { - hasUnprotectedDests = ETrue; - CleanupStack::PopAndDestroy( dest ); - break; - } - CleanupStack::PopAndDestroy( dest ); - } - - CleanupStack::PopAndDestroy( &destIdArray ); - - return hasUnprotectedDests; - } - - -// ----------------------------------------------------------------------------- -// CCmManagerImpl::BuildPluginArrayL() -// ----------------------------------------------------------------------------- -// -void CCmManagerImpl::BuildPluginArrayL() - { - LOGGER_ENTERFN( "CCmManagerImpl::BuildPluginArrayL" ); - iPlugins = new (ELeave) CArrayPtrFlat( - KPluginGranularity ); - - // Get a list of all the bearer types - RImplInfoPtrArray implArray; - REComSession::ListImplementationsL( TUid::Uid( KCMPluginInterfaceUid ), - implArray ); - - CleanupClosePushL( implArray ); // 1 - - CCmPluginBaseEng* plugin = NULL; - for ( TInt i=0; iImplementationUid(), - _FOFF( CCmPluginBaseEng, - iDtor_ID_Key ), - (TAny*)¶ms )) ); - - if ( !err ) - { - CLOG_ATTACH( plugin, this ); - - CleanupStack::PushL( plugin ); - - TBool inserted( EFalse ); - TInt defaultPriority( KDataMobilitySelectionPolicyPriorityWildCard ); - - // No UI priority -> wildcard - TRAP_IGNORE( defaultPriority = plugin->GetIntAttributeL( ECmDefaultUiPriority ) ); - - for( TInt j( 0 ); j < iPlugins->Count(); ++j ) - { - if( defaultPriority > (*iPlugins)[j]->GetIntAttributeL( ECmDefaultUiPriority ) ) - { - continue; - } - else if( defaultPriority == (*iPlugins)[j]->GetIntAttributeL( ECmDefaultUiPriority ) ) - { - if( plugin->GetIntAttributeL( ECmExtensionLevel ) > - (*iPlugins)[j]->GetIntAttributeL( ECmExtensionLevel ) ) - { - iPlugins->InsertL( j, plugin ); - inserted = ETrue; - break; - } - } - else - { - iPlugins->InsertL( j, plugin ); - inserted = ETrue; - break; - } - } - - if( !inserted ) - { - iPlugins->AppendL( plugin ); - } - - CleanupStack::Pop( plugin ); - } - } - - implArray.ResetAndDestroy(); - - CleanupStack::PopAndDestroy(); // implArray; - } - -// ----------------------------------------------------------------------------- -// CCmManagerImpl::GetBearerInfoIntL() -// ----------------------------------------------------------------------------- -// -EXPORT_C TUint32 CCmManagerImpl::GetBearerInfoIntL( TUint32 aBearerType, - TUint32 aAttribute ) const - { - LOGGER_ENTERFN( "CCmManagerImpl::GetBearerInfoIntL" ); - if( !IsBearerSpecific( aAttribute ) ) - { - User::Leave( KErrNotSupported ); - } - - for ( TInt i = 0; i < iPlugins->Count(); ++i ) - { - if ( aBearerType == (*iPlugins)[i]->GetIntAttributeL( ECmBearerType ) ) - { - return (*iPlugins)[i]->GetIntAttributeL( aAttribute ); - } - } - - User::Leave( KErrNotSupported ); - - return 0; - } - -// ----------------------------------------------------------------------------- -// CCmManagerImpl::GetBearerInfoBoolL() -// ----------------------------------------------------------------------------- -// -EXPORT_C TBool CCmManagerImpl::GetBearerInfoBoolL( TUint32 aBearerType, - TUint32 aAttribute ) const - { - LOGGER_ENTERFN( "CCmManagerImpl::GetBearerInfoBoolL" ); - if( !IsBearerSpecific( aAttribute ) ) - { - User::Leave( KErrNotSupported ); - } - - for ( TInt i = 0; i < iPlugins->Count(); ++i ) - { - if ( aBearerType == (*iPlugins)[i]->GetIntAttributeL( ECmBearerType ) ) - { - return (*iPlugins)[i]->GetBoolAttributeL( aAttribute ); - } - } - - User::Leave( KErrNotSupported ); - - return EFalse; - } - -// ----------------------------------------------------------------------------- -// CCmManagerImpl::GetBearerInfoStringL() -// ----------------------------------------------------------------------------- -// -EXPORT_C HBufC* CCmManagerImpl::GetBearerInfoStringL( TUint32 aBearerType, - TUint32 aAttribute ) const - { - LOGGER_ENTERFN( "CCmManagerImpl::GetBearerInfoStringL" ); - if( !IsBearerSpecific( aAttribute ) ) - { - User::Leave( KErrNotSupported ); - } - - for ( TInt i = 0; i < iPlugins->Count(); ++i ) - { - if ( aBearerType == (*iPlugins)[i]->GetIntAttributeL( ECmBearerType ) ) - { - return (*iPlugins)[i]->GetStringAttributeL( aAttribute ); - } - } - - User::Leave( KErrNotSupported ); - - return NULL; - } - -// ----------------------------------------------------------------------------- -// CCmManagerImpl::GetBearerInfoString8L() -// ----------------------------------------------------------------------------- -// -EXPORT_C HBufC8* CCmManagerImpl::GetBearerInfoString8L( TUint32 aBearerType, - TUint32 aAttribute ) const - { - LOGGER_ENTERFN( "CCmManagerImpl::GetBearerInfoStringL" ); - if( !IsBearerSpecific( aAttribute ) ) - { - User::Leave( KErrNotSupported ); - } - - for ( TInt i = 0; i < iPlugins->Count(); ++i ) - { - if ( aBearerType == (*iPlugins)[i]->GetIntAttributeL( ECmBearerType ) ) - { - return (*iPlugins)[i]->GetString8AttributeL( aAttribute ); - } - } - - User::Leave( KErrNotSupported ); - - return NULL; - } - -// ----------------------------------------------------------------------------- -// CCmManagerImpl::GetConnectionMethodInfoIntL() -// ----------------------------------------------------------------------------- -// -EXPORT_C TUint32 CCmManagerImpl::GetConnectionMethodInfoIntL( TUint32 aCmId, - TUint32 aAttribute ) const - { - LOGGER_ENTERFN( "CCmManagerImpl::GetConnectionMethodInfoIntL" ); - - if ( aAttribute == ECmBearerType ) - { - return const_cast(this)->BearerTypeFromCmIdL( aCmId ); - } - else - { - return iPluginImpl->GetConnectionInfoIntL( aCmId, aAttribute ); - } - } - -// ----------------------------------------------------------------------------- -// CCmManagerImpl::GetConnectionMethodInfoBoolL() -// ----------------------------------------------------------------------------- -// -EXPORT_C TBool CCmManagerImpl::GetConnectionMethodInfoBoolL( TUint32 aCmId, - TUint32 aAttribute ) const - { - LOGGER_ENTERFN( "CCmManagerImpl::GetConnectionMethodInfoBoolL" ); - - TBool retval = EFalse; - if ( aAttribute == ECmVirtual ) - { - TUint32 b = GetConnectionMethodInfoIntL( aCmId, ECmBearerType ); - retval = GetBearerInfoBoolL( b, ECmVirtual ); - } - else - { - retval = iPluginImpl->GetConnectionInfoBoolL( aCmId, aAttribute ); - } - return retval; - } - -// ----------------------------------------------------------------------------- -// CCmManagerImpl::GetConnectionMethodInfoStringL() -// ----------------------------------------------------------------------------- -// -EXPORT_C HBufC* CCmManagerImpl::GetConnectionMethodInfoStringL( - TUint32 aCmId, - TUint32 aAttribute ) const - { - LOGGER_ENTERFN( "CCmManagerImpl::GetConnectionMethodInfoStringL" ); - - return iPluginImpl->GetConnectionInfoStringL( aCmId, aAttribute ); - } - -// ----------------------------------------------------------------------------- -// CCmManagerImpl::GetConnectionMethodInfoStringL() -// ----------------------------------------------------------------------------- -// -EXPORT_C HBufC8* CCmManagerImpl::GetConnectionMethodInfoString8L( - TUint32 aCmId, - TUint32 aAttribute ) const - { - LOGGER_ENTERFN( "CCmManagerImpl::GetConnectionMethodInfoString8L" ); - - return iPluginImpl->GetConnectionInfoString8L( aCmId, aAttribute ); - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::UncategorizedIconL() -//----------------------------------------------------------------------------- -// -CGulIcon* CCmManagerImpl::UncategorizedIconL() const - { - LOGGER_ENTERFN( "CCmManagerImpl::UncategorizedIconL" ); - - MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance(); - - TParse mbmFile; - User::LeaveIfError( mbmFile.Set( KManagerIconFilename, - &KDC_BITMAP_DIR, - NULL ) ); - - CGulIcon* icon = AknsUtils::CreateGulIconL( - skinInstance, - KAknsIIDQgnPropSetConnDestUncategorized, - mbmFile.FullName(), - EMbmCmmanagerQgn_prop_set_conn_dest_uncategorized, - EMbmCmmanagerQgn_prop_set_conn_dest_uncategorized_mask ); - - return icon; - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::UncategorizedIconL() -//----------------------------------------------------------------------------- -// -CMDBSession& CCmManagerImpl::Session() const - { - return iTrans->Session(); - } - -// ----------------------------------------------------------------------------- -// CCmManagerImpl::HasCapabilityL() -// ----------------------------------------------------------------------------- -// -void CCmManagerImpl::HasCapabilityL( TCapability aCapability ) - { - TSecurityInfo info; - - info.SetToCurrentInfo(); - - if( !info.iCaps.HasCapability( aCapability ) ) - { - User::Leave( KErrPermissionDenied ); - } - } - -// --------------------------------------------------------------------------- -// CCmManagerImpl::FeatureSupported -// --------------------------------------------------------------------------- -TBool CCmManagerImpl::FeatureSupported( TInt aFeature ) - { - return FeatureManager::FeatureSupported( aFeature ); - } - -// --------------------------------------------------------------------------- -// CCmManagerImpl::IsEasyWLan -// -// We can't have any dependecy to WLan plugin, but -// in some cases we need to filter out EasyWLan access points. -// --------------------------------------------------------------------------- -TBool CCmManagerImpl::IsEasyWLanL( CCDIAPRecord* aIapRecord ) const - { - LOGGER_ENTERFN( "CCmManagerImpl::IsEasyWLanL" ); - if (!iWLan) - { - return EFalse; - } - if( (TPtrC(aIapRecord->iServiceType) != TPtrC(KCDTypeNameLANService) ) || - TPtrC(aIapRecord->iBearerType) != TPtrC(KCDTypeNameLANBearer) ) - { - return EFalse; - } - - TBool retVal( EFalse ); - TUint32 serviceId = aIapRecord->iService; - - CCDWlanServiceRecord* wLanServ = - new (ELeave) CCDWlanServiceRecord( CCDWlanServiceRecord::TableIdL( Session() ) ); - - CleanupStack::PushL( wLanServ ); - - wLanServ->iWlanServiceId.SetL( serviceId ); - - if( wLanServ->FindL( Session() ) ) - { - wLanServ->LoadL( Session() ); - - if( wLanServ->iWLanSSID.IsNull() || - !TPtrC(wLanServ->iWLanSSID).Compare( KNullDesC ) ) - { - retVal = ETrue; - } - } - - CleanupStack::PopAndDestroy( wLanServ ); - - return retVal; - } - -// ----------------------------------------------------------------------------- -// CCmManagerImpl::EasyWlanIdL() -// ----------------------------------------------------------------------------- -// -EXPORT_C TUint32 CCmManagerImpl::EasyWlanIdL() - { - LOGGER_ENTERFN( "CCmManagerImpl::EasyWlanId" ); - - OpenTransactionLC(); - - TUint32 easyId( 0 ); - - CMDBRecordSet* ptrRecordSet = AllIapsL(); - CleanupStack::PushL( ptrRecordSet ); - TInt iapRecords = ptrRecordSet->iRecords.Count(); - CLOG_WRITE_1_PTR( NULL, "Record num [%d]", iapRecords ); - - for ( TInt i = 0; i < iapRecords; i++ ) - { - CCDIAPRecord* iapRecord = (*ptrRecordSet)[i]; - - if( (TPtrC(iapRecord->iServiceType) == TPtrC(KCDTypeNameLANService) ) && - TPtrC(iapRecord->iBearerType) == TPtrC(KCDTypeNameLANBearer) ) - { - if( IsEasyWLanL( iapRecord ) ) - { - easyId = (*ptrRecordSet)[i]->RecordId(); - break; - } - } - } - - CleanupStack::PopAndDestroy( ptrRecordSet ); - - RollbackTransaction(); - - return easyId; - } - -// ----------------------------------------------------------------------------- -// CCmManagerImpl::AllIapsL() -// ----------------------------------------------------------------------------- -// -CMDBRecordSet* CCmManagerImpl::AllIapsL() - { - LOGGER_ENTERFN( "CCmManagerImpl::AllIapsL" ); - - OpenTransactionLC(); - - CMDBRecordSet* ptrRecordSet = - new (ELeave) CMDBRecordSet( KCDTIdIAPRecord ); - - TRAP_IGNORE( ptrRecordSet->LoadL( Session() ) ); - - RollbackTransaction(); - - return ptrRecordSet; - } - -// ----------------------------------------------------------------------------- -// CCmManagerImpl::AllSNAPRecordsL() -// ----------------------------------------------------------------------------- -// -CMDBRecordSet* - CCmManagerImpl::AllSNAPRecordsL( TUint32 aSnapElementId ) - { - LOGGER_ENTERFN( "CCmManagerImpl::AllSNAPRecordsL" ); - - CMDBRecordSet* ptrRecordSet = - new (ELeave) CMDBRecordSet( - DestinationTableId() ); - CleanupStack::PushL( ptrRecordSet ); - - OpenTransactionLC(); - if( aSnapElementId ) - { - // Prime record - CCDSnapRecord* record = SNAPRecordL( 0 ); - CleanupStack::PushL( record ); - record->iEmbeddedSNAP = aSnapElementId; - ptrRecordSet->iRecords.AppendL( record ); - - CleanupStack::Pop( record ); - record = NULL; - - ptrRecordSet->FindL( Session() ); - } - else - { - ptrRecordSet->LoadL( Session() ); - } - - RollbackTransaction(); - - return ptrRecordSet; - } - -// ----------------------------------------------------------------------------- -// CCmManagerImpl::IsIapLinkedL() -// ----------------------------------------------------------------------------- -// -TBool CCmManagerImpl::IsIapLinkedL( const CCmPluginBaseEng& aPlugin ) - { - LOGGER_ENTERFN( "CCmManagerImpl::IsIapLinkedL" ); - - TUint32 iapId = aPlugin.GetIntAttributeL( ECmId ); - CMDBRecordSet* ptrRecordSet = AllIapsL(); - CleanupStack::PushL( ptrRecordSet ); - - TInt iapRecords = ptrRecordSet->iRecords.Count(); - CLOG_WRITE_1_PTR( NULL, "Record num [%d]", iapRecords ); - - TBool linked( EFalse ); - for ( TInt i = 0; !linked && i < iapRecords; i++ ) - { - CCDIAPRecord* iapRecord = (*ptrRecordSet)[i]; - - if( iapRecord->RecordId() == iapId ) - { - continue; - } - - TUint32 bearerType( 0 ); - - TRAP_IGNORE( bearerType = BearerTypeFromIapRecordL( iapRecord ) ); - if( bearerType ) - { - if( GetBearerInfoBoolL( bearerType, ECmVirtual ) ) - { - CCmPluginBase* plugin = NULL; - - TRAP_IGNORE( plugin = GetConnectionMethodL( iapRecord->RecordId() ) ); - if( plugin ) - { - linked = plugin->IsLinkedToIap( iapId ); - } - - delete plugin; - } - } - } - CleanupStack::PopAndDestroy( ptrRecordSet ); - - return linked; - } - -// ----------------------------------------------------------------------------- -// CCmManagerImpl::RemoveAllReferencesL() -// ----------------------------------------------------------------------------- -// -void CCmManagerImpl::RemoveAllReferencesL( const CCmPluginBaseEng& aPlugin ) - { - RArray dests; - CleanupClosePushL( dests ); - OpenTransactionLC(); - - AllDestinationsL( dests ); - - for( TInt i = 0; i < dests.Count(); ++i ) - { - CCmDestinationImpl* dest = DestinationL( dests[i] ); - CleanupStack::PushL( dest ); - TRAPD( err, dest->RemoveConnectionMethodL( aPlugin ) ); - - if( err != KErrNotFound ) - { - User::LeaveIfError( err ); - - dest->UpdateL(); - } - - CleanupStack::PopAndDestroy( dest ); - } - - CommitTransactionL( 0 ); - CleanupStack::PopAndDestroy( &dests ); - } - -// ----------------------------------------------------------------------------- -// CCmManagerImpl::RemoveAllReferencesLWoTransL() -// ----------------------------------------------------------------------------- -// -void CCmManagerImpl::RemoveAllReferencesWoTransL( const CCmPluginBaseEng& aPlugin ) - { - LOGGER_ENTERFN( "CCmManagerImpl::RemoveAllReferencesWoTransL" ); - - RArray dests; - CleanupClosePushL( dests ); - - AllDestinationsL( dests ); - - for( TInt i = 0; i < dests.Count(); ++i ) - { - CCmDestinationImpl* dest = DestinationL( dests[i] ); - CleanupStack::PushL( dest ); - TRAPD( err, dest->RemoveConnectionMethodL( aPlugin ) ); - - if( err != KErrNotFound ) - { - User::LeaveIfError( err ); - - dest->UpdateL(); - } - - CleanupStack::PopAndDestroy( dest ); - } - CleanupStack::PopAndDestroy( &dests ); - } - -// ----------------------------------------------------------------------------- -// CCmManagerImpl::HandleDefConnDeletedL() -// ----------------------------------------------------------------------------- -// -void CCmManagerImpl::HandleDefConnDeletedL( TCmDefConnValue& aDCSetting ) - { - LOGGER_ENTERFN( "CCmManagerImpl::HandleDefConnDeletedL" ); - - if ( IsDefConnSupported() ) - { - TCmDefConnValue defConn; - ReadDefConnWoTransL(defConn); - if ( defConn == aDCSetting ) - { - // Default connection deleted, setting it to default value. - TUint32 destId = GetInternetDestinationIdL(); - - if ( destId && ( destId != aDCSetting.iId ) ) - { - defConn.iType = ECmDefConnDestination; - defConn.iId = destId; - } - else - { - // Internet destination not found. Initialise to zero. - defConn.iType = TCmDefConnType ( 0 ); - defConn.iId = 0; - } - - WriteDefConnWoTransL( defConn ); - } - } // do nothing if default connection is not supported - } - -// ----------------------------------------------------------------------------- -// CCmManagerImpl::ReadDefConnWoTransL() -// ----------------------------------------------------------------------------- -// -void CCmManagerImpl::ReadDefConnWoTransL( TCmDefConnValue& aDCSetting ) - { - LOGGER_ENTERFN( "CCmManagerImpl::ReadDefConnWoTransL" ); - if ( IsDefConnSupported() ) - { - CMDBRecordSet* defConnRecordSet = - new ( ELeave ) CMDBRecordSet( iDefConnTableId ); - CleanupStack::PushL( defConnRecordSet ); - - TRAPD( err, defConnRecordSet->LoadL( Session() ) ); - if (err == KErrNone) - { - TInt mode = QUERY_INT_FIELD( defConnRecordSet->iRecords[0], - KCDTIdDefConnType ); - aDCSetting.iType= TCmDefConnType (mode); - - aDCSetting.iId = QUERY_INT_FIELD( defConnRecordSet->iRecords[0], - KCDTIdDefConnUid ); - CLOG_WRITE( "Default Connection read OK " ); - } - else - { - //deleting old record, writing Always Ask (default value) - //aDCSetting.iType = ECmDefConnAlwaysAsk; - //aDCSetting.iId = 0; - TUint32 destId = GetInternetDestinationIdL(); - - if ( destId ) - { - aDCSetting.iType = ECmDefConnDestination; - aDCSetting.iId = destId; - } - else - { - // Internet destination not found. Initialise to zero. - aDCSetting.iType = TCmDefConnType ( 0 ); - aDCSetting.iId = 0; - } - - CLOG_WRITE( "Default Connection read FAILED, storing Always Ask! " ); - ReplaceDefConnRecordL( aDCSetting ); - } - CleanupStack::PopAndDestroy( defConnRecordSet ); - } - else - { - CLOG_WRITE( "Default Connection NOT supported, leaving with KErrNotSupported" ); - User::Leave(KErrNotSupported); - } - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::WriteDefConnWoTransL() -//----------------------------------------------------------------------------- -// -void CCmManagerImpl::WriteDefConnWoTransL( const TCmDefConnValue& aDCSetting ) - { - LOGGER_ENTERFN( "CCmManagerImpl::WriteDefConnWoTransL" ); - - if ( IsDefConnSupported() ) - { - ReplaceDefConnRecordL( aDCSetting ); - } - else - { - CLOG_WRITE( "Default Connection NOT supported, leaving with KErrNotSupported" ); - User::Leave(KErrNotSupported); - } - } - -// ----------------------------------------------------------------------------- -// CCmManagerImpl::ReadDefConnL() -// ----------------------------------------------------------------------------- -// -void CCmManagerImpl::ReadDefConnL( TCmDefConnValue& aDCSetting ) - { - LOGGER_ENTERFN( "CCmManagerImpl::ReadDefConn" ); - - if ( IsDefConnSupported() ) - { - OpenTransactionLC(); - CMDBRecordSet* defConnRecordSet = - new ( ELeave ) CMDBRecordSet( iDefConnTableId ); - CleanupStack::PushL( defConnRecordSet ); - - TRAPD( err, defConnRecordSet->LoadL( Session() ) ); - if (err == KErrNone) - { - TInt mode = QUERY_INT_FIELD( defConnRecordSet->iRecords[0], - KCDTIdDefConnType ); - aDCSetting.iType= TCmDefConnType ( mode ); - - aDCSetting.iId = QUERY_INT_FIELD( defConnRecordSet->iRecords[0], - KCDTIdDefConnUid ); - CleanupStack::PopAndDestroy( defConnRecordSet ); - RollbackTransaction(); - } - else - { - //deleting old record, writing Always Ask (default value) - //aDCSetting.iType = ECmDefConnAlwaysAsk; - //aDCSetting.iId = 0; - - TUint32 destId = GetInternetDestinationIdL(); - - if ( destId ) - { - aDCSetting.iType = ECmDefConnDestination; - aDCSetting.iId = destId; - } - else - { - // Internet destination not found. Initialise to zero. - aDCSetting.iType = TCmDefConnType ( 0 ); - aDCSetting.iId = 0; - } - - CLOG_WRITE( "Default Connection read FAILED, storing Always Ask! " ); - ReplaceDefConnRecordL( aDCSetting ); - - CleanupStack::PopAndDestroy( defConnRecordSet ); - CommitTransactionL( KErrNone ); - } - } - else - { - CLOG_WRITE( "Default Connection NOT supported" ); - User::Leave(KErrNotSupported); - } - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::ReplaceDefConnRecordL() -//----------------------------------------------------------------------------- -// -void CCmManagerImpl::ReplaceDefConnRecordL( const TCmDefConnValue aDCSetting ) - { - - LOGGER_ENTERFN( "CCmManagerImpl::ReplaceDefConnRecordL" ); - // Check the Id first (that it exists) - if ( aDCSetting.iType == ECmDefConnConnectionMethod ) - { - CCDIAPRecord* iapRecord = static_cast - ( CCDRecordBase::RecordFactoryL( KCDTIdIAPRecord ) ); - CleanupStack::PushL( iapRecord ); - iapRecord->SetRecordId( aDCSetting.iId ); - TRAPD( err, iapRecord->LoadL( Session() ) ); - if ( err == KErrNotFound ) - { - User::Leave( KErrArgument ); - } - CleanupStack::PopAndDestroy( iapRecord ); - - // Check that Connection Method is not hidden - if ( GetConnectionMethodInfoBoolL( aDCSetting.iId, ECmHidden ) ) - { - User::Leave( KErrArgument ); - } - } - else if ( aDCSetting.iType == ECmDefConnDestination ) - { - TUint32 destId = GetInternetDestinationIdL(); - - // Allow empty Internet destination, others must have some content - if ( destId != aDCSetting.iId ) - { - CCDAccessPointRecord* destAPRecord = static_cast( - CCDRecordBase::RecordFactoryL( KCDTIdAccessPointRecord ) ); - CleanupStack::PushL( destAPRecord ); - - destAPRecord->iRecordTag = aDCSetting.iId; - if ( !destAPRecord->FindL( Session() ) ) - { - User::Leave( KErrArgument ); - } - CleanupStack::PopAndDestroy( destAPRecord ); - } - } - - TInt ret = KErrNone; - TCmGenConnSettings genConnSettings; - - SetGenConnSettingsToDefault( genConnSettings ); - - CMDBRecordSet* defConnRecordSet = - new ( ELeave ) CMDBRecordSet( iDefConnTableId ); - CleanupStack::PushL( defConnRecordSet ); - - TRAP( ret, defConnRecordSet->LoadL( Session() ) ); - - if (ret == KErrNone) - { - TInt value = QUERY_INT_FIELD( defConnRecordSet->iRecords[0], KCDTIdUsageOfWlan ); - genConnSettings.iUsageOfWlan = TCmUsageOfWlan( value ); - - value = QUERY_INT_FIELD( defConnRecordSet->iRecords[0], KCDTIdCellularDataUsageHome ); - genConnSettings.iCellularDataUsageHome = TCmCellularDataUsage( value ); - - value = QUERY_INT_FIELD( defConnRecordSet->iRecords[0], KCDTIdCellularDataUsageVisitor ); - genConnSettings.iCellularDataUsageVisitor = TCmCellularDataUsage( value ); - } - - TInt typeVal = aDCSetting.iType; - TInt uidVal = aDCSetting.iId; - - // Delete the old record - for ( TInt i = 0; i < defConnRecordSet->iRecords.Count(); ++i ) - { - defConnRecordSet->iRecords[i]->DeleteL( Session() ); - } - CleanupStack::PopAndDestroy( defConnRecordSet ); - - CCDDefConnRecord* dcRcd = - new (ELeave) CCDDefConnRecord( iDefConnTableId ); - CleanupStack::PushL( dcRcd ); // 2 - - dcRcd->SetRecordId( KCDNewRecordRequest ); - - SET_INT_FIELD(dcRcd, KCDTIdUsageOfWlan, genConnSettings.iUsageOfWlan ); - SET_INT_FIELD(dcRcd, KCDTIdCellularDataUsageHome, genConnSettings.iCellularDataUsageHome ); - SET_INT_FIELD(dcRcd, KCDTIdCellularDataUsageVisitor, genConnSettings.iCellularDataUsageVisitor ); - - CLOG_WRITE_FORMAT( "Set default connection type: [%d]", typeVal ); - SET_INT_FIELD( dcRcd, - KCDTIdDefConnType, - typeVal ); - CLOG_WRITE_1( "Set uid: [%d]", uidVal ); - SET_INT_FIELD( dcRcd, - KCDTIdDefConnUid, - uidVal ); - dcRcd->StoreL( Session() ); - CleanupStack::PopAndDestroy( dcRcd ); - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::WriteDefConnL() -//----------------------------------------------------------------------------- -// -void CCmManagerImpl::WriteDefConnL( const TCmDefConnValue& aDCSetting ) - { - LOGGER_ENTERFN( "CCmManagerImpl::WriteDefConnL" ); - - if ( ( aDCSetting.iType == ECmDefConnAlwaysAsk ) || - ( aDCSetting.iType == ECmDefConnAskOnce ) ) - { - User::Leave( KErrNotSupported ); - } - - if ( IsDefConnSupported() ) - { - OpenTransactionLC(); - - ReplaceDefConnRecordL( aDCSetting ); - CommitTransactionL( KErrNone ); - } - else - { - CLOG_WRITE( "Default Connection NOT supported, leaving with KErrNotSupported" ); - User::Leave(KErrNotSupported); - } - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::IsDefConnSupported() -//----------------------------------------------------------------------------- -// -TBool CCmManagerImpl::IsDefConnSupported( ) - { - LOGGER_ENTERFN( "CCmManagerImpl::IsDefConnSupported" ); - - return iDefConnSupported; - } - -// ----------------------------------------------------------------------------- -// CCmManagerImpl::ReadGenConneSettingsL() -// ----------------------------------------------------------------------------- -// -void CCmManagerImpl::ReadGenConnSettingsL( TCmGenConnSettings& aGenConnSettings ) - { - LOGGER_ENTERFN( "CCmManagerImpl::ReadGenConnSettingsL" ); - - OpenTransactionLC(); - CMDBRecordSet* defConnRecordSet = - new ( ELeave ) CMDBRecordSet( iDefConnTableId ); - CleanupStack::PushL( defConnRecordSet ); - - defConnRecordSet->LoadL( Session() ); - - TInt value = QUERY_INT_FIELD( defConnRecordSet->iRecords[0], KCDTIdUsageOfWlan ); - aGenConnSettings.iUsageOfWlan = TCmUsageOfWlan( value ); - - value = QUERY_INT_FIELD( defConnRecordSet->iRecords[0], KCDTIdCellularDataUsageHome ); - aGenConnSettings.iCellularDataUsageHome = TCmCellularDataUsage( value ); - - value = QUERY_INT_FIELD( defConnRecordSet->iRecords[0], KCDTIdCellularDataUsageVisitor ); - aGenConnSettings.iCellularDataUsageVisitor = TCmCellularDataUsage( value ); - - CleanupStack::PopAndDestroy( defConnRecordSet ); - RollbackTransaction(); - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::ReplaceGenConnSettingsL() -//----------------------------------------------------------------------------- -// -void CCmManagerImpl::ReplaceGenConnSettingsL( const TCmGenConnSettings& aGenConnSettings ) - { - - LOGGER_ENTERFN( "CCmManagerImpl::ReplaceGenConnSettingsL" ); - - TInt ret = KErrNone; - TCmDefConnValue defConn; - - defConn.iType = TCmDefConnType ( 0 ); - defConn.iId = 0; - - CMDBRecordSet* defConnRecordSet = - new ( ELeave ) CMDBRecordSet( iDefConnTableId ); - CleanupStack::PushL( defConnRecordSet ); - - TRAP(ret, defConnRecordSet->LoadL(Session())); - - if (ret == KErrNone) - { - TInt type = QUERY_INT_FIELD( defConnRecordSet->iRecords[0], KCDTIdDefConnType); - defConn.iType = TCmDefConnType( type ); - TInt id = QUERY_INT_FIELD( defConnRecordSet->iRecords[0], KCDTIdDefConnUid); - defConn.iId = id; - } - - TInt usageOfNewWlan = aGenConnSettings.iUsageOfWlan; - TInt cellularDataUsageHome = aGenConnSettings.iCellularDataUsageHome; - TInt cellularDataUsageVisitor = aGenConnSettings.iCellularDataUsageVisitor; - - // Delete the old record - for ( TInt i = 0; i < defConnRecordSet->iRecords.Count(); ++i ) - { - defConnRecordSet->iRecords[i]->DeleteL( Session() ); - } - CleanupStack::PopAndDestroy( defConnRecordSet ); - - CCDDefConnRecord* dcRcd = - new (ELeave) CCDDefConnRecord( iDefConnTableId ); - CleanupStack::PushL( dcRcd ); // 2 - - dcRcd->SetRecordId( KCDNewRecordRequest ); - - SET_INT_FIELD(dcRcd, KCDTIdDefConnType, defConn.iType); - SET_INT_FIELD(dcRcd, KCDTIdDefConnUid, defConn.iId); - - CLOG_WRITE_1( "Set wlan usage: [%d]", usageOfNewWlan ); - SET_INT_FIELD(dcRcd, KCDTIdUsageOfWlan, usageOfNewWlan ); - - CLOG_WRITE_1( "Set cellularDataUsageHome: [%d]", cellularDataUsageHome ); - SET_INT_FIELD(dcRcd, KCDTIdCellularDataUsageHome, cellularDataUsageHome ); - - CLOG_WRITE_1( "Set cellularDataUsageVisitor: [%d]", cellularDataUsageVisitor ); - SET_INT_FIELD(dcRcd, KCDTIdCellularDataUsageVisitor, cellularDataUsageVisitor ); - - dcRcd->StoreL( Session() ); - CleanupStack::PopAndDestroy( dcRcd ); - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::WriteGenConnSettingsL() -//----------------------------------------------------------------------------- -// -void CCmManagerImpl::WriteGenConnSettingsL( const TCmGenConnSettings& aGenConnSettings ) - { - LOGGER_ENTERFN( "CCmManagerImpl::WriteGenConnSettingsL" ); - - OpenTransactionLC(); - - ReplaceGenConnSettingsL( aGenConnSettings ); - CommitTransactionL( KErrNone ); - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::IsMemoryLow() -//----------------------------------------------------------------------------- -// -TBool CCmManagerImpl::IsMemoryLow() - { - LOGGER_ENTERFN( "CCmManagerImpl::IsMemoryLow" ); - - TBool ret( EFalse ); - // Any plugin can be used here, because CheckSpaceBelowCriticalLevelL - // is defined in their father class CCmPluginBaseEng - TRAPD( err, ret = (*iPlugins)[0]->CheckSpaceBelowCriticalLevelL() ); - if( err != KErrNone ) - { - ret = ETrue; - return ret; - } - return ret; - } - -// ----------------------------------------------------------------------------- -// CCmManagerImpl::SNAPRecordL -// ----------------------------------------------------------------------------- -CCDSnapRecord* CCmManagerImpl::SNAPRecordL( TUint32 aRecordId ) const - { - CCDSnapRecord* record = new (ELeave) CCDSnapRecord( - DestinationTableId() ); - - if( aRecordId ) - { - record->SetRecordId( aRecordId ); - - CleanupStack::PushL( record ); - record->LoadL( Session() ); - CleanupStack::Pop( record ); - } - - return record; - } - -// ----------------------------------------------------------------------------- -// CCmManagerImpl::SNAPRecordL -// ----------------------------------------------------------------------------- -CCDSnapRecord* CCmManagerImpl::CreateSNAPRecordL( TUint32 aRecordId ) const - { - CCDSnapRecord* record = new (ELeave) CCDSnapRecord( - DestinationTableId() ); - - if( aRecordId ) - { - record->SetRecordId( aRecordId ); - } - - return record; - } - -//----------------------------------------------------------------------------- -// CCmManagerImpl::WrapCmManager() -//----------------------------------------------------------------------------- -// -EXPORT_C void CCmManagerImpl::WrapCmManager( RCmManagerExt& aCmManagerExt ) - { - aCmManagerExt.iImplementation = this; - } - -// -------------------------------------------------------------------------- -// CCmManagerImpl::FilterOutVirtualsL -// -------------------------------------------------------------------------- -// -EXPORT_C void CCmManagerImpl::FilterOutVirtualsL( RPointerArray& aCmDataArray ) - { - LOGGER_ENTERFN( "CCmManagerImpl::FilterOutVirtualsL" ); - - for ( TInt i = 0; i < aCmDataArray.Count(); i++ ) - { - if ( aCmDataArray[i]->GetBoolAttributeL( ECmVirtual ) ) - { - delete aCmDataArray[i]; - aCmDataArray.Remove(i); - i--; - } - } - } - -// -------------------------------------------------------------------------- -// CCmManagerImpl::CreateFlatCMListLC -// -------------------------------------------------------------------------- -// -EXPORT_C void CCmManagerImpl::CreateFlatCMListLC( TUint32 aDestinationId , - RPointerArray& aCmArray ) - { - LOGGER_ENTERFN( "CCmManagerImpl::CreateFlatCMListLC" ); - - CreateFlatCMListL(aDestinationId, aCmArray); - CleanupResetAndDestroyPushL< RPointerArray >(aCmArray); - } - -// -------------------------------------------------------------------------- -// CCmManagerImpl::CreateFlatCMListL -// -------------------------------------------------------------------------- -// -EXPORT_C void CCmManagerImpl::CreateFlatCMListL( TUint32 aDestinationId , - RPointerArray& aCmArray ) - { - LOGGER_ENTERFN( "CCmManagerImpl::CreateFlatCMListL" ); - // get the uncategorised connection methods - if ( aDestinationId == KDestItemUncategorized ) - { - AppendUncatCmListLC( aCmArray); - } - else - { - // Get the CM ids from the destination - AppendCmListLC( aDestinationId, aCmArray ); - } - - // get the possible embedded destinations to be able to list their content, too - // we only have to check in cmArray - // put them in a sep. array and get their data into another. - RArray cmEmbDestArray ( KCmArrayMediumGranularity ); - CleanupClosePushL( cmEmbDestArray ); - for ( TInt i = 0; i < aCmArray.Count(); i++ ) - { - if ( aCmArray[i]->GetBoolAttributeL( ECmDestination ) ) - { - cmEmbDestArray.AppendL( aCmArray[i]->GetIntAttributeL( ECmId ) ); - //remove embedded destination right now - delete aCmArray[i]; - aCmArray.Remove(i); - i--; // Array gets re-indexed after calling Remove(). - } - } - // now we stored the needed emb.dest, - // we can filter out all virtual ones - //iCmManager.FilterOutVirtualsL( cmArray ); //no filtering here, we can do it later - - // now we have the list of emb.dest. inside current destination, - // now get their CM's data appended to one flat list - RPointerArray cmLinkedDataArray ( KCmArrayMediumGranularity ); - CleanupResetAndDestroyPushL< RPointerArray >( cmLinkedDataArray ); - TInt embdestcount = cmEmbDestArray.Count(); - for ( TInt i = 0; i < embdestcount; i++ ) - { - // get the list of CM's - CCmPluginBase* emdestcm = - GetConnectionMethodL( cmEmbDestArray[i] ); - CleanupStack::PushL( emdestcm ); - TUint destUid = emdestcm->Destination()->Id(); - AppendCmListL( destUid, cmLinkedDataArray ); - CleanupStack::PopAndDestroy( emdestcm ); - } - // filter out virtuals - //iCmManager.FilterOutVirtualsL( cmLinkedDataArray ); //still no filtering here - - // now we have the original, sorted list and an unsorted cmLinkedDataArray, - // add each element to original array with sorting - - CombineArraysForPriorityOrderL( aCmArray, cmLinkedDataArray ); - - // now we do no longer need the linked array - CleanupStack::Pop( &cmLinkedDataArray ); // don't destroy the cm objects! - - cmLinkedDataArray.Close(); // they are appended to aCmArray!!! - CleanupStack::PopAndDestroy( &cmEmbDestArray ); - - CleanupStack::Pop(&aCmArray); - } - -// -------------------------------------------------------------------------- -// CCmManagerImpl::CombineCmListsL -// -------------------------------------------------------------------------- -// -EXPORT_C void CCmManagerImpl::CombineArraysForPriorityOrderL( - RPointerArray& aCmArray , - RPointerArray& aCmLinkedArray ) - { - LOGGER_ENTERFN( "CCmManagerImpl::CombineArraysForPriorityOrderL" ); - - // now we have two arrays, the first is sorted as needed, - // the second is not. - // we have to insert the items from the second to the first into their - // correct position based on the bearer type priorities - - // so loop on the second array, and for ech element, find it's place - TInt count = aCmLinkedArray.Count(); - for ( TInt i = 0; i < count; i++ ) - { - TUint32 linkedpriority( aCmLinkedArray[i]->GetIntAttributeL( ECmDefaultPriority ) ); - // InsertItemL( aCmArray, aCmLinkedArray[i]); - // higher priority means smaller number - // if same priority elements exist, then - // - we need to insert our element inside the elements - // of the same priority according to - // bearetypes and extension levels - // or before the first element having higher priority numbers. - TInt cc = aCmArray.Count(); - if ( cc ) - { - TInt ii = 0; - for ( ; ii < cc; ii++ ) - { - if ( linkedpriority < aCmArray[ii]->GetIntAttributeL( ECmDefaultPriority ) ) - { - // the next element already has larger number, - // we must insert it HERE - break; - } - else - { - // priorities either same, then we need to check bearer, - // ext.level, etc - // or we simply still need to go to next element - if ( linkedpriority == aCmArray[ii]->GetIntAttributeL( ECmDefaultPriority )) - { - // check if the same bearer - if ( aCmArray[ii]->GetIntAttributeL( ECmBearerType ) == - aCmLinkedArray[i]->GetIntAttributeL( ECmBearerType ) ) - { - // we need to find the last one of these bearers, - // and insert after the last one - do - { - ii++; - }while ( ( ii < cc ) - && (aCmArray[ii]->GetIntAttributeL( ECmBearerType ) == - aCmLinkedArray[i]->GetIntAttributeL( ECmBearerType )) ); - // now we either found a correct place or - // we are at the end of the list - break; - } - else - { - // diff. bearers, check Ext.level - if ( aCmArray[ii]->GetIntAttributeL( ECmExtensionLevel ) < aCmLinkedArray[i]->GetIntAttributeL( ECmExtensionLevel ) ) - { - break; - } - // if not, then go for the next one... - } - } - } - } - // now we either found a correct place or - // we are at the end of the list - // ( we break-ed for cycle when found the correct place ) - if ( ii == cc ) - { - // end of the list, append - aCmArray.AppendL( aCmLinkedArray[i]); - } - else - { - // we found the place to be inserted - aCmArray.InsertL( aCmLinkedArray[i], ii ); - } - } - else - { - // no elements in original array yet, - // so simply append - aCmArray.AppendL( aCmLinkedArray[i]); - } - } - } - - -// -------------------------------------------------------------------------- -// CCmManagerImpl::ParentDestinationL -// -------------------------------------------------------------------------- -// -TUint32 CCmManagerImpl::ParentDestinationL( TUint32 aCmId ) - { - LOGGER_ENTERFN( "CCmManagerImpl::ParentDestinationL" ); - - TUint32 retval(0); - - TUint32 destTblId = DestinationTableId(); - CMDBRecordSet* ptrRecordSet = - new (ELeave) CMDBRecordSet( - destTblId ); - CleanupStack::PushL( ptrRecordSet ); - - // Prime record - CCDDataMobilitySelectionPolicyRecord* record = - new (ELeave) CCDDataMobilitySelectionPolicyRecord( - DestinationTableId() ); - CleanupStack::PushL( record ); - - record->iIAP = IAP_ELEMENT_ID( aCmId ); - ptrRecordSet->iRecords.AppendL( record ); - - CleanupStack::Pop( record ); - record = NULL; - - if ( ptrRecordSet->FindL(Session()) ) - { - // we have a match - retval = QUERY_INT_FIELD( (*ptrRecordSet)[0], - KCDTIdDataMobilitySelectionPolicyNetwork ); - - } - CleanupStack::PopAndDestroy( ptrRecordSet ); - - return retval; - } - -// -------------------------------------------------------------------------- -// CCmManagerImpl::GetInternetDestinationIdL -// -------------------------------------------------------------------------- -// -TUint32 CCmManagerImpl::GetInternetDestinationIdL() - { - - LOGGER_ENTERFN( "CCmManagerImpl::GetInternetDestinationIdL" ); - - TUint32 destId = 0; - - // Get all destinations - RArray destIdArray( KCmArrayBigGranularity ); - AllDestinationsL( destIdArray ); - CleanupClosePushL( destIdArray ); - - CCmDestinationImpl* dest = NULL; - - for ( TInt i = 0; i < destIdArray.Count(); i++ ) - { - dest = DestinationL( destIdArray[i] ); - CleanupStack::PushL( dest ); - - // Check if destination is internet - if ( dest->MetadataL(ESnapMetadataInternet) ) - { - destId = destIdArray[i]; - } - - CleanupStack::PopAndDestroy( dest ); - - if ( destId ) - { - break; - } - } - - CleanupStack::PopAndDestroy( &destIdArray ); - - return destId; - } - -// ----------------------------------------------------------------------------- -// CCmManagerImpl::SetGenConnSettingsToDefault() -// ----------------------------------------------------------------------------- -// -void CCmManagerImpl::SetGenConnSettingsToDefault( TCmGenConnSettings& aGenConnSettings ) - { - LOGGER_ENTERFN( "CCmManagerImpl::SetGenConnSettingsToDefault" ); - - aGenConnSettings.iUsageOfWlan = ECmUsageOfWlanKnown; - aGenConnSettings.iCellularDataUsageHome = ECmCellularDataUsageAutomatic; - aGenConnSettings.iCellularDataUsageVisitor = ECmCellularDataUsageConfirm; - } - - -// ----------------------------------------------------------------------------- -// CCmManagerImpl::CheckAvailableSpaceL() -// ----------------------------------------------------------------------------- -// -void CCmManagerImpl::CheckAvailableSpaceL() - { - LOGGER_ENTERFN( "CCmManagerImpl::CheckAvailableSpaceL" ); - TBool belowCritical = SysUtil::FFSSpaceBelowCriticalLevelL( &(this->iFs), KBytesToWrite ); - CLOG_WRITE_1( "belowCritical: [%d]", belowCritical ); - if ( belowCritical ) - { - User::Leave( KErrDiskFull ); - } - } - - -// -------------------------------------------------------------------------- -// CCmManagerImpl::WatcherRegisterL -// -------------------------------------------------------------------------- -// -EXPORT_C void CCmManagerImpl::WatcherRegisterL( MCmCommsDatWatcher* aWatcher ) - { - iCommsDatIapNotifier->WatcherRegisterL( aWatcher ); - iCommsDatSnapNotifier->WatcherRegisterL( aWatcher ); - } - -// -------------------------------------------------------------------------- -// CCmManagerImpl::WatcherUnRegister -// -------------------------------------------------------------------------- -// -EXPORT_C void CCmManagerImpl::WatcherUnRegister() - { - iCommsDatIapNotifier->WatcherUnRegister(); - iCommsDatSnapNotifier->WatcherUnRegister(); - } - -// -------------------------------------------------------------------------- -// CCmManagerImpl::DestinationStillExistedL -// -------------------------------------------------------------------------- -// -EXPORT_C TBool CCmManagerImpl::DestinationStillExistedL( CCmDestinationImpl* aDest ) - { - TUint32 destId = aDest->Id(); - TBool found( EFalse ); - TInt count; - - OpenTransactionLC(); - - CMDBRecordSet* destRecordSet = - new ( ELeave ) CMDBRecordSet( - iDestinationTableId ); - CleanupStack::PushL( destRecordSet ); - - TRAP_IGNORE( destRecordSet->LoadL( Session() ) ); - - count = destRecordSet->iRecords.Count(); - - for ( TInt i = 0; i < count; ++i ) - { - TInt nwId = QUERY_INT_FIELD( destRecordSet->iRecords[i], - KCDTIdDataMobilitySelectionPolicyNetwork ); - //nwId = RECORD_FROM_ELEMENT_ID( nwId ); - - if( nwId == destId ) - { - found = ETrue; - break; - } - } - - CleanupStack::PopAndDestroy( destRecordSet ); - - RollbackTransaction(); - - return found; - } - -// -------------------------------------------------------------------------- -// CCmManagerImpl::IapStillExistedL -// -------------------------------------------------------------------------- -// -EXPORT_C TBool CCmManagerImpl::IapStillExistedL( const CCmPluginBaseEng& aPlugin ) - { - TUint32 iapId = aPlugin.GetIntAttributeL( ECmId ); - CMDBRecordSet* ptrRecordSet = AllIapsL(); - CleanupStack::PushL( ptrRecordSet ); - - TInt iapRecords = ptrRecordSet->iRecords.Count(); - - TBool found( EFalse ); - for ( TInt i = 0; !found && i < iapRecords; i++ ) - { - CCDIAPRecord* iapRecord = (*ptrRecordSet)[i]; - - if( iapRecord->RecordId() == iapId ) - { - found = ETrue; - break; - } - } - - CleanupStack::PopAndDestroy( ptrRecordSet ); - - return found; - } - -// -------------------------------------------------------------------------- -// CCmManagerImpl::IsIapStillInDestL -// -------------------------------------------------------------------------- -// -EXPORT_C TBool CCmManagerImpl::IsIapStillInDestL( - CCmDestinationImpl* aDest, - const CCmPluginBaseEng& aPlugin ) - { - TUint32 iapId = aPlugin.GetIntAttributeL( ECmId ); - - aDest->ReLoadConnectionMethodsL(); - RArray cmIds; - aDest->ConnectMethodIdArrayL( cmIds ); - CleanupClosePushL( cmIds ); - - TBool found( EFalse ); - for ( TInt i = 0; i < cmIds.Count(); i++ ) - { - if( cmIds[i] == iapId ) - { - found = ETrue; - break; - } - } - - CleanupStack::PopAndDestroy( &cmIds ); - - return found; - } - -// -------------------------------------------------------------------------- -// CCmManagerImpl::GetSnapTableIdL -// -------------------------------------------------------------------------- -// -TUint32 CCmManagerImpl::GetSnapTableIdL() - { - TUint32 snapTableId; - - CMDBSession* db = CMDBSession::NewLC( CMDBSession::LatestVersion() ); - db->SetAttributeMask( ECDHidden | ECDProtectedWrite ); - - snapTableId = CCDDataMobilitySelectionPolicyRecord::TableIdL( *db ); - - CleanupStack::PopAndDestroy( db ); - - return snapTableId; - } - -// ----------------------------------------------------------------------------- -// CCmManagerImpl::IsBearerSpecific() -// ----------------------------------------------------------------------------- -// -TBool CCmManagerImpl::IsBearerSpecific( TUint32 aAttribute ) const - { - TUint32 i = 0; - while( KBearerSpecificAttributes[i] != KEndOfArray ) - { - if( KBearerSpecificAttributes[i] == aAttribute ) - { - return ETrue; - } - i++; - } - return EFalse; - }