/*

* 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 CWsfSession

*

*/

//  CLASS HEADER

#include "wsfsession.h"

#include "wsfserver.h"

#include "wsfengine.h"

#include "wsfservercommon.h"

#include "wsfwlaninfo.h"

#include "wsflogger.h"

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

// CWsfSession::CWsfSession

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

//

CWsfSession::CWsfSession( CWsfServer& aServer ): 

    iServer( aServer ), 

    iRequestNotify( EFalse ),

    iEnabledScanning( EFalse )

    {

    }

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

// CWsfSession::NewL

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

//

CWsfSession* CWsfSession::NewL( CWsfServer& aServer )

    {

    CWsfSession* thisPtr = new (ELeave) CWsfSession( aServer );

    CleanupStack::PushL( thisPtr );

    thisPtr->ConstructL();

    CleanupStack::Pop( thisPtr );

    return thisPtr; 

    }

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

// CWsfSession::~CWsfSession

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

//

CWsfSession::~CWsfSession()

    {

    LOG_ENTERFN( "CWsfSession::~CWsfSession" );

    CancelPendingTasks();

    iServer.Engine()->Detach( this );

    iServer.ClientRelease();

    iEventQueue.Close();

    }

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

// CWsfSession::ConstructL

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

//

void CWsfSession::ConstructL()

    {

    iServer.ClientAttach();

    iServer.Engine()->AttachL( this );

    iEnabledScanning = iServer.Engine()->IsScanning();

    }

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

// CWsfSession::ServiceL

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

//

void CWsfSession::ServiceL( const RMessage2& aMessage )

    {

    TRAPD( err, DispatchMessageL( aMessage ) );

    if ( err != KErrNone )

        {

        LOG_WRITEF( "CWsfSession::ServiceL DispatchMessageL leave error = %d", 

                    err );

        aMessage.Complete( err );

        }

    }

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

// CWsfSession::DispatchMessageL

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

//

void CWsfSession::DispatchMessageL( const RMessage2& aMessage )

    {

    LOG_ENTERFN( "CWsfSession::DispatchMessageL" );

    LOG_WRITEF( "CWsfSession::DispatchMessageL message = %d", 

                aMessage.Function() );

    switch ( aMessage.Function() )

        {

        case ESnifferCmdWlanDataSize:

            {

            ReplyWlanDataSizeL( aMessage );

            aMessage.Complete( KErrNone );

            break;

            }

        case ESnifferCmdNotifyEvents:

            {

            RequestNotifyL( aMessage );    

            break;

            }

        case ESnifferCmdCancelNotifyEvents:

            {

            CancelNotifyEvents();    

            aMessage.Complete( KErrNone );

            break;

            }

        case ESnifferCmdGetWlanInfo:

            {

            WriteWlanDataL( aMessage );

            aMessage.Complete( KErrNone );

            break;

            }    

        case ESnifferCmdConnect:

            {

            ConnectWlanL( aMessage );

            aMessage.Complete( KErrNone );    

            break;

            }

        case ESnifferCmdDisconnect:

            {

            DisconnectWlanL( aMessage );

            aMessage.Complete( KErrNone );    

            break;

            }

        case ESnifferCmdActivateScan:

            {

            ActivateScanL();    

            aMessage.Complete( KErrNone );

            break;

            }

        case ESnifferCmdDisableScan:

            {

            DisableScanL();

            aMessage.Complete( KErrNone ); 

            break;

            }

        case ESnifferCmdConnectionName:

            {

            GetConnectedAccountNameL( aMessage );          

            aMessage.Complete( KErrNone );    

            break;     

            }

        case ESnifferCmdCancelAll:

            {

            CancelPendingTasks();

            aMessage.Complete( KErrNone );

            break;

            }             

        case ESnifferCmdRequestScan:

            {

            RequestScanL( aMessage );

            aMessage.Complete( KErrNone );

            break;

            }

        case ESnifferCmdMonitorAp:

            {

            MonitorApL( aMessage );

            aMessage.Complete( KErrNone );                

            break;    

            }

        case ESnifferCmdIsScanEnabled:

            {

            ReplyIsScanningL(aMessage); 

            aMessage.Complete( KErrNone );    

            break;

            }

        case ESnifferCmdIsConnected:

            {

            IsConnectedL( aMessage );

            aMessage.Complete( KErrNone );

            break;

            }

        case ESnifferCmdConnectedDetails:

            {

            GetConnectedDetailsL( aMessage );

            aMessage.Complete( KErrNone );

            break;

            }

        case ESnifferCmdAbortScanning:

            {

            AbortScanning();

            aMessage.Complete( KErrNone );

            break;

            }

        case ESnifferCmdAbortConnecting:

            {

            AbortConnectingL();

            aMessage.Complete( KErrNone );

            break;

            }

        case ESnifferCmdSetIapPersistence:

            {

            SetIapPersistenceL( aMessage );

            aMessage.Complete( KErrNone );

            break;

            }

        case ESnifferCmdControlDisconnectTimer:

            {

            ControlDisconnectTimerL( aMessage );

            aMessage.Complete( KErrNone );

            break;

            }

        // requests we don't understand at all are a different thing,

        // so panic the client here, this function also completes the message

        default:

            {

            _LIT( KWsfServerPanic, "WlanSnifferServer" );

            aMessage.Panic( KWsfServerPanic, 1 );

            }

        }

    }

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

// CWsfSession::RequestNotify

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

//        

void CWsfSession::RequestNotifyL( const RMessage2& aMessage )

    {

    LOG_ENTERFN( "CWsfSession::RequestNotifyL" );

    if ( !iRequestNotify )

        {

        LOG_WRITE( "CWsfSession::RequestNotifyL first subscription" );

        // first subscription

        iRequestNotify = ETrue;

        iEventQueue.Reset();

        }

    // initial value / processing finished

    iProcessingEvent = EFalse;

    // store the message to be completed

    iNotifyChangesMessage = aMessage;

    // deal with the queue

    if ( iEventQueue.Count() )

        {

        LOG_WRITE( "CWsfSession::RequestNotifyL queue not empty" );

        NotifyClientL();

        }

    }

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

// CWsfSession::CancelNotifyEvents

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

//        

void CWsfSession::CancelNotifyEvents()

    {

    LOG_ENTERFN( "CWsfSession::CancelNotifyEvents" );

    // interrupt ongoing event handling

    iProcessingEvent = EFalse;

    if ( !iNotifyChangesMessage.IsNull() )

        {

        iNotifyChangesMessage.Complete( KErrCancel );

        }

    // unsubscribe

    iRequestNotify = EFalse;

    // drop all waiting events

    iEventQueue.Reset();

    }

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

// CWsfSession::CancelPendingTasks

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

//        

void CWsfSession::CancelPendingTasks()

    {

    LOG_ENTERFN( "CWsfSession::CancelPendingTasks" );

    if ( iEnabledScanning )

        {

        TRAP_IGNORE( iServer.Engine()->DisableScanningL() );

        }

    CancelNotifyEvents();

    }

// from MWsfEngineObserver

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

// CWsfSession::WlanListChangedL

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

//    

void CWsfSession::WlanListChangedL()

    {    

    LOG_ENTERFN( "CWsfSession::WlanListChangedL" );

    TWsfNotifyEventContainer event = { EEngineWlanDataChanged, KErrNone };

    iEventQueue.AppendL( event );

    NotifyClientL();

    }

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

// CWsfSession::NotifyErrorL

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

//    

void CWsfSession::NotifyErrorL( TInt aError )

    {

    LOG_ENTERFN( "CWsfSession::NotifyErrorL" );

    TWsfNotifyEventContainer event = { EEngineError, aError };

    iEventQueue.AppendL( event );

    NotifyClientL();

    }

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

// CWsfSession::ScanEnabledL

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

//    

void CWsfSession::ScanEnabledL()

    {

    LOG_ENTERFN( "CWsfSession::ScanEnabledL" );

    iEnabledScanning = ETrue;

    TWsfNotifyEventContainer event = { EEngineScanEnabled, KErrNone };

    iEventQueue.AppendL( event );

    NotifyClientL();

    }

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

// CWsfSession::ScanDisabledL

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

//    

void CWsfSession::ScanDisabledL()

    {

    LOG_ENTERFN( "CWsfSession::ScanDisabledL" );

    iEnabledScanning = EFalse;

    TWsfNotifyEventContainer event = { EEngineScanDisabled, KErrNone };

    iEventQueue.AppendL( event );

    NotifyClientL();

    }

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

// CWsfSession::ConnectedL

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

//    

void CWsfSession::ConnectedL()

    {

    LOG_ENTERFN( "CWsfSession::ConnectedL" );

    TWsfNotifyEventContainer event = { EEngineConnected, KErrNone };

    iEventQueue.AppendL( event );

    NotifyClientL();

    }

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

// CWsfSession::DisconnectedL

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

//    

void CWsfSession::DisconnectedL()

    {

    LOG_ENTERFN( "CWsfSession::DisconnectedL" );

    TWsfNotifyEventContainer event = { EEngineDisconnected, KErrNone };

    iEventQueue.AppendL( event );

    NotifyClientL();

    }

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

// CWsfSession::ConnectingFailedL

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

//    

void CWsfSession::ConnectingFailedL( TInt aError )

    {

    LOG_ENTERFN( "CWsfSession::ConnectingFailedL" );

    TWsfNotifyEventContainer event = { EEngineConnectingFailed, aError };

    iEventQueue.AppendL( event );

    NotifyClientL();

    }

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

// CWsfSession::NotifyClientL

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

//    

void CWsfSession::NotifyClientL()

    {

    LOG_ENTERFN( "CWsfSession::NotifyClientL" );

    if ( iRequestNotify && !iProcessingEvent )

        {

        LOG_WRITE( "CWsfSession::NotifyClientL notify" );

        TPckgBuf<TWsfNotifyEventContainer> container( iEventQueue[0] );

        iNotifyChangesMessage.WriteL( 0, container );

        // remove the item that we have just handed over

        iEventQueue.Remove( 0 );

        iProcessingEvent = ETrue;

        iNotifyChangesMessage.Complete( KErrNone );

        }

    }

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

// CWsfSession::GetConnectedAccountNameL

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

//

void CWsfSession::GetConnectedAccountNameL( const RMessage2& aMessage )

    {

    LOG_ENTERFN( "CWsfSession::GetConnectedAccountNameL" );    

    HBufC* iapName = iServer.Engine()->ConnectedWlanSsidL();

    CleanupStack::PushL( iapName );

    TPckgBuf<TWsfQueryConnectedAccount> package;

    TInt maxLen = package().iConnectedAccountName.MaxLength();

    if ( iapName->Length() )

        {

        if ( iapName->Length() > maxLen )

            {

            package().iConnectedAccountName.Copy( iapName->Ptr(), maxLen );    

            }

        else

            {

            package().iConnectedAccountName.Copy( *iapName );

            }

        package().iConnected = ETrue;

        }

    else

        {

        package().iConnected = EFalse;

        }    

    aMessage.WriteL( 0, package );

    CleanupStack::PopAndDestroy( iapName );        

    }

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

// CWsfSession::GetConnectedDetailsL

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

//

void CWsfSession::GetConnectedDetailsL( const RMessage2& aMessage )

    {

    LOG_ENTERFN( "CWsfSession::GetConnectedDetailsL" );    

    TPckgBuf<TWsfWlanInfo> package;

    TPckgBuf<TBool> ret( ETrue );

    if ( !iServer.Engine()->ConnectedWlanConnectionDetailsL( package() ) )

        {

        LOG_WRITE( "engine returned false, so wlaninfo is marked as invalid" );

        ret() = EFalse;

        }

    aMessage.WriteL( 0, ret );

    aMessage.WriteL( 1, package );

    }

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

// CWsfSession::ReplyWlanDataSizeL

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

//

void CWsfSession::ReplyWlanDataSizeL( const RMessage2& aMessage )

    {

    LOG_ENTERFN( "CWsfSession::ReplyWlanDataSizeL" );

    const TInt KInvalidLength = 0;

    TPckgBuf<TUint> p( KInvalidLength );

    HBufC8* results = iServer.Engine()->GetScanResults();

    if ( results )

        {

        p() = results->Length();

        }

    aMessage.WriteL( 0, p );

    }

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

// CWsfSession::WriteWlanDataL

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

//

void CWsfSession::WriteWlanDataL( const RMessage2& aMessage )

    {