/*

* Copyright (c) 2002-2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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 wlan management API

*

*/

/*

* %version: 29 %

*/

// INCLUDE FILES

#include <e32std.h>

#include <ecom/implementationproxy.h>

#include "gendebug.h"

#include "wlanmgmtimpl.h"

#include "wlanscaninfoimpl.h"

// LOCAL CONSTANTS

/**

* Pairs ECom implementation UIDs with a pointer to the instantiation 

* method for that implementation. Required for all ECom implementation

* collections.

*/

//lint --e{611}

const TImplementationProxy ImplementationTable[] =

    {

        {{0x101f8eff}, reinterpret_cast<TProxyNewLPtr>( CWlanMgmtImpl::NewL )},

        {{0x101f8f01}, reinterpret_cast<TProxyNewLPtr>( CWlanScanInfoImpl::NewL )}

    };

/** The default values for scan scheduling parameters. */

const TInt KWlanMgmtDefaultCacheLifetime = -1;

const TUint KWlanMgmtDefaultMaxDelay = 0;

/**

 * A mapping table between WLAN Management callback API versions

 * and internal notifications.

 */

const TUint KWlanMgmtCallbackInterfaceMap[KWlanCallbackInterfaceVersion] =

    { KWlmDefaultNotificationsV1,

      KWlmDefaultNotificationsV2 };

// ================= MEMBER FUNCTIONS =======================

// C++ default constructor can NOT contain any code, that

// might leave.

//

CWlanMgmtImpl::CWlanMgmtImpl() : 

    iScanRequest( NULL ),

    iPendingScanStatus( NULL ),

    iAvailableIapsRequest( NULL ),

    iPendingAvailableIapsStatus( NULL ),

	iClientNotification( NULL ),

	iProtectedSetupRequest( NULL ),

	iPendingProtectedSetupStatus( NULL ),

	iCacheLifetime( 0 ),

	iMaxDelay( 0 )

    {

    TraceDump( INFO_LEVEL, ( _L( "CWlanMgmtImpl::CWlanMgmtImpl()" ) ) );

    }

// Symbian 2nd phase constructor can leave.

void CWlanMgmtImpl::ConstructL()

    {

    TraceDump( INFO_LEVEL, ( _L( "CWlanMgmtImpl::ConstructL()" ) ) );

    User::LeaveIfError( iServer.Connect() );

    }

// Static constructor.

CWlanMgmtImpl* CWlanMgmtImpl::NewL()

    {

    TraceDump( INFO_LEVEL, ( _L( "CWlanMgmtImpl::NewL()" ) ) );

    CWlanMgmtImpl* self = new (ELeave) CWlanMgmtImpl;

    CleanupStack::PushL( self );    

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CWlanMgmtImpl::~CWlanMgmtImpl()

    {

    TraceDump( INFO_LEVEL, ( _L( "CWlanMgmtImpl::~CWlanMgmtImpl()" ) ) );

    CancelGetAvailableIaps();

    CancelGetScanResults();

    CancelProtectedSetup();

    iServer.Close();

    delete iScanRequest;

    delete iAvailableIapsRequest;

    delete iProtectedSetupRequest;

    iPendingScanStatus = NULL;

    iPendingAvailableIapsStatus = NULL;

    iClientNotification = NULL;

    iPendingProtectedSetupStatus = NULL;

    }

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

// CWlanMgmtImpl::ActivateNotificationsL

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

//

void CWlanMgmtImpl::ActivateNotificationsL(

    MWlanMgmtNotifications& aCallback )

    {

    TraceDump( INFO_LEVEL, ( _L( "CWlanMgmtImpl::ActivateNotificationsL()" ) ) );

	iClientNotification = &aCallback;

	iServer.ActivateNotifiesL( *this, KWlmDefaultNotificationsV1 );

    }

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

// CWlanMgmtImpl::CancelNotifications

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

//

void CWlanMgmtImpl::CancelNotifications()

    {

    TraceDump( INFO_LEVEL, ( _L( "CWlanMgmtImpl::CancelNotifications()" ) ) );

	iServer.CancelNotifies();

	iClientNotification = NULL;

    }

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

// CWlanMgmtImpl::GetScanResults

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

//

void CWlanMgmtImpl::GetScanResults(

    TRequestStatus& aStatus,

    CWlanScanInfo& aResults )

    {

    TraceDump( INFO_LEVEL, ( _L( "CWlanMgmtImpl::GetScanResults()" ) ) );

    aStatus = KRequestPending;

    iPendingScanStatus = &aStatus;

    // Because CWlanScanInfo has been initialized through ECom

    // interface, the object is actually CWlanScanInfoImpl.

    CWlanScanInfoImpl* impl = reinterpret_cast<CWlanScanInfoImpl*>(&aResults);

    TWlanSsid tmp;

    iCacheLifetime = KWlanMgmtDefaultCacheLifetime;

    iMaxDelay = KWlanMgmtDefaultMaxDelay;

    iScanRequest = new CWlanScanRequest( *this, iServer, *impl, tmp, iCacheLifetime, iMaxDelay );

	if ( !iScanRequest )

		{

		User::RequestComplete( iPendingScanStatus, KErrNoMemory );

		iPendingScanStatus = NULL;

		return;

		}

    iScanRequest->IssueRequest();

    }

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

// CWlanMgmtImpl::GetScanResults

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

//

void CWlanMgmtImpl::GetScanResults(

    TWlanSsid& aSsid,

    TRequestStatus& aStatus,

    CWlanScanInfo& aResults )

    {

    TraceDump( INFO_LEVEL, ( _L( "CWlanMgmtImpl::GetScanResults() (directed scan)" ) ) );

    aStatus = KRequestPending;

    iPendingScanStatus = &aStatus;

    iCacheLifetime = KWlanMgmtDefaultCacheLifetime;

    iMaxDelay = KWlanMgmtDefaultMaxDelay;

    // Because CWlanScanInfo has been initialized through ECom

    // interface, the object is actually CWlanScanInfoImpl.

    CWlanScanInfoImpl* impl = reinterpret_cast<CWlanScanInfoImpl*>(&aResults);

    iScanRequest = new CWlanScanRequest( *this, iServer, *impl, aSsid, iCacheLifetime, iMaxDelay );

	if ( !iScanRequest )

		{

		User::RequestComplete( iPendingScanStatus, KErrNoMemory );

		iPendingScanStatus = NULL;

		return;

		}

    iScanRequest->IssueRequest();

    }

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

// CWlanMgmtImpl::GetScanResults

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

//

TInt CWlanMgmtImpl::GetScanResults(

    CWlanScanInfo& aResults )

    {

    TraceDump( INFO_LEVEL, ( _L( "CWlanMgmtImpl::GetScanResults() (2)" ) ) );

    // Because CWlanScanInfo has been initialized through ECom

    // interface, the object is actually CWlanScanInfoImpl.

    CWlanScanInfoImpl* impl = reinterpret_cast<CWlanScanInfoImpl*>(&aResults);

    TWlanSsid tmp;

    iCacheLifetime = KWlanMgmtDefaultCacheLifetime;

    iMaxDelay = KWlanMgmtDefaultMaxDelay;

    TInt ret = iServer.GetScanResults( impl->GetInternalList(), tmp, iCacheLifetime, iMaxDelay );

    if ( ret != KErrNone )

        {

        TraceDump( INFO_LEVEL, ( _L( "GetScanResults() returned with %d" ), ret ) );

        return ret;

        }

    return impl->UpdateResults();

    }

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

// CWlanMgmtImpl::GetScanResults

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

//

void CWlanMgmtImpl::GetScanResults(

    TInt& aCacheLifetime,

    TUint& aMaxDelay,

    TWlanSsid& aSsid,

    TRequestStatus& aStatus,

    CWlanScanInfo& aResults )

    {

    TraceDump( INFO_LEVEL, ( _L( "CWlanMgmtImpl::GetScanResults() (scan scheduling)" ) ) );

    aStatus = KRequestPending;

    iPendingScanStatus = &aStatus;

    // Because CWlanScanInfo has been initialized through ECom

    // interface, the object is actually CWlanScanInfoImpl.

    CWlanScanInfoImpl* impl = reinterpret_cast<CWlanScanInfoImpl*>(&aResults);

	iScanRequest = new CWlanScanRequest( *this, iServer, *impl, aSsid, aCacheLifetime, aMaxDelay );

	if ( !iScanRequest )

		{

		User::RequestComplete( iPendingScanStatus, KErrNoMemory );

		iPendingScanStatus = NULL;

		return;

		}

    iScanRequest->IssueRequest();

    }

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

// CWlanMgmtImpl::GetConnectionBssid

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

//

TInt CWlanMgmtImpl::GetConnectionBssid(

    TWlanBssid& aBssid )

    {

    TraceDump( INFO_LEVEL, ( _L( "CWlanMgmtImpl::GetConnectionBssid()" ) ) );

	TMacAddress bssid;

	TInt ret = iServer.GetBSSID( bssid );

	if ( ret != KErrNone )

		{

		return ret;

		}

	aBssid.Copy( &bssid.iMacAddress[0], KMacAddressLength ); 

    return KErrNone;

    }

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

// CWlanMgmtImpl::GetConnectionSsid

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

//

TInt CWlanMgmtImpl::GetConnectionSsid(

    TWlanSsid& aSsid )

    {

    TraceDump( INFO_LEVEL, ( _L( "CWlanMgmtImpl::GetConnectionSsid()" ) ) );

    TBuf16<KWlanMaxSsidLength> ssid;

	TInt ret = iServer.GetNetworkName( ssid );

	if ( ret != KErrNone )

		{

		return ret;

		}

	aSsid.Copy( ssid );

    return KErrNone;

    }

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

// CWlanMgmtImpl::GetConnectionSignalQuality

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

//

TInt CWlanMgmtImpl::GetConnectionSignalQuality(

    TInt32& aSignalQuality )

    {

    TraceDump( INFO_LEVEL, ( _L( "CWlanMgmtImpl::GetConnectionSignalQuality()" ) ) );

    TInt32 rcpi = 0;

    iServer.GetConnectionRCPI( rcpi );

    // RCPI -> RSSI CONVERSION

    // Note: conversion may round the result by 0.5 units

    aSignalQuality = ( 110 - ( rcpi / 2 ) );

    TraceDump( INFO_LEVEL, ( _L( " - (RCP, RSS) == (%u, %u)"), rcpi, aSignalQuality ) );

    return KErrNone;

    }

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

// CWlanMgmtImpl::GetConnectionState

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

//

TInt CWlanMgmtImpl::GetConnectionMode(

    TWlanConnectionMode& aMode )

    {

    TraceDump( INFO_LEVEL, ( _L( "CWlanMgmtImpl::GetConnectionMode()" ) ) );

	TWlanConnectionState state = iServer.GetConnectionState();

	switch ( state )

		{

		case EWlanStateInfrastructure:

			aMode = EWlanConnectionModeInfrastructure;

			break;

		case EWlanStateSearchingAP:

			aMode = EWlanConnectionModeSearching;

			break;

		case EWlanStateIBSS:

			aMode = EWlanConnectionModeAdhoc;

			break;

		case EWlanStateSecureInfra:

			aMode = EWlanConnectionModeSecureInfra;

			break;

		default:

			aMode = EWlanConnectionModeNotConnected;

			break;

        }

    return KErrNone;

    }

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

// CWlanMgmtImpl::GetConnectionSecurityMode

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

//

TInt CWlanMgmtImpl::GetConnectionSecurityMode(

    TWlanConnectionSecurityMode& aMode )

    {

    TraceDump( INFO_LEVEL, ( _L( "CWlanMgmtImpl::GetConnectionSecurityMode()" ) ) );

	TWlanSecurity mode( EWlanSecurityOpen );

	TInt ret = iServer.GetSecurityMode( mode );

	if ( ret != KErrNone )

		{

		return ret;

		}

	switch ( mode )

		{

		case EWlanSecurityWepOpen: // Fallthrough on purpose

		case EWlanSecurityWepShared:

			aMode = EWlanConnectionSecurityWep;

			break;

		case EWlanSecurity802d1x:  // Fallthrough on purpose

		case EWlanSecurityWapi:    // Fallthrough on purpose

		case EWlanSecurityWapiPsk:

			aMode = EWlanConnectionSecurity802d1x;

			break;

		case EWlanSecurityWpa: // Fallthrough on purpose

		case EWlanSecurityWpa2:

			aMode = EWlanConnectionSecurityWpa;

			break;

		case EWlanSecurityWpaPsk: // Fallthrough on purpose

		case EWlanSecurityWpa2Psk:

			aMode = EWlanConnectionSecurityWpaPsk;

			break;

		default:

			aMode = EWlanConnectionSecurityOpen;

			break;

        }

    return KErrNone;

    }

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

// CWlanMgmtImpl::GetAvailableIaps

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

//

TInt CWlanMgmtImpl::GetAvailableIaps(

    RArray<TUint>& aAvailableIaps )

    {

    TraceDump( INFO_LEVEL, ( _L( "CWlanMgmtImpl::GetAvailableIaps()" ) ) );

    TWlmAvailableIaps iaps;

    aAvailableIaps.Reset();

    iCacheLifetime = KWlanMgmtDefaultCacheLifetime;

    iMaxDelay = KWlanMgmtDefaultMaxDelay;

	TInt ret = iServer.GetAvailableIaps( iaps, iCacheLifetime, iMaxDelay );

	if ( ret != KErrNone )

		{

		return ret;

		}   

    for ( TUint idx( 0 ); idx < iaps.count; ++idx )

        {

        aAvailableIaps.Append( iaps.iaps[idx] );

        }

    return KErrNone;

    }

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

// CWlanMgmtImpl::GetAvailableIaps

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

//

void CWlanMgmtImpl::GetAvailableIaps(

    TRequestStatus& aStatus,

    RArray<TUint>& aAvailableIaps )

    {

    TraceDump( INFO_LEVEL, ( _L( "CWlanMgmtImpl::GetAvailableIaps() (async)" ) ) );

    aAvailableIaps.Reset();

    aStatus = KRequestPending;

    iPendingAvailableIapsStatus = &aStatus;    

    iCacheLifetime = KWlanMgmtDefaultCacheLifetime;

    iMaxDelay = KWlanMgmtDefaultMaxDelay;

	iAvailableIapsRequest = new CWlanAvailableIapsRequest( *this, iServer, aAvailableIaps, iCacheLifetime, iMaxDelay );

	if ( !iAvailableIapsRequest )

		{

		User::RequestComplete( iPendingAvailableIapsStatus, KErrNoMemory );

		iPendingAvailableIapsStatus = NULL;

		return;

		}

    iAvailableIapsRequest->IssueRequest();

    }

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

// CWlanMgmtImpl::GetAvailableIaps

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

//

void CWlanMgmtImpl::GetAvailableIaps(

	TInt& aCacheLifetime,

	TUint& aMaxDelay,

	TRequestStatus& aStatus,

    RArray<TUint>& aAvailableIaps )

    {

    TraceDump( INFO_LEVEL, ( _L( "CWlanMgmtImpl::GetAvailableIaps() (async)" ) ) );

    aAvailableIaps.Reset();

    aStatus = KRequestPending;

    iPendingAvailableIapsStatus = &aStatus;    

	iAvailableIapsRequest = new CWlanAvailableIapsRequest( *this, iServer, aAvailableIaps, aCacheLifetime, aMaxDelay );

	if ( !iAvailableIapsRequest )

		{

		User::RequestComplete( iPendingAvailableIapsStatus, KErrNoMemory );

		iPendingAvailableIapsStatus = NULL;

		return;

		}

    iAvailableIapsRequest->IssueRequest();

    }

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

// CWlanMgmtImpl::NotifyChangedSettings

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

//

void CWlanMgmtImpl::NotifyChangedSettings()

    {

    TraceDump( INFO_LEVEL, ( _L( "CWlanMgmtImpl::NotifyChangedSettings()" ) ) );

    iServer.NotifyChangedSettings();

    }

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

// CWlanMgmtImpl::AddBssidToBlacklist

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

//

TInt CWlanMgmtImpl::AddBssidToBlacklist(

    const TWlanBssid& aBssid )

    {

    TraceDump( INFO_LEVEL, ( _L( "CWlanMgmtImpl::AddBssidToBlacklist()" ) ) );

    TMacAddress bssid;

    Mem::Copy( &bssid.iMacAddress[0], aBssid.Ptr(), sizeof( TMacAddress ) );

    return iServer.AddBssidToRoguelist( bssid );

    }

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

// CWlanMgmtImpl::UpdateRssNotificationBoundary

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

//

TInt CWlanMgmtImpl::UpdateRssNotificationBoundary( 

    const TInt32 aRssLevelBoundary,

    const TInt32 aHysteresis )

    {

    // Do some basic checks:

    if( aRssLevelBoundary <= KRssMin || aRssLevelBoundary > KRssMax )

        {

        return KErrArgument;

        }

    if( aHysteresis <= KRssHysteresisMin || aHysteresis > KRssHysteresisMax)

        {

        return KErrArgument;

        }

    // RSSI -> RCPI Conversion

    TInt32 rcpLevelBoundary = ( 110 - aRssLevelBoundary ) * 2;

    // Hysteresis Conversion

    TInt32 hysteresis = ( ( 110 - ( aRssLevelBoundary - aHysteresis ) ) * 2 ) - rcpLevelBoundary;

    TraceDump( INFO_LEVEL, ( _L( "CWlanMgmtImpl::UpdateRssNotificationBoundary()" ) ) );

    TraceDump( INFO_LEVEL, ( _L( "RSS(%d, %d) -> RCP(%d, %d)" ),

        aRssLevelBoundary, aHysteresis,

        rcpLevelBoundary, hysteresis ) );

    return iServer.UpdateRcpNotificationBoundary( rcpLevelBoundary, hysteresis );

    }

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

// CWlanMgmtImpl::RunProtectedSetup