/*
* Copyright (c) 2002 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 plugins (base & all derived).
*
*/
// INCLUDE FILES
#include "ActiveSelectExplicit.h"
#include "SelectExplicitDialog.h"
#include "ConnectionInfo.h"
#include "ConnectionInfoArray.h"
#include "CConnDlgPrivateCRKeys.h"
#include "ConnectionDialogsLogger.h"
#include "sortsnaputils.h"
#include <commdb.h>
#include <StringLoader.h>
#include <wlanmgmtcommon.h>
#include <cmdestinationext.h>
#include <cmpluginwlandef.h>
#ifndef __WINS__
#include <wlanmgmtclient.h>
#endif
#include <AknWaitDialog.h>
#include <AknIconArray.h>
#include <AknsUtils.h>
#include <CConnDlgPlugin.rsg>
#include <data_caging_path_literals.hrh>
#include <cmmanager.mbg>
#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS
#include <commsdat.h>
#else
#include <commsdat.h>
#include <commsdat_partner.h>
#endif
#include <wlancontainer.h>
// CONSTANTS
LOCAL_D const TInt KMaxEntryLength = CommsDat::KMaxTextLength*2 + 20;
LOCAL_D const TInt KIconsGranularity = 4;
using namespace CMManager;
///////////////////////////////////////////////////////////////////////////////
// ---------------------------------------------------------
// CActiveSelectExplicit::CActiveSelectExplicit()
// ---------------------------------------------------------
//
CActiveSelectExplicit::CActiveSelectExplicit(
CSelectConnectionDialog* aCallerDialog,
TUint aDestId,
TInt aRefreshInterval,
TUint32 aBearerSet,
TBool aIsWLANFeatureSupported,
TUint aDefaultCMId )
: iCallerDialog( aCallerDialog ),
iDestId( aDestId ),
// isDialogDeleting( EFalse ),
iRefreshInterval( aRefreshInterval ),
iBearerSet( aBearerSet ),
iIsWLANFeatureSupported( aIsWLANFeatureSupported ),
iDefaultCMId( aDefaultCMId )
{
}
// ---------------------------------------------------------
// CActiveSelectExplicit* CActiveSelectExplicit::NewL()
// ---------------------------------------------------------
//
CActiveSelectExplicit* CActiveSelectExplicit::NewL(
CSelectConnectionDialog* aCallerDialog,
TUint aDestId,
TInt aRefreshInterval,
TUint32 aBearerSet,
TBool aIsWLANFeatureSupported,
TUint aDefaultCMId )
{
CLOG_ENTERFN( "CActiveSelectExplicit::NewL " );
CActiveSelectExplicit* self = new ( ELeave ) CActiveSelectExplicit(
aCallerDialog, aDestId, aRefreshInterval,
aBearerSet, aIsWLANFeatureSupported,
aDefaultCMId );
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
CLOG_LEAVEFN( "CActiveSelectExplicit::NewL " );
return self;
}
// ---------------------------------------------------------
// CActiveSelectExplicit::ConstructL()
// ---------------------------------------------------------
//
void CActiveSelectExplicit::ConstructL()
{
CActiveBase::ConstructL();
iItems = new( ELeave ) CConnectionInfoArray();
iIcons = new( ELeave ) CAknIconArray( KIconsGranularity );
iCmManagerExt.OpenL();
}
// ---------------------------------------------------------
// CActiveSelectExplicit::~CActiveSelectExplicit()
// ---------------------------------------------------------
//
CActiveSelectExplicit::~CActiveSelectExplicit()
{
Cancel();
if ( iItems )
{
iItems->ResetAndDestroy();
}
delete iItems;
iItems = NULL;
iCmManagerExt.Close();
}
// ---------------------------------------------------------
// CActiveSelectExplicit::Cancel()
// ---------------------------------------------------------
//
void CActiveSelectExplicit::Cancel()
{
StopTimer();
CActive::Cancel();
if( iDialog && !( iDialog->GetOkToExit() ) )
{
CLOG_WRITEF( _L( "iDialog->GetOkToExit() : %b" ), iDialog->GetOkToExit() );
delete iDialog;
iDialog = NULL;
}
}
// ---------------------------------------------------------
// CActiveSelectExplicit::DoCancel()
// ---------------------------------------------------------
//
void CActiveSelectExplicit::DoCancel()
{
CLOG_ENTERFN( "CActiveSelectExplicit::DoCancel " );
/* if( isDialogDeleting )
{
CLOG_WRITE( "isDialogDeleting" );
delete iDialog;
iDialog = NULL;
isDialogDeleting = EFalse;
}
*/
CLOG_LEAVEFN( "CActiveSelectExplicit::DoCancel " );
}
// ---------------------------------------------------------
// CActiveSelectExplicit::RunL()
// ---------------------------------------------------------
//
void CActiveSelectExplicit::RunL()
{
CLOG_ENTERFN( "CActiveSelectExplicit::RunL " );
if( iStatus == KErrNone )
{
BuildConnectionListL();
iDialog->RefreshDialogL( iItems, iIcons, ETrue );
}
CLOG_LEAVEFN( "CActiveSelectExplicit::RunL " );
}
// ---------------------------------------------------------
// CActiveSelectExplicit::StartSearchIAPsL()
// ---------------------------------------------------------
//
void CActiveSelectExplicit::ShowSelectExplicitL()
{
BuildConnectionListL();
iDialog = CSelectExplicitDialog::NewL( iCallerDialog );
iDialog->PrepareAndRunLD( iItems, iIcons, EFalse );
if( iRefreshInterval )
{
StartTimerL( iRefreshInterval );
}
}
// ---------------------------------------------------------
// CActiveSelectExplicit::BuildConnectionListL()
// ---------------------------------------------------------
//
void CActiveSelectExplicit::BuildConnectionListL()
{
CLOG_ENTERFN( "CActiveSelectExplicit::BuildConnectionListL " );
if ( iItems )
{
iItems->ResetAndDestroy();
}
if ( iIcons )
{
iIcons->ResetAndDestroy();
}
if ( iDefaultCMId != 0 )
{ // It automatically means also that the feature is supported
_LIT( KDriveZ, "z:" ); // ROM folder
// Name of the MBM file containing icons
_LIT( KManagerIconFilename, "cmmanager.mbm" );
TFileName iconsFileName;
iconsFileName.Append( KDriveZ );
iconsFileName.Append( KDC_APP_BITMAP_DIR );
iconsFileName.Append( KManagerIconFilename );
iIcons->AppendL( AknsUtils::CreateGulIconL( AknsUtils::SkinInstance(),
KAknsIIDQgnIndiCbHotAdd,
iconsFileName,
EMbmCmmanagerQgn_indi_cb_hot_add,
EMbmCmmanagerQgn_indi_cb_hot_add_mask ) );
}
TBool easyWlanIsInDb = EFalse;
#ifdef _DEBUG
if ( iDestId )
{ // Real destination, not for uncategorized
RCmDestinationExt cmDestExt = iCmManagerExt.DestinationL( iDestId );
CleanupClosePushL( cmDestExt );
CLOG_WRITEF( _L( "Destination id %d, Total number of methods %d" ),
iDestId, cmDestExt.ConnectionMethodCount() );
for ( TInt j = 0; j < cmDestExt.ConnectionMethodCount(); j++ )
{
RCmConnectionMethodExt cmConnMethodExt;
TRAPD( err, cmConnMethodExt = cmDestExt.ConnectionMethodL( j ) );
if ( err == KErrNone )
{
CleanupClosePushL( cmConnMethodExt );
HBufC* bufMethod = cmConnMethodExt.GetStringAttributeL(
ECmName );
CleanupStack::PushL( bufMethod );
TBuf<CommsDat::KMaxTextLength+1> nameMethod;
nameMethod = *bufMethod;
nameMethod.ZeroTerminate();
CLOG_WRITEF( _L( "ConnMethod id %d, Method name %s" ),
cmConnMethodExt.GetIntAttributeL( ECmIapId ), nameMethod.Ptr() );
CleanupStack::PopAndDestroy( 2 ); // bufMethod, cmConnMethodExt
}
}
CleanupStack::PopAndDestroy(); // cmDestExt
}
#endif
TSortSnapUtils sortSnapUtils( iMPM );
TMpmSnapBuffer snapBuffer;
TInt err = sortSnapUtils.GetSortSnapData( iDestId, snapBuffer );
CLOG_WRITEF( _L( "GetSortSNAPDataL returned = %d. list.Count() = %d" ), err, snapBuffer.Count() );
if ( err == KErrNone )
{
RCmConnectionMethodExt cmConnMethodExt;
CleanupClosePushL( cmConnMethodExt );
for ( TInt numCM = 0; numCM < snapBuffer.Count(); numCM++ )
{
AddConnectionMethodItemL( snapBuffer.iIapId[numCM],
iDestId == 0,
easyWlanIsInDb,
snapBuffer.iIapId[numCM] == iDefaultCMId );
}
CleanupStack::PopAndDestroy(); // cmConnMethodExt
}
// Add any ad-hoc WLAN iaps to the list
if ( ( iBearerSet & ECommDbBearerWLAN ) && ( iDestId == 0 ) && iIsWLANFeatureSupported )
{
AddAdhocWlanIapsL();
}
CLOG_LEAVEFN( "CActiveSelectExplicit::BuildConnectionListL " );
}
// ---------------------------------------------------------
// CActiveSelectExplicit::AddConnectionMethodItemL()
// ---------------------------------------------------------
//
void CActiveSelectExplicit::AddConnectionMethodItemL( TUint32 aId,
TBool aCheckForEasyWlan,
TBool& aEasyWlanIsInDb,
TBool aDefaultCM )
{
CLOG_ENTERFN( "CActiveSelectExplicit::AddConnectionMethodItemL" );
CConnectionInfo* conIn;
RCmConnectionMethodExt cmConnMethodExt;
CLOG_WRITEF( _L( "Uncat dest id %d" ), aId );
TRAPD( err, cmConnMethodExt = iCmManagerExt.ConnectionMethodL( aId ) );
CLOG_WRITEF( _L( "err %d" ), err );
if ( err == KErrNone )
{
CleanupClosePushL( cmConnMethodExt );
TUint32 bearer = cmConnMethodExt.GetIntAttributeL(
ECmCommsDBBearerType );
CLOG_WRITEF( _L( "bearer %d" ), bearer );
if ( bearer & iBearerSet )
{
CLOG_WRITE( "To be listed!" );
TBool isCMEasyWlan = EFalse;
HBufC* bufName = cmConnMethodExt.GetStringAttributeL(
ECmName );
TBuf<CommsDat::KMaxTextLength+1> nameCM;
nameCM = *bufName;
nameCM.ZeroTerminate();
delete bufName;
CLOG_WRITEF( _L( "Method name %s. Bearer = %d" ), nameCM.Ptr(), bearer );
if ( aCheckForEasyWlan && bearer == KCommDbBearerWLAN &&
iIsWLANFeatureSupported )
{
if ( !aEasyWlanIsInDb )
{
HBufC* bufSSID = cmConnMethodExt.GetStringAttributeL(
EWlanSSID );
if ( !bufSSID || bufSSID->Des().Length() == 0 )
{
isCMEasyWlan = ETrue;
aEasyWlanIsInDb = ETrue;
}
delete bufSSID;
}
}
if ( !isCMEasyWlan )
{
CGulIcon* iconCM = ( CGulIcon* )
cmConnMethodExt.GetIntAttributeL(
ECmBearerIcon );
if ( iconCM )
{
CLOG_WRITEF( _L( "iconCM found" ) );
CleanupStack::PushL( iconCM );
iIcons->AppendL( iconCM );
// icon array took over ownership
CleanupStack::Pop( iconCM );
}
else
{
CLOG_WRITEF( _L( "iconCM not found" ) );
}
TBuf<KMaxEntryLength> temp;
_LIT( KIconIdName, "%d\t%s" );
_LIT( KIconIdNameDefaultConn, "%d\t%s\t0" );
if ( aDefaultCM )
{
temp.Format( KIconIdNameDefaultConn, iIcons->Count()-1,
nameCM.Ptr() );
}
else
{
temp.Format( KIconIdName, iIcons->Count()-1,
nameCM.Ptr() );
}
conIn = CConnectionInfo::NewL( aId, 0, temp );
CleanupStack::PushL( conIn );
iItems->AppendL( conIn );
CleanupStack::Pop( conIn );
}
}
CleanupStack::PopAndDestroy(); // cmConnMethodExt
}
CLOG_LEAVEFN( "CActiveSelectExplicit::AddConnectionMethodItemL" );
}
// ---------------------------------------------------------
// CActiveSelectExplicit::AddAdhocWlanIapsL()
// ---------------------------------------------------------
//
void CActiveSelectExplicit::AddAdhocWlanIapsL()
{
CLOG_ENTERFN( "CActiveSelectExplicit::AddAdhocWlanIapsL " );
// Creating a session with the latest version
CMDBSession* db = CMDBSession::NewLC( CMDBSession::LatestVersion() );
db->SetAttributeMask( ECDProtectedWrite );
// Create wlan service record set (RArray (or RPtrArray?))
CMDBRecordSet<CCDWlanServiceRecord>* wlanSet =
new (ELeave)CMDBRecordSet<CCDWlanServiceRecord>( CCDWlanServiceRecord::TableIdL( *db ) );
CleanupStack::PushL( wlanSet );
// Create wlan service record
CCDWlanServiceRecord* wlanRecord =
new (ELeave)CCDWlanServiceRecord( CCDWlanServiceRecord::TableIdL( *db ) );
CleanupStack::PushL( wlanRecord );
// Set ConnectionMode field in wlan service record (see wlancontainer.h)
// This works with EWlanOperatingModeAdhoc, fails with EWlanConnectionModeAdhoc
wlanRecord->iWlanConnMode.SetL( EWlanOperatingModeAdhoc );
// Append wlan service record to wlan service record set (currently empty)
wlanSet->iRecords.AppendL( wlanRecord );
CleanupStack::Pop( wlanRecord ); // ownership moved to RPointerArray
// Find matcing wlan service records
if( wlanSet->FindL( *db ) )
{
TInt wlanRecordCount( wlanSet->iRecords.Count() );
CLOG_WRITEF( _L("wlanSet record count = %d"), wlanRecordCount );
TBool easyWlanIsInDb = EFalse;
// loop for each record found
for ( TInt i = 0; i < wlanRecordCount; i++ )
{
// Seems we need to specifically load the current record again to be sure all fields are up to date
wlanRecord->SetElementId( wlanSet->iRecords[i]->ElementId() );
// Load will only look at ElementId and updates the rest of the fields
wlanRecord->LoadL( *db );
if ( !( wlanRecord->iWLanSSID.IsNull() ) )
{
// Don't include Easy WLAN
// lets print some stuff to log
CLOG_WRITEF( _L("New ad-hoc WLAN IAP:" ));
CLOG_WRITEF( _L(" iWlanServiceId = %d"), static_cast<TUint>( wlanRecord->iWlanServiceId ) );
CLOG_WRITEF( _L(" iWlanConnMode = %d"), static_cast<TUint>( wlanRecord->iWlanConnMode ) );
CLOG_WRITEF( _L(" iWLanSSID = %S"), &(static_cast<TDesC>( wlanRecord->iWLanSSID ) ) );
// Create an iap record
CCDIAPRecord* iapRecord = static_cast<CCDIAPRecord*> (
CCDRecordBase::RecordFactoryL( KCDTIdIAPRecord ) );
CleanupStack::PushL( iapRecord );
iapRecord->iServiceType.SetL( TPtrC( KCDTypeNameLANService ) );
// Set the service field to the same value as in the wlan service record we are currently looking
iapRecord->iService = wlanRecord->iWlanServiceId;
// Find the matching iap record
if( iapRecord->FindL( *db ) )
{
TUint iapId( 0 );
// read the iap id
iapId = iapRecord->RecordId();
CLOG_WRITEF( _L(" iapId = %d"), iapId );
AddConnectionMethodItemL( iapId,
iDestId == 0,
easyWlanIsInDb,
iapId == iDefaultCMId );
}
CleanupStack::PopAndDestroy( iapRecord );
}
}
}
else
{
CLOG_WRITEF( _L("no matcing wlan records found." ));
}
CleanupStack::PopAndDestroy( wlanSet );
CleanupStack::PopAndDestroy( db );
CLOG_LEAVEFN( "CActiveSelectExplicit::AddAdhocWlanIapsL" );
}
// End of File