diff -r 05bc53fe583b -r 83ca720e2b9a cmmanager/cmmgr/Framework/Src/cmconnsettingsuiimpl.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/cmmanager/cmmgr/Framework/Src/cmconnsettingsuiimpl.cpp Wed Sep 01 12:23:51 2010 +0100 @@ -0,0 +1,1163 @@ +/* +* 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 application setting UI. +* +*/ + +#include +#include +#include +#include +#include +#include +#include + + +#include +#include "cmapplicationsettingsui.h" +#include +#include "cmmanagerimpl.h" +#include "cmdestinationimpl.h" +#include "cmmanagerimpl.h" +#include +#include +#include "cmconnsettingsuiimpl.h" +#include "cmconnselectrbpage.h" + +using namespace CMManager; + +typedef struct + { + TInt iCmIapId; + TInt iCmDefaultPriority; + }TCmListItem; + +//--------------------------------------------------------------------------- +// CCmConnSettingsUiImpl::NewL +//--------------------------------------------------------------------------- +// +EXPORT_C CCmConnSettingsUiImpl* CCmConnSettingsUiImpl::NewL( CCmManagerImpl* aCCmManagerImpl ) + { + CCmConnSettingsUiImpl* self = + new (ELeave) CCmConnSettingsUiImpl(); + CleanupStack::PushL( self ); + self->ConstructL( aCCmManagerImpl ); + CleanupStack::Pop( self ); // self + return self; + } + +//--------------------------------------------------------------------------- +// CCmConnSettingsUiImpl::NewL +//--------------------------------------------------------------------------- +// +CCmConnSettingsUiImpl* CCmConnSettingsUiImpl::NewWithoutTablesL() + { + CCmConnSettingsUiImpl* self = + new (ELeave) CCmConnSettingsUiImpl(); + CleanupStack::PushL( self ); + self->iCreateTables = EFalse; + self->ConstructL( NULL ); + CleanupStack::Pop( self ); // self + return self; + } + +//--------------------------------------------------------------------------- +// CCmConnSettingsUiImpl::TCmDCSettingSelection +//--------------------------------------------------------------------------- +// +CCmConnSettingsUiImpl::CCmConnSettingsUiImpl() + : iResourceReader( *CCoeEnv::Static() ) + , iAreDestinations ( ETrue ) + , iShowAlwaysAsk( EFalse ) + , iShowEasyWlan( EFalse ) + , iShowVirtualCMs( ETrue ) + , iShowEmptyDestinations( EFalse ) + , iShowAskOnce( EFalse ) + , iShowUncat( EFalse ) + , iShowDefConn( EFalse ) + , iUsePassedDestinationArray( EFalse ) + , iHelpContext ( KSET_HLP_APP_DEST_ASSOC_VIEW ) + , iCreateTables( ETrue ) + { + } + +//--------------------------------------------------------------------------- +// CCmConnSettingsUiImpl::~TCmDCSettingSelection +//--------------------------------------------------------------------------- +// +CCmConnSettingsUiImpl::~CCmConnSettingsUiImpl() + { + if ( iOwnCmManager ) + { + delete iCmManagerImpl; + } + iResourceReader.Close(); + iItems.Close(); + iPassedDestinations.Close(); + } + +//--------------------------------------------------------------------------- +// CCmConnSettingsUiImpl::LoadResourceL +// Load the resource for the dll module +//--------------------------------------------------------------------------- +// +TInt CCmConnSettingsUiImpl::LoadResourceL () + { + // Add resource file. + TParse* fp = new(ELeave) TParse(); + TInt err = fp->Set( KACMManagerResDirAndFileName, + &KDC_RESOURCE_FILES_DIR, + NULL ); + if ( err != KErrNone) + { + User::Leave( err ); + } + + TFileName resourceFileNameBuf = fp->FullName(); + delete fp; + + iResourceReader.OpenL( resourceFileNameBuf ); + return err; + } + +//--------------------------------------------------------------------------- +// CCmConnSettingsUiImpl::ConstructL() +//--------------------------------------------------------------------------- +// +void CCmConnSettingsUiImpl::ConstructL( CCmManagerImpl* aCCmManagerImpl ) + { + iOwnCmManager = !(aCCmManagerImpl); + if ( iOwnCmManager ) + { + if (iCreateTables) + { + iCmManagerImpl = CCmManagerImpl::NewL(); + } + else + { + iCmManagerImpl = CCmManagerImpl::NewL(EFalse); + } + } + else + { + iCmManagerImpl = aCCmManagerImpl; + } + LoadResourceL(); + AknsUtils::SetAvkonSkinEnabledL( ETrue ); + } + +//--------------------------------------------------------------------------- +// CCmConnSettingsUiImpl::ShowConnSelectRadioPageL +//--------------------------------------------------------------------------- +// +TBool CCmConnSettingsUiImpl::ShowConnSelectRadioPageL( + TCmDCSettingSelection& aSelection, + const TInt aTitleStringResource, + TBearerFilterArray& aFilterArray ) + { + TBool retVal( EFalse ); +// aSelection.iResult = EDCAlwaysAsk; + + CDesCArrayFlat* items = + new ( ELeave ) CDesCArrayFlat( KCmArrayBigGranularity ); + CleanupStack::PushL( items ); + + if (iAreDestinations) + { + BuildDestinationArrayL( items, aFilterArray ); + } + else + { + BuildCMArrayL( items, aFilterArray ); + + } + // Uncategorized connection methods + RPointerArray uncatArray( KCmArraySmallGranularity ); + CCmManagerImpl::CleanupResetAndDestroyPushL< RPointerArray >( uncatArray ); + if ( iShowUncat ) + { + BuildUncatArrayL( uncatArray, items, + aFilterArray); + } + //appending items in reverse order of priority + // Check if Ask Once should be shown + if ( iShowAskOnce ) + { + HBufC* buf = StringLoader::LoadLC( R_CMMANAGERUI_SETT_ASK_ONCE ); + items->InsertL( 0, *buf ); + iItems.InsertL( KDestItemAskOnce, 0 ); + CleanupStack::PopAndDestroy( buf ); + } + + // Check if Always Ask should be shown + if ( iShowAlwaysAsk ) + { + HBufC* buf = StringLoader::LoadLC( R_CMMANAGERUI_SETT_ALWAYS_ASK ); + items->InsertL( 0, *buf ); + iItems.InsertL( KDestItemAlwaysAsk, 0 ); + CleanupStack::PopAndDestroy( buf ); + } + // Check if Default Connection should be shown + //feautre flag + if ( iCmManagerImpl->IsDefConnSupported() ) + { + //client's selection + if ( iShowDefConn ) + { + HBufC* buf = StringLoader::LoadLC( R_CMMANAGERUI_SETT_DEFAULT_CONNECTION ); + items->InsertL( 0, *buf ); + iItems.InsertL( KDestItemDefaultConnection, 0 ); + CleanupStack::PopAndDestroy( buf ); + } + } + if (!items->Count()) + { + User::Leave(KErrConnectionNotFound); + } + + TInt listIndex(0); + + if (iAreDestinations) + { + switch ( aSelection.iResult ) + { + case EDCDestination: + { + TInt newIndex = iItems.Find(aSelection.iId); + if (newIndex >=0) + { + listIndex = newIndex; + } + break; + } + case EDCConnectionMethod: + { + TInt err(KErrNotFound); + CCmPluginBase* cm = NULL; + TRAP( err, cm = iCmManagerImpl->GetConnectionMethodL(aSelection.iId)); + if ( err == KErrNone ) + { + // connection method is valid + CleanupStack::PushL( cm ); + TUint32 parentId = 0; + CCmDestinationImpl* parent = cm->ParentDestination(); + if (parent) + { + // it has a parent, get it's id + parentId = parent->Id(); + delete parent; + } + else + { + // no parent means Uncategorised + parentId = KDestItemUncategorized; + } + // get the index based on id + TInt tempIndex = iItems.Find( parentId ); + if ( tempIndex != KErrNotFound ) + { + // found destination id in list + listIndex = tempIndex; + } + CleanupStack::PopAndDestroy( cm ); + } + break; + } + case EDCDefaultConnection: + { + TInt newIndex = iItems.Find(KDestItemDefaultConnection); + if (newIndex >=0) + { + listIndex = newIndex; + } + break; + } + case EDCAlwaysAsk: + { + TInt newIndex = iItems.Find(KDestItemAlwaysAsk); + if (newIndex >=0) + { + listIndex = newIndex; + } + break; + } + case EDCAskOnce: + { + TInt newIndex = iItems.Find(KDestItemAskOnce); + if (newIndex >=0) + { + listIndex = newIndex; + } + break; + } + default: // use default value (0) + { + break; + } + } + } + else + { + if (aSelection.iResult == EDCConnectionMethod) + { + TInt newIndex = iItems.Find(aSelection.iId); + if (newIndex >=0) + { + listIndex = newIndex; + } + } + } + + if ( aTitleStringResource == R_CMMANAGERUI_DEFAULT_CONNECTION_TITLE ) + { + // It is not allowed to choose Connection Methods + // in Default connection -dialog. + // + iOpenDestination = EFalse; + } + + if ( UserSelectionDlgL( listIndex, items, aSelection, + aTitleStringResource, + iOpenDestination) ) + { + // Handle selection + + switch ( aSelection.iResult ) + { + case EDCConnectionMethod: + { + // from the first list? + if (!iAreDestinations) + { + aSelection.iId = iItems[listIndex]; + retVal = ETrue; + } + else + { + // Uncategorised? + TUint32 destId = iItems[ listIndex ]; + if ( destId == KDestItemUncategorized ) + { + TBearerFilterArray emptyFilter; + retVal = ShowConnectionMethodsL( uncatArray, + aSelection, aTitleStringResource, emptyFilter ); + } + else + { + RPointerArray cmArray ( KCmArrayMediumGranularity ); + if ( iShowVirtualCMs ) //create a flat list to show cms in embedded destinations + { + iCmManagerImpl->CreateFlatCMListLC( destId, cmArray); + } + else + { + //append only the cms in the destination + iCmManagerImpl->AppendCmListLC( destId, cmArray ); + } + retVal = ShowConnectionMethodsL( cmArray, + aSelection, aTitleStringResource, + aFilterArray ); + CleanupStack::PopAndDestroy( &cmArray ); + } + } + break; + } + case EDCDestination: + { + // Store the destination Id + aSelection.iId = iItems[listIndex]; + retVal = ETrue; + break; + } + case EDCAlwaysAsk: + { + // nothing more to do + retVal = ETrue; + break; + } + case EDCDefaultConnection: + { + // nothing more to do + retVal = ETrue; + break; + } + case EDCAskOnce: + { + // nothing more to do + retVal = ETrue; + break; + } + default: + { + break; + } + } + } + + CleanupStack::PopAndDestroy( &uncatArray ); + CleanupStack::PopAndDestroy( items ); + + return retVal; + } + + +//--------------------------------------------------------------------------- +// CCmConnSettingsUiImpl::RunSettingsL() +//--------------------------------------------------------------------------- +// +EXPORT_C TBool CCmConnSettingsUiImpl::RunApplicationSettingsL( + TCmSettingSelection& aSelection, + TUint aListItems, + TBearerFilterArray& aFilterArray) + { + iItems.Close(); + iAreDestinations = ETrue; + if (!aListItems) + { + User::Leave(KErrArgument); + } + if ( !iCmManagerImpl->IsDefConnSupported() && + !(aListItems & EShowAlwaysAsk) && + !(aListItems & EShowConnectionMethods) && + !(aListItems & EShowDestinations) + ) + { + // default conn would be the only one but not supported + User::Leave(KErrNotSupported); + } + + if ( aListItems & EShowDefaultConnection ) + { + EnableDefConn( ETrue ); + } + else + { + EnableDefConn( EFalse ); + } + if (aListItems & EShowAlwaysAsk) + { + EnableAlwaysAsk( ETrue ); + } + else + { + EnableAlwaysAsk( EFalse ); + } + if ( (aListItems & EShowConnectionMethods) && (aListItems & EShowDestinations) ) + { + iOpenDestination = ETrue; + iShowUncat = ETrue; + } + else + { + iOpenDestination = EFalse; + } + if ( (aListItems & EShowConnectionMethods) && !(aListItems & EShowDestinations) ) + { + iAreDestinations = EFalse; + GetCMArrayL( ); + } + else if ( aListItems & EShowDestinations ) + { + if (iUsePassedDestinationArray) + { + // now fill up iItems + for( TInt i=0; iAllDestinationsL( iItems ); + TInt i( 0 ); + TInt count = iItems.Count(); + for ( i=0; i < count; i++ ) + { + if ( iItems[i] > 0 && iItems[i] < 255 ) + { + CCmDestinationImpl* dest = + iCmManagerImpl->DestinationL( iItems[i] ); + CleanupStack::PushL( dest ); + if ( dest->IsHidden() ) + { + iItems.Remove(i); + i--; + count = count-1; + } + CleanupStack::PopAndDestroy(); + } + } + iItems.Compress(); + } + } + + TBool ret = EFalse; + TCmDCSettingSelection userDefSelection; + + // convert selection + switch ( aSelection.iResult ) + { + case EDestination: + { + userDefSelection.iResult = EDCDestination; + userDefSelection.iId = aSelection.iId; + break; + } + + case EConnectionMethod: + { + userDefSelection.iResult = EDCConnectionMethod; + userDefSelection.iId = aSelection.iId; + break; + } + + case EDefaultConnection: + { + userDefSelection.iResult = EDCDefaultConnection; + userDefSelection.iId = 0; + break; + } + + case EAlwaysAsk: + { + userDefSelection.iResult = EDCAlwaysAsk; + userDefSelection.iId = 0; + break; + } + + default: + { + // do not leave, perhaps there was no default selection + } + } + + + + if ( ShowConnSelectRadioPageL( userDefSelection, + R_CMMANAGERUI_SETT_DESTINATION , aFilterArray)) + { + switch ( userDefSelection.iResult ) + { + case EDCDestination: + { + aSelection.iResult = EDestination; + aSelection.iId = userDefSelection.iId; + break; + } + case EDCConnectionMethod: + { + aSelection.iResult = EConnectionMethod; + aSelection.iId = userDefSelection.iId; + break; + } + case EDCDefaultConnection: + { + aSelection.iResult = EDefaultConnection; + aSelection.iId = 0; + break; + } + case EDCAlwaysAsk: + { + aSelection.iResult = EAlwaysAsk; + aSelection.iId = 0; + break; + } + default: //should not ever get here, unhandled branch + { + User::Leave( KErrGeneral ); + break; + } + } + ret = ETrue; + } + else + { + ret = EFalse; + } + return ret; + } + + +//--------------------------------------------------------------------------- +// CCmConnSettingsUiImpl::RunDefaultConnecitonRBPageL() +//--------------------------------------------------------------------------- +// +TBool CCmConnSettingsUiImpl::RunDefaultConnecitonRBPageL( + TCmDCSettingSelection& aSelection ) + { + iHelpContext = KSET_HLP_DEFAULT_CONN; + iItems.Close(); + iOpenDestination = ETrue; + iCmManagerImpl->AllDestinationsL( iItems ); + EnableAlwaysAsk( EFalse ); + EnableAskOnce( EFalse ); + EnableUncat( EFalse ); + TBearerFilterArray aFilterArray; + iAreDestinations = ETrue; + iShowEmptyDestinations = ETrue; + return ShowConnSelectRadioPageL( aSelection , + R_CMMANAGERUI_DEFAULT_CONNECTION_TITLE, aFilterArray ); + } +//--------------------------------------------------------------------------- +// CCmConnSettingsUiImpl::GetCMArrayL() +//--------------------------------------------------------------------------- +// +void CCmConnSettingsUiImpl::GetCMArrayL( ) + { + iCmManagerImpl->ConnectionMethodL( iItems, ETrue, EFalse,EFalse, ETrue ); + TInt count = iItems.Count(); + + if ( !iShowVirtualCMs ) + { + // Don't show virtual CMs + for ( TInt i = 0; i < count; i++ ) + { + if ( IsCmVirtualL( iItems[i] ) ) + { + iItems.Remove( i ); + count--; + i--; + } + } + } + } + +//--------------------------------------------------------------------------- +// CCmConnSettingsUiImpl::BuildCMArrayL() +//--------------------------------------------------------------------------- +// +void CCmConnSettingsUiImpl::BuildCMArrayL( CDesCArrayFlat* aItems, + TBearerFilterArray& aFilterArray ) + { + // Add the New Connection Item + for ( TInt i = 0; i < iItems.Count(); i++ ) + { + CCmPluginBase* cm = NULL; + TInt err(KErrNone); + TRAP( err, cm = iCmManagerImpl->GetConnectionMethodL(iItems[i])); + if (err == KErrNoMemory) + { + User::Leave(KErrNoMemory); + } + else if (err != KErrNone) + { + continue; + } + CleanupStack::PushL( cm ); + if (aFilterArray.Count()) + { + TUint cmBearerType = cm->GetIntAttributeL( ECmBearerType ); + if ( aFilterArray.Find( cmBearerType ) == KErrNotFound ) + { + CleanupStack::PopAndDestroy( cm ); + iItems.Remove(i); + i--; + continue; + } + } + // CM Iap Id + TUint32 cmId = cm->GetIntAttributeL( ECmId ); + + // Should virtual bearer types be shown? + if ( iShowVirtualCMs || !IsCmVirtualL( cmId ) ) + { + // CM name + HBufC* cmName = cm->GetStringAttributeL( ECmName ); + CleanupStack::PushL( cmName ); + // embedded destination has a special text format + aItems->AppendL( *cmName ); + CleanupStack::PopAndDestroy( cmName ); + } + CleanupStack::PopAndDestroy( cm ); + } + } + +//--------------------------------------------------------------------------- +// CCmConnSettingsUiImpl::BuildDestinationArray() +//--------------------------------------------------------------------------- +// +void CCmConnSettingsUiImpl::BuildDestinationArrayL( CDesCArrayFlat* aItems, + TBearerFilterArray& aFilterArray ) + { + /* + * The behavior of this function is as follow. + * 1. If aFilterArray.Count() == 0 (This just means no filter provided by user) then the function will + * show all of available destinations (if iShowVirtualCMs == ETrue; Otherwise, destination with only + * virtualCMs will be filted out) (default). + * 2. If aFilterArray.Count() != 0 then destination with only unavailable bearer-type IAPs will be + * filted out. + */ + TInt count = iItems.Count(); + // Add the New Connection Item + for ( TInt i = 0; i < count; i++ ) + { + // Get the destinations from their IDs + CCmDestinationImpl* dest = + iCmManagerImpl->DestinationL( iItems[i] ); + CleanupStack::PushL( dest ); + + TInt cmCount = dest->ConnectionMethodCount(); + TInt validCmCount = cmCount; + + if ( !iUsePassedDestinationArray ) + { + // Check if empty destinations should be displayed + if ( !iShowVirtualCMs || aFilterArray.Count()) + { + for ( TInt j = 0; j < cmCount; j++ ) + { + CCmPluginBase& cm = *dest->GetConnectionMethodL(j); + // check if this destination only contains virtual CMs + if (!iShowVirtualCMs)// See if the virtual CM (Default in case no filter provided by user) + { + // CM Iap Id + TUint32 cmIapId = cm.GetIntAttributeL( ECmId ); + // real CMs were found + if ( IsCmVirtualL( cmIapId ) ) + { + validCmCount--; + continue; + } + // We can not break the loop with else case here + // for cm might be filted out by aFilterArray + } + + if (aFilterArray.Count()) // See if the CM is filtered out + { + TUint cmBearerType = cm.GetIntAttributeL( ECmBearerType ); + if ( aFilterArray.Find( cmBearerType ) == KErrNotFound ) + { + validCmCount--; + } + else + { + break;//there is at least one CM in this dest + } + } + } + } + } + + // check if the destination should be omitted + // check if empty destinations should be displayed + + // We can use a destination to make a connection only + // if it contains something else than an empty embedded + // destination. Otherwise, consider it empty. + TBool canUseDestToConnect = dest->CanUseToConnectL(); + + if ( iDestinationToOmit != iItems[i] && + ( ( validCmCount && canUseDestToConnect ) + || iShowEmptyDestinations ) ) + { + // Check whether the MMS SNAP is in question. + // It should not be shown on the UI in the destinations list + TInt snapMetadata = 0; + TRAPD( metaErr, snapMetadata = dest->MetadataL( CMManager::ESnapMetadataPurpose )); + if ( metaErr == KErrNone && snapMetadata == CMManager::ESnapPurposeMMS ) + { + iItems.Remove(i); + count--; + i--; + } + else + { + HBufC* destName = dest->NameLC(); + + aItems->AppendL( *destName ); + CleanupStack::PopAndDestroy( destName ); + } + } + else + { + iItems.Remove(i); + count--; + i--; + } + + CleanupStack::PopAndDestroy( dest ); + } + } + +//--------------------------------------------------------------------------- +// CCmConnSettingsUiImpl::BuildUncatArrayL() +//--------------------------------------------------------------------------- +// +void CCmConnSettingsUiImpl::BuildUncatArrayL( RPointerArray& aUncatArray, + CDesCArrayFlat* aItems, + TBearerFilterArray& aFilterArray ) + { + if ( iShowEasyWlan ) + { + // Get the uncategorised CMs including EasyWLAN + iCmManagerImpl->AppendUncatCmListL( aUncatArray, ETrue, ETrue, ETrue ); + } + else + { + iCmManagerImpl->AppendUncatCmListL( aUncatArray ); + } + + // Remove hidden Connection Methods + for ( TInt i = 0; i < aUncatArray.Count(); i++ ) + { + if ( aUncatArray[i]->GetBoolAttributeL( ECmHidden ) ) + { + delete aUncatArray[i]; + aUncatArray.Remove(i); + i--; + } + } + + if (aFilterArray.Count()) + { + for ( TInt i = 0; i < aUncatArray.Count(); i++ ) + { + CCmPluginBase* cm = aUncatArray[i]; + TUint cmBearerType = cm->GetIntAttributeL( ECmBearerType ); + if ( aFilterArray.Find( cmBearerType ) == KErrNotFound ) + { + delete aUncatArray[i]; + aUncatArray.Remove(i); + i--; + } + } + } + TInt count = aUncatArray.Count(); + + if ( !iShowVirtualCMs ) + { + // Don't show virtual CMs + for ( TInt i = 0; i < count; i++ ) + { + if ( IsCmVirtualL( aUncatArray[i]->GetIntAttributeL( ECmId ) ) ) + { + delete aUncatArray[i]; + aUncatArray.Remove( i ); + count--; + i--; + } + } + } + // Show the 'Uncategorised' destination + if ( count ) + { + HBufC* buf = StringLoader::LoadLC( R_CMMANAGERUI_DEST_UNCATEGORIZED ); + aItems->AppendL( *buf ); + CleanupStack::PopAndDestroy( buf ); + iItems.AppendL( KDestItemUncategorized ); + } + } + +//--------------------------------------------------------------------------- +// CCmConnSettingsUiImpl::UserSelectionDlgL() +//--------------------------------------------------------------------------- +// +TBool CCmConnSettingsUiImpl::UserSelectionDlgL( + TInt& aDestSelected, + CDesCArrayFlat* aItems, + TCmDCSettingSelection& aSelection, + const TInt aTitleStringResource, + TBool aOpenDestination) + { + // Should an item be highlighted? + if ( aSelection.iResult == EDCDestination ) + { + for ( TInt i = 0; i < iItems.Count(); i++ ) + { + if ( iItems[i] == aSelection.iId ) + { + aDestSelected = i; + } + } + } + + HBufC* buf = StringLoader::LoadLC( aTitleStringResource ); + TInt dialogResourceId = R_RADIO_BUTTON_SETTING_PAGE_OK_CANCEL; + if ( aOpenDestination ) // OPTIONS/CANCEL is available only if we can open + //destinations + { + dialogResourceId = R_RADIO_BUTTON_SETTING_PAGE; + } + CCMConnSelectRBPage* page = + new ( ELeave ) CCMConnSelectRBPage( dialogResourceId, + aDestSelected, + aItems, + *iCmManagerImpl, + aSelection.iResult, + iItems, + iAreDestinations, + aOpenDestination , + iHelpContext ); + CleanupStack::PushL( page ); + page->SetSettingTextL( *buf ); + CleanupStack::Pop( page ); + + CleanupStack::PopAndDestroy( buf ); + buf = NULL; + + return page->ExecuteLD( CAknSettingPage::EUpdateWhenChanged ); + } + +//--------------------------------------------------------------------------- +// CCmConnSettingsUiImpl::UserSelectedUncatItemL() +//--------------------------------------------------------------------------- +// +TBool CCmConnSettingsUiImpl::UserSelectedUncatItemL( + RPointerArray& aUncatArray, + TCmDCSettingSelection& aSelection, + const TInt aTitleStringResource ) + { + TBool retVal( EFalse ); + CDesCArrayFlat* items = + new ( ELeave ) CDesCArrayFlat( KCmArrayBigGranularity ); + CleanupStack::PushL( items ); + + TInt cmSelected( 0 ); + + TInt count = aUncatArray.Count(); + for ( TInt i = 0; i < count; ++i ) + { + CCmPluginBase* cm = NULL; + TRAPD( err, + cm = iCmManagerImpl->GetConnectionMethodL( aUncatArray[i]->GetIntAttributeL( ECmId) ) + ); + + if ( !err ) + { + CleanupStack::PushL( cm ); + HBufC* cmName = cm->GetStringAttributeL( ECmName ); + CleanupStack::PushL( cmName ); + items->AppendL( *cmName ); + + // Virtual CMs have underlying CMs, highlight + if ( cm->GetBoolAttributeL( ECmVirtual ) ) + { + TUint32 iapId (0); + iapId = cm->GetIntAttributeL( ECmNextLayerIapId ); + if ( iapId && iapId == aSelection.iId ) + { + cmSelected = i; + } + } + CleanupStack::PopAndDestroy( 2, cm ); + } + else + { + //not handled iap, remove from list + aUncatArray.Remove( i ); + count--; + i--; + } + } + + + CAknRadioButtonSettingPage* rbPage = + new ( ELeave ) CAknRadioButtonSettingPage( + R_RADIO_BUTTON_SETTING_PAGE_OK_CANCEL, + cmSelected, + items ); + CleanupStack::PushL( rbPage ); + + HBufC* buf = StringLoader::LoadLC( aTitleStringResource ); + rbPage->SetSettingTextL( *buf ); + CleanupStack::PopAndDestroy( buf ); + + if ( rbPage->ExecuteLD( CAknSettingPage::EUpdateWhenChanged ) ) + { + CCmPluginBase* cm = + iCmManagerImpl->GetConnectionMethodL( aUncatArray[cmSelected]->GetIntAttributeL( ECmId) ); + + // ECmIapId can be surely queried here. It won't leave, but PushL to be + // on the safe side + CleanupStack::PushL( cm ); + aSelection.iId = cm->GetIntAttributeL( ECmId ); + CleanupStack::PopAndDestroy( cm ); + + aSelection.iResult = EDCConnectionMethod; + + retVal = ETrue; + } + CleanupStack::Pop( rbPage ); + CleanupStack::PopAndDestroy( items ); + + return retVal; + } + + +//--------------------------------------------------------------------------- +// CCmConnSettingsUiImpl::ShowConnectionMethodsL() +//--------------------------------------------------------------------------- +// +TBool CCmConnSettingsUiImpl::ShowConnectionMethodsL( + RPointerArray& aCmArray, TCmDCSettingSelection& aSelection, + const TInt aTitleStringResource, + TBearerFilterArray& aFilterArray ) + { + TInt retVal ( EFalse ); + + // List texts + CDesCArrayFlat* items = + new ( ELeave ) CDesCArrayFlat( KCmArrayMediumGranularity ); + CleanupStack::PushL( items ); + + // keeps track of the CMs in the list + + // idArray is used to put valid IAP ID. + // aFilterArray might filt some of IAPs (e.g., virtual IAPs) out. In this case, + // aCmArray can not be used to select IAP. So, idArray may be used for IAP selection + // for it only stores valid IAPs (i.e., not filted-out IAPs). + RArray idArray; + TInt cmSelected( 0 ); + TInt j( 0 ); + + // Collect item texts + TInt cmCount = aCmArray.Count(); + for ( TInt i = 0; i < cmCount; i++ ) + { + // CM info + if (aFilterArray.Count()) + { + TUint cmBearerType = aCmArray[i]->GetIntAttributeL( ECmBearerType ); + if ( aFilterArray.Find( cmBearerType ) == KErrNotFound ) + { + continue; + } + } + + // CM Iap Id + TUint32 cmIapId = aCmArray[i]->GetIntAttributeL( ECmId ); + + // Should virtual bearer types be shown? + if ( iShowVirtualCMs || !IsCmVirtualL( cmIapId ) ) + { + // CM name + HBufC* name = aCmArray[i]->GetStringAttributeL( ECmName ); + CleanupStack::PushL( name ); + + items->AppendL( *name ); + idArray.Append( cmIapId ); + + // Virtual CMs have underlying CMs, highlight + if ( cmIapId == aSelection.iId ) + { + cmSelected = j; + j++; + } + + CleanupStack::PopAndDestroy( name ); + } + } + + // create the dialog + CAknRadioButtonSettingPage* dlg = + new ( ELeave ) CAknRadioButtonSettingPage( + R_RADIO_BUTTON_SETTING_PAGE_OK_CANCEL, + cmSelected, + items ); + CleanupStack::PushL( dlg ); + + // Title + HBufC* title = StringLoader::LoadLC ( aTitleStringResource ); + dlg->SetSettingTextL( *title ); + + // Show the dialog + if ( dlg->ExecuteLD( CAknSettingPage::EUpdateWhenChanged ) ) + { + aSelection.iId = idArray[cmSelected]; + aSelection.iResult = EDCConnectionMethod; + retVal = ETrue; + } + idArray.Close(); + + CleanupStack::PopAndDestroy( title ); + CleanupStack::Pop( dlg ); + CleanupStack::PopAndDestroy( items ); + + return retVal; + } + + +//--------------------------------------------------------------------------- +// CCmConnSettingsUiImpl::IsCmVirtualL +//--------------------------------------------------------------------------- +// +TBool CCmConnSettingsUiImpl::IsCmVirtualL( TUint32 aIapId ) + { + // check if bearer is virtual + TInt bearerType = iCmManagerImpl->GetConnectionMethodInfoIntL( + aIapId, ECmBearerType ); + return iCmManagerImpl->GetBearerInfoBoolL( bearerType, ECmVirtual ); + } + + +//--------------------------------------------------------------------------- +// CCmConnSettingsUiImpl::CreateDefaultConnectionNameL +//--------------------------------------------------------------------------- +// +HBufC* CCmConnSettingsUiImpl::CreateDefaultConnectionNameL( + TCmDefConnValue aSelection ) + { + HBufC* ret = NULL; + switch ( aSelection.iType ) + { + case ECmDefConnDestination: + { + CCmDestinationImpl* dest = + iCmManagerImpl->DestinationL( aSelection.iId ); + CleanupStack::PushL( dest ); + ret = dest->NameLC(); + CleanupStack::Pop( ret ); + CleanupStack::PopAndDestroy( dest ); + break; + } + case ECmDefConnConnectionMethod: + { + ret = iCmManagerImpl->GetConnectionMethodInfoStringL( + aSelection.iId, ECmName ); + break; + } + } + return ret; + } + + + +//--------------------------------------------------------------------------- +// CCmConnSettingsUiImpl::SetDestinationArrayToUseL +//--------------------------------------------------------------------------- +// +EXPORT_C void CCmConnSettingsUiImpl::SetDestinationArrayToUseL( + RArray aDestinationArray ) + { + iPassedDestinations.Close(); + for (TInt i=0; i