/*

* 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 <cmpluginwlandef.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();

    }

// -----------------------------------------------------------------------------

// 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();

    }

// ---------------------------------------------------------------------------

// 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;

    // "qtn_uni_ind_wlan_avail_unknown_many    WLAN networks found"

    dynText = StringLoader::LoadL (

            R_QTN_UNI_IND_WLAN_AVAIL_UNKNOWN_MANY, iCoeEnv );

    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::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 );

    TUint32 easyWLANIapId = cmManager.EasyWlanIdL();

    if ( easyWLANIapId != connectedIapId )

        {

        connName = connMethod.GetStringAttributeL( ECmName );

        }

    else

        {

        connName = connMethod.GetStringAttributeL( EWlanUsedSSID );

        }

    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