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