/*

* Copyright (c) 2007-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:  Implementation of CWsfEventHandler

*

*/

//  CLASS HEADER

#include "wsfeventhandler.h"

//  INTERNAL INCLUDES

#include "wsfstatechangeobserver.h"

#include "wsflogger.h"

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

// CWsfEventHandler::NewL

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

//

CWsfEventHandler* CWsfEventHandler::NewL( RWsfSession& aSession, 

                                          MWsfStateChangeObserver& aObserver )

    {

    CWsfEventHandler* thisPtr = new (ELeave) CWsfEventHandler( aSession, 

                                                               aObserver );

    CleanupStack::PushL( thisPtr );

    thisPtr->ConstructL();

    CleanupStack::Pop( thisPtr );

    return thisPtr;

    }

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

// CWsfEventHandler::~CWsfEventHandler

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

//

CWsfEventHandler::~CWsfEventHandler()

    {

    Cancel();

    iSession = NULL;

    iObserver = NULL;

    }

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

// CWsfEventHandler::CWsfEventHandler

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

//

CWsfEventHandler::CWsfEventHandler( RWsfSession& aSession, 

                                    MWsfStateChangeObserver& aObserver ): 

    CActive( CActive::EPriorityStandard )

    {

    iSession = &aSession;

    iObserver = &aObserver;

    }

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

// CWsfEventHandler::ConstructL

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

//

void CWsfEventHandler::ConstructL()

    {

    CActiveScheduler::Add( this );

    }

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

// CWsfEventHandler::DoRunL

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

//

void CWsfEventHandler::DoRunL()

    {

    LOG_ENTERFN( "CWsfEventHandler::DoRunL" );    

    LOG_WRITEF( "CWsfEventHandler::DoRunL event = %d", iEvent().iEvent );    

    switch ( iEvent().iEvent )

        {

        case EEngineWlanDataChanged:

            {

            iObserver->WlanListChangedL();

            break;

            }

        case EEngineScanDisabled:

            {

            iObserver->ScanDisabledL();

            break;

            }

        case EEngineScanEnabled:

            {

            iObserver->ScanEnabledL();

            break;

            }

        case EEngineConnected:

            {

            if ( !iBlockConnectedEvent )

                {

                // if the event wasn't blocked, notify the observer

                iObserver->WlanConnectionActivatedL();

                }

            else

                {

                // if it was blocked, just clear the flag

                iBlockConnectedEvent = EFalse;

                }

            // anyhow, connecting process is finished

            if ( iConnecting )

                {

                iConnecting = EFalse;

                iSession->StopConnectingWait();

                iObserver->ConnectionCreationProcessFinishedL( 

                                        KErrNone );

                }

            break;

            }

        case EEngineDisconnected:

            {

            iObserver->WlanConnectionClosedL();

            break;

            }

        case EEngineError:

            {

            iObserver->NotifyEngineError( iEvent().iError );

            break;

            }

        case EEngineConnectingFailed:

            {

            if ( iConnecting )

                {

                // connecting is over

                iConnecting = EFalse;

                // make client return with KErrCancel

                iSession->iConnectingResult = iEvent().iError;

                iSession->StopConnectingWait();

                iObserver->ConnectionCreationProcessFinishedL( 

                        iSession->iConnectingResult );

                }

            break;

            }

        default:

            __ASSERT_DEBUG(0, _L("CWsfEventHandler - Invalid EngineEvent"));

            break;        

        }

    }

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

// CWsfEventHandler::RunL

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

//

void CWsfEventHandler::RunL()

    {

    LOG_ENTERFN( "CWsfEventHandler::RunL" );

    TInt notifyError( KErrNone );

    TBool reissue( ETrue );

    if ( iStatus.Int() >= KErrNone && iObserver )

        {

        TRAP( notifyError, DoRunL() );

        }

    if ( notifyError )

        {

        // notified class leaved

        LOG_WRITEF( "CWsfEventHandler::RunL notify error %d", notifyError );

        }

    else if ( iStatus.Int() != KErrNone )

        {

        if ( iStatus.Int() == KErrCancel )

            {

            // KErrCancel is the signal that we are going down

            LOG_WRITE( "going down..." );

            reissue = EFalse;

            }

        else

            {

            // error on the server side

            LOG_WRITEF( "CWsfEventHandler::RunL engine error %d", 

                        iStatus.Int() );

            TBool notify( ETrue );

            if ( iStatus.Int() == KErrServerTerminated )

                {

                reissue = EFalse;

                if ( iObserver

                        && iSession->RecoverFromServerTermination( *iObserver ) )

                    {

                    // no need to reissue if recovered since it is already

                    // done in the recovery process

                    notify = EFalse;

                    }

                }

            if ( notify && iObserver )

                {

                // let the client decide what to do

                iObserver->NotifyEngineError( iStatus.Int() );

                }

            }

        }

    if ( reissue && iObserver )

        {

        // reissue callback request

        iSession->NotifyEventL( *iObserver );

        }

    }

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

// CWsfEventHandler::DoCancel

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

//

void CWsfEventHandler::DoCancel()

    {

    LOG_ENTERFN( "CWsfEventHandler::DoCancel" );

    iSession->DoCancelNotifyEvent();

    }

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

// CWsfEventHandler::RunError

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

//

TInt CWsfEventHandler::RunError( TInt aError )

    {

    LOG_ENTERFN( "CWsfEventHandler::RunError" );

    LOG_WRITEF( "CWsfEventHandler::RunError error = %d", aError );

    if ( iObserver )

        {

        iObserver->NotifyEngineError( aError ) ;

        }

    return KErrNone; // we don't wan't to panic euser-47 - do we?

    }

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

// CWsfEventHandler::Start

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

//

void CWsfEventHandler::Start()

    {

    SetActive();

    }

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

// CWsfEventHandler::EventContainer

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

//

TPckgBuf<TWsfNotifyEventContainer>& CWsfEventHandler::EventContainer()

    {

    return iEvent;

    }

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

// CWsfEventHandler::ResetObserver

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

//

void CWsfEventHandler::ResetObserver( MWsfStateChangeObserver& aObserver )

    {

    LOG_ENTERFN( "CWsfEventHandler::ResetObserver" );

    iObserver = &aObserver;

    }

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

// CWsfEventHandler::BlockNextConnectedEvent

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

//

void CWsfEventHandler::BlockNextConnectedEvent()

    {

    LOG_ENTERFN( "CWsfEventHandler::BlockNextConnectedEvent" );

    if ( iConnecting )

        {

        LOG_WRITE( "iBlockConnectedEvent to true" );

        // set the flag only if we are the ones who are connecting

        iBlockConnectedEvent = ETrue;

        }

    }

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

// CWsfEventHandler::UnBlockNextConnectedEvent

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

//

void CWsfEventHandler::UnBlockNextConnectedEvent()

    {

    LOG_ENTERFN( "CWsfEventHandler::UnBlockNextConnectedEvent" );

    LOG_WRITE( "iBlockConnectedEvent to false" );

    iBlockConnectedEvent = EFalse;

    }

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

// CWsfEventHandler::SetConnecting

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

//

void CWsfEventHandler::SetConnecting( TBool aConnecting )

    {

    LOG_ENTERFN( "CWsfEventHandler::SetConnecting" );

    LOG_WRITEF( "iConnecting=%d, aConnecting=%d", iConnecting, aConnecting );

    iConnecting = aConnecting;

    }

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

// CWsfEventHandler::Connecting

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

//

TBool CWsfEventHandler::Connecting() const

    {

    return iConnecting;

    }