/*

* Copyright (c) 2007 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.

*

*/

#include "CWLanBearerMonitor.h"

#include "sipbearerowner.h"

#include "CWLanConnUsagePermissionMonitor.h"

#include "sipwlanlog.h"

#include <wlanerrorcodes.h>

const TInt KCompletionTime = 1;

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

// CWLanBearerMonitor::NewL

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

//

CWLanBearerMonitor* CWLanBearerMonitor::NewL( TAny* aParams )

	{

	CWLanBearerMonitor* self = new( ELeave ) CWLanBearerMonitor( aParams );

	CleanupClosePushL( *self );

	self->ConstructL();

	CleanupStack::Pop(); // self

	return self;

	}

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

// CWLanBearerMonitor::~CWLanBearerMonitor

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

//

CWLanBearerMonitor::~CWLanBearerMonitor()

	{

	if( iAsyncCompletionTimer )

	    {

    	iAsyncCompletionTimer->Remove( iTimerEntry );

	    }

    delete iAsyncCompletionTimer;

	delete iUsagePermissionMonitor;

	// Cancel notifications and close connection monitor session

	iConnMon.CancelNotifications();

	iConnMon.Close();

	}

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

// CWLanBearerMonitor::RefreshL

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

//	

void CWLanBearerMonitor::RefreshL( TInt aError )

    {  

    SIPWLAN_LOG("CWLanBearerMonitor::RefreshL, calling SetCurrentAvailabilityL()")

    SetCurrentAvailabilityL();

	if(!aError)

	{

    SIPWLAN_LOG("CWLanBearerMonitor::RefreshL, calling IssueActivityNotification()")

    IssueActivityNotification();

	}

    }

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

// CWLanBearerMonitor::ContinueMonitoring

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

//        

TBool CWLanBearerMonitor::ContinueMonitoring( TInt aError )

    {

    SIPWLAN_INTLOG("CWLanBearerMonitor::ContinueMonitoring", aError)

    return !IapSettingsInvalid( aError );

    }

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

// CWLanBearerMonitor::EventL

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

//

void CWLanBearerMonitor::EventL( const CConnMonEventBase& aConnMonEvent )

    {

    SIPWLAN_LOG("CWLanBearerMonitor::EventL")

	// We're interested only on iap availability notifications

	if( ( aConnMonEvent.EventType() == EConnMonIapAvailabilityChange ) &&

		( aConnMonEvent.ConnectionId() == EBearerIdAll ) )

	    {	    

	    // Typecast event to appropriate event type

		const CConnMonIapAvailabilityChange& event =

			static_cast< const CConnMonIapAvailabilityChange& >( aConnMonEvent );

		// Check availability and report to our owner

		MSIPNetworkObserver::TNetworkState newState = 

		    IsAvailable( event.IapAvailability(), iIapId ) ? 

            	    MSIPNetworkObserver::ENetworkActive : 

            	    MSIPNetworkObserver::ENetworkInactive;

        SIPWLAN_INTLOG("CWLanBearerMonitor::EventL: new state", newState)

        // Report only if state of monitored iap changed

	    if ( iState != newState )

	        {

	        iState = newState;

	        iParent.BearerStateChanged( this, KErrNone );

	        }

	    }

	}

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

// CWLanBearerMonitor::UsagePermissionChanged

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

//	

void CWLanBearerMonitor::UsagePermissionChanged( 

    TBool aPermissionToUse, 

    TInt aError )

    {

    iUsagePermission = aPermissionToUse;

    if ( !aError )

        {

        // Don't wait for availability changed event if not necessary since

        // it may take several minutes (even if IAP is already available).

        TRAP( aError, SetCurrentAvailabilityL() );

        }

    IssueActivityNotification( aError );

    }

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

// CWLanBearerMonitor::CompletionCallback

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

//

TInt CWLanBearerMonitor::CompletionCallback( TAny* aAny )

	{

	CWLanBearerMonitor* self = 

	    reinterpret_cast< CWLanBearerMonitor* >( aAny );

    if ( self )

        {

        self->InformActivity();

        }

	return KErrNone;

	}

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

// CWLanBearerMonitor::CWLanBearerMonitor

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

//

CWLanBearerMonitor::CWLanBearerMonitor( TAny* aParams )	: 

    CSIPBearerMonitor( aParams ),

	iCallBack( CompletionCallback, this ),

	iTimerEntry( iCallBack ),

	iLastError( KErrNone )

	{

	}

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

// CWLanBearerMonitor::ConstructL

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

//

void CWLanBearerMonitor::ConstructL()

	{

	// These are really very peculiar functions. They can

	// both leave AND return an error code..

	User::LeaveIfError( iConnMon.ConnectL() );

	User::LeaveIfError( iConnMon.NotifyEventL( *this ) );

	iUsagePermissionMonitor = CWLanConnUsagePermissionMonitor::NewL( *this );

	iAsyncCompletionTimer = CDeltaTimer::NewL( CActive::EPriorityStandard );

    SetCurrentAvailabilityL();

    iUsagePermission = iUsagePermissionMonitor->CurrentUsagePermissionL();

    IssueActivityNotification();

	}

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

// CWLanBearerMonitor::SetCurrentAvailabilityL

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

//

void CWLanBearerMonitor::SetCurrentAvailabilityL()

    {                         

    // Get current availability of this monitor owner's wlan access point

    // and set current network state according it

    //

    TConnMonIapInfoBuf iapInfo;

	TRequestStatus status;

	iConnMon.GetPckgAttribute( EBearerIdWLAN, 0, KIapAvailability,

							   iapInfo, status );

	User::WaitForRequest( status );

	User::LeaveIfError( status.Int() );

	iState = IsAvailable( iapInfo(), iIapId ) ? 

            	    MSIPNetworkObserver::ENetworkActive : 

            	    MSIPNetworkObserver::ENetworkInactive;

    SIPWLAN_INTLOG("CWLanBearerMonitor::SetCurrentAvailabilityL", iState)        	    

    }

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

// CWLanBearerMonitor::IsAvailable

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

//

TBool CWLanBearerMonitor::IsAvailable( 

    const TConnMonIapInfo& aIapInfo, 

    TInt aIapId )

    {

    // Check if aIapId is in the list of available access points

    TInt count = aIapInfo.iCount;

    for ( TInt i = 0; i < count; i++ )

        {

        if ( aIapInfo.iIap[ i ].iIapId == aIapId )

            {

            return ETrue;

            }

        }

    return EFalse;

    }

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

// CWLanBearerMonitor::IssueActivityNotification

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

//    

void CWLanBearerMonitor::IssueActivityNotification( TInt aError )

    {

    // Notify activity asynchronously

    iAsyncCompletionTimer->Remove( iTimerEntry );

    iAsyncCompletionTimer->Queue( KCompletionTime, iTimerEntry );

    iLastError = aError;

    }

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

// CWLanBearerMonitor::InformActivity

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

//    

void CWLanBearerMonitor::InformActivity()

    {

    if ( iLastError ||

       ( iState == MSIPNetworkObserver::ENetworkActive && iUsagePermission ) )

        {

        iParent.BearerStateChanged( this, iLastError );

        }

    }

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

// CWLanBearerMonitor::IapSettingsInvalid

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

//

TBool CWLanBearerMonitor::IapSettingsInvalid( TInt aError ) const

    {

    if ( aError == KErrNotFound || 

         aError == KErrBadName ||

         aError == KErrNotSupported ||

         aError == KErrWlanOpenAuthFailed ||

         aError == KErrWlanSharedKeyAuthRequired ||

         aError == KErrWlanSharedKeyAuthFailed ||

         aError == KErrWlanWpaAuthRequired ||

         aError == KErrWlanIllegalEncryptionKeys ||

         aError == KErrWlanPskModeRequired ||

         aError == KErrWlanEapModeRequired ||

         aError == KErrWlanSimNotInstalled ||

         aError == KErrWlanNotSubscribed ||

         aError == KErrWlanAccessBarred ||

         aError == KErrWlanPasswordExpired ||

         aError == KErrWlanNoDialinPermissions ||

         aError == KErrWlanAccountDisabled ||

         aError == KErrWlanRestrictedLogonHours ||

         aError == KErrWlanServerCertificateExpired ||

         aError == KErrWlanCerficateVerifyFailed ||

         aError == KErrWlanNoUserCertificate ||

         aError == KErrWlanNoCipherSuite ||

         aError == KErrWlanUserRejected ||

         aError == KErrWlanUserCertificateExpired)

        {

	SIPWLAN_INTLOG("CWLanBearerMonitor::IapSettingsInvalid, Fatal", aError)

        return ETrue;

        }

	else if(

		aError == KErrWlanWpaAuthFailed ||

		aError == KErrWlan802dot1xAuthFailed ||

		aError == KErrWlanIllegalWpaPskKey ||

		aError == KErrWlanEapSimFailed ||

		aError == KErrWlanEapTlsFailed ||

        aError == KErrWlanEapPeapFailed ||

		aError == KErrWlanEapMsChapv2 ||

        aError == KErrWlanEapAkaFailed ||

        aError == KErrWlanEapTtlsFailed ||

		aError == KErrWlanLeapFailed ||

		aError == KErrWlanEapGtcFailed )

		{

	SIPWLAN_INTLOG("CWLanBearerMonitor::IapSettingsInvalid, Less Fatal", aError)

		return EFalse;

		}

    return EFalse;

    }

// End of File