/*
* Copyright (c) 2008 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: wlanindicatorplugin implementation
*
*/
// INCLUDE FILES
#include <eikenv.h>
#include <avkon.rsg>
#include <avkon.hrh>
#include <apgcli.h>
#include <apgtask.h>
#include <coemain.h>
#include <bautils.h>
#include <data_caging_path_literals.hrh>
#include <StringLoader.h>
#include <rconnmon.h>
#include <cmmanager.h>
#include <cmconnectionmethod.h>
#include <wlanmgmtclient.h>
#include <wlanscaninfo.h>
#include <cdblen.h>
#include <commdb.h>
#include <WlanCdbCols.h>
#include <utf.h>
#include <wlanindicator.rsg>
#include "wlanindicatorpluginimplementation.h"
// CONSTANTS
const TUid KSnifferAppUid = { 0x10281CAA };
_LIT( KDriveZ, "z:" );
_LIT( KWlanIndicatorResourceFile, "wlanindicator.rsc" );
using namespace CMManager;
// ======== MEMBER FUNCTIONS ========
// ---------------------------------------------------------------------------
// CWlanIndicatorPluginImplementation::CWlanIndicatorPluginImplementation
// C++ default constructor can NOT contain any code, that
// might leave.
// ---------------------------------------------------------------------------
//
CWlanIndicatorPluginImplementation::CWlanIndicatorPluginImplementation()
: iCoeEnv( CCoeEnv::Static() )
{
}
// ---------------------------------------------------------------------------
// CWlanIndicatorPluginImplementation::ConstructL
// Symbian 2nd phase constructor can leave.
// ---------------------------------------------------------------------------
//
void CWlanIndicatorPluginImplementation::ConstructL()
{
TFileName fileName;
fileName.Append( KDriveZ );
fileName.Append( KDC_RESOURCE_FILES_DIR );
fileName.Append( KWlanIndicatorResourceFile );
BaflUtils::NearestLanguageFile( iCoeEnv->FsSession(), fileName );
iResource = iCoeEnv->AddResourceFileL( fileName );
iConnMonitor.ConnectL();
iWlanMgmtClient = CWlanMgmtClient::NewL();
}
// -----------------------------------------------------------------------------
// CWlanIndicatorPluginImplementation::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CWlanIndicatorPluginImplementation* CWlanIndicatorPluginImplementation::NewL()
{
CWlanIndicatorPluginImplementation* self =
new( ELeave ) CWlanIndicatorPluginImplementation;
CleanupStack::PushL( self );
self->ConstructL();
CleanupStack::Pop( self );
return self;
}
// -----------------------------------------------------------------------------
// CWlanIndicatorPluginImplementation::~CWlanIndicatorPluginImplementation
// Destructor.
// -----------------------------------------------------------------------------
//
CWlanIndicatorPluginImplementation::~CWlanIndicatorPluginImplementation()
{
iCoeEnv->DeleteResourceFile( iResource );
iConnMonitor.Close();
delete iWlanMgmtClient;
}
// ---------------------------------------------------------------------------
// CWlanIndicatorPluginImplementation::HandleIndicatorTapL
// ---------------------------------------------------------------------------
//
void CWlanIndicatorPluginImplementation::HandleIndicatorTapL( const TInt aUid )
{
switch ( aUid )
{
case EAknIndicatorWlanAvailable:
case EAknIndicatorWlanActive:
case EAknIndicatorWlanActiveSecure:
{
LaunchWlanSnifferL();
break;
}
default:
break;
}
}
// ---------------------------------------------------------------------------
// CWlanIndicatorPluginImplementation::TextL( const TInt aUid, TInt& aTextType )
// ---------------------------------------------------------------------------
//
HBufC* CWlanIndicatorPluginImplementation::TextL( const TInt aUid,
TInt& aTextType )
{
HBufC* textBuf = NULL;
switch ( aUid )
{
case EAknIndicatorWlanAvailable:
{
textBuf = CreateWlanNetworksFoundTextL();
aTextType = EAknIndicatorPluginLinkText;
break;
}
case EAknIndicatorWlanActive:
case EAknIndicatorWlanActiveSecure:
{
textBuf = CreateWlanConnectedTextL();
aTextType = EAknIndicatorPluginLinkText;
break;
}
default:
break;
}
return textBuf;
}
// ---------------------------------------------------------------------------
// CWlanIndicatorPluginImplementation::CreateWlanNetworksFoundTextL()
// ---------------------------------------------------------------------------
//
HBufC* CWlanIndicatorPluginImplementation::CreateWlanNetworksFoundTextL()
{
HBufC* dynText = NULL;
HBufC* knownNetworkName = NULL;
TInt availableCount( 0 );
knownNetworkName = AvailableNetworksInfoL( availableCount );
CleanupStack::PushL( knownNetworkName );
if ( !knownNetworkName )
{
if ( availableCount == 1 )
{
// dynText: "qtn_uni_ind_wlan_avail_unknown WLAN network found"
dynText = StringLoader::LoadL (
R_QTN_UNI_IND_WLAN_AVAIL_UNKNOWN, iCoeEnv );
}
else
{
// dynText: "qtn_uni_ind_wlan_avail_unknown_many WLAN networks found"
dynText = StringLoader::LoadL (
R_QTN_UNI_IND_WLAN_AVAIL_UNKNOWN_MANY, iCoeEnv );
}
}
else
{
// dynText: "qtn_uni_ind_wlan_avail_known '%U' found"
dynText = StringLoader::LoadL (
R_QTN_UNI_IND_WLAN_AVAIL_KNOWN, *knownNetworkName, iCoeEnv );
}
CleanupStack::PopAndDestroy( knownNetworkName );
return dynText;
}
// ---------------------------------------------------------------------------
// CWlanIndicatorPluginImplementation::CreateWlanConnectedTextL()
// ---------------------------------------------------------------------------
//
HBufC* CWlanIndicatorPluginImplementation::CreateWlanConnectedTextL()
{
HBufC* dynText = NULL;
HBufC* connectedNetworkName = NULL;
connectedNetworkName = ConnectionNameL( );
CleanupStack::PushL( connectedNetworkName );
if ( connectedNetworkName )
{
// "qtn_uni_ind_wlan_conn '%U' connected"
dynText = StringLoader::LoadL (
R_QTN_UNI_IND_WLAN_CONN, *connectedNetworkName, iCoeEnv );
}
CleanupStack::PopAndDestroy( connectedNetworkName );
return dynText;
}
// ---------------------------------------------------------------------------
// CWlanIndicatorPluginImplementation::AvailableNetworksInfoL()
// ---------------------------------------------------------------------------
//
HBufC* CWlanIndicatorPluginImplementation::AvailableNetworksInfoL(
TInt& aAvailableCount )
{
HBufC* knownNetworkName = NULL;
// get available iaps
RArray<TUint> availableIaps;
TInt iapError( 0 );
iapError = iWlanMgmtClient->GetAvailableIaps( availableIaps );
if ( iapError == KErrNone )
{
// if there are known networks, get the name of the first one
// in an alphabetical order
if ( availableIaps.Count() )
{
// get all network names and put them into a sorted array
// use one TWliWlanInfo struct to point to each IAP in a loop
TWliWlanInfo* availableInfo = new ( ELeave ) TWliWlanInfo();
CleanupStack::PushL( availableInfo );
// descriptor array with granularity 2
CDesCArray* networkNames = new (ELeave)CDesCArrayFlat( 2 );
CleanupStack::PushL( networkNames );
for ( TInt i = 0; i < availableIaps.Count() ; i++ )
{
availableInfo->iIapId = availableIaps[i];
GetWlanInfoFromIapL( *availableInfo );
// insert the name into the proper place
// in alphabetical order
networkNames->InsertIsqL(
( availableInfo->iNetworkName ), ECmpFolded );
}
knownNetworkName = ( networkNames->MdcaPoint(0) ).AllocL();
CleanupStack::PopAndDestroy( networkNames );
CleanupStack::PopAndDestroy( availableInfo );
}
else // unknown networks only
{
CWlanScanInfo* scanInfo = CWlanScanInfo::NewL();
TInt scanError( 0 );
scanError = iWlanMgmtClient->GetScanResults( *scanInfo );
if ( scanError == KErrNone )
{
// Find if we have 1 or more networks available,
// we don't have to know the exact amount
scanInfo->Next() ? aAvailableCount = 2 : aAvailableCount = 1;
}
delete scanInfo;
}
}
availableIaps.Close();
return knownNetworkName;
}
// ---------------------------------------------------------------------------
// CWlanIndicatorPluginImplementation::GetWlanInfoFromIapL()
// ---------------------------------------------------------------------------
//
void CWlanIndicatorPluginImplementation::GetWlanInfoFromIapL( TWliWlanInfo& aWlanInfo )
{
CCommsDatabase* commsDb = CCommsDatabase::NewL();
CleanupStack::PushL( commsDb );
CCommsDbTableView* commsDbIapTableView = commsDb->OpenViewMatchingUintLC(
TPtrC( IAP ), TPtrC( COMMDB_ID ), aWlanInfo.iIapId );
User::LeaveIfError( commsDbIapTableView->GotoFirstRecord() );
commsDbIapTableView->ReadTextL( TPtrC( COMMDB_NAME ), aWlanInfo.iNetworkName );
CleanupStack::PopAndDestroy( commsDbIapTableView );
CleanupStack::PopAndDestroy( commsDb );
}
// ---------------------------------------------------------------------------
// CWlanIndicatorPluginImplementation::ConnectionNameL()
// ---------------------------------------------------------------------------
//
HBufC* CWlanIndicatorPluginImplementation::ConnectionNameL( )
{
HBufC* connName = NULL;
// get the connection ID
TUint connectionId = FindWlanBearerConnectedL();
TUint connectedIapId(0);
TRequestStatus status;
// get the IAP ID
iConnMonitor.GetUintAttribute( connectionId, 0, KIAPId,
connectedIapId, status );
User::WaitForRequest( status );
// get the connection method from cmmanager
RCmManager cmManager;
cmManager.OpenLC();
RCmConnectionMethod connMethod = cmManager.ConnectionMethodL( connectedIapId );
CleanupClosePushL( connMethod );
connName = connMethod.GetStringAttributeL( ECmName );
CleanupStack::PopAndDestroy( 2, &cmManager ); //cmManager and connMethod
return connName;
}
// ---------------------------------------------------------------------------
// CWlanIndicatorPluginImplementation::FindWlanBearerConnectedL()
// ---------------------------------------------------------------------------
//
TUint CWlanIndicatorPluginImplementation::FindWlanBearerConnectedL( )
{
TUint connectionId( 0 );
TUint connCount( 0 );
TUint subConnectionCount( 0 );
TRequestStatus status;
iConnMonitor.GetConnectionCount( connCount, status );
User::WaitForRequest( status );
if ( status.Int() == KErrNone )
{
for ( TUint i = 1; i <= connCount; ++i )
{
User::LeaveIfError( iConnMonitor.GetConnectionInfo( i, connectionId,
subConnectionCount ) );
if ( CheckIfWlan( connectionId ) )
{
break;
}
}
}
return connectionId;
}
// ---------------------------------------------------------------------------
// CWlanIndicatorPluginImplementation::CheckIfWlan()
// ---------------------------------------------------------------------------
//
TBool CWlanIndicatorPluginImplementation::CheckIfWlan( TUint aConnectionId )
{
TConnMonBearerType bearerType( EBearerUnknown );
TBool foundWlanBearer( EFalse );
TRequestStatus status;
// Add only connections with valid id
if ( aConnectionId > 0 )
{
iConnMonitor.GetIntAttribute( aConnectionId, 0, KBearer, (TInt&)bearerType,
status );
User::WaitForRequest( status );
if ( status.Int() == KErrNone )
{
if ( bearerType == EBearerWLAN )
{
foundWlanBearer = ETrue;
}
}
}
return foundWlanBearer;
}
// ---------------------------------------------------------------------------
// CWlanIndicatorPluginImplementation::LaunchWlanSnifferL()
// ---------------------------------------------------------------------------
//
void CWlanIndicatorPluginImplementation::LaunchWlanSnifferL()
{
RApaLsSession appArcSession;
User::LeaveIfError( appArcSession.Connect() ); // connect to AppArc server
CleanupClosePushL( appArcSession );
// check if the app is already running
TApaTaskList taskList( CEikonEnv::Static()->WsSession() );
TApaTask task = taskList.FindApp( KSnifferAppUid );
if ( task.Exists() )
{
task.BringToForeground();
}
else
{
TThreadId threadId;
User::LeaveIfError( appArcSession.StartDocument( KNullDesC,
KSnifferAppUid, threadId ) );
}
CleanupStack::PopAndDestroy(); // appArcSession
}
// End of File