/*

* Copyright (c) 2002-2006 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 HotSpot Server Session

*

*/

// INCLUDE FILES

#include "hotspotserver.h"

#include "hotspotsession.h"

#include "hssnotif.h"

#include "hsslogintimer.h"

#include "hsslogouttimer.h"

#include "hssclientinterface.h"

#include "am_debug.h"

#include <internetconnectivitycrkeys.h>

#include <WlanCdbCols.h>

#include <starterclient.h>

#include <cmmanagerext.h>

#include <e32std.h>

#include <ecom.h>

#include <f32file.h>

#include <apgcli.h>

// Forward declarations

class CWlanMgmtClient;

class MWlanMgmtNotifications;

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

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

// CHotSpotPluginSession

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

//

CHotSpotSession::CHotSpotSession( CHotSpotServer& aServer ) :

    iServer( aServer ), iClient( NULL ), iSrvNotifications ( NULL ), 

    iNotificationHandle( NULL ), iAllowNotifications( ETrue ), iHotspotExtension( ETrue )

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

// ConstructL

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

//

void CHotSpotSession::ConstructL()

    {

    DEBUG( "CHotSpotSession::ConstructL()" );

    iIapSettingsHandler = CHssIapSettingsHandler::NewL();

    iLoginTimer = CHssLoginTimer::NewL( *this );

    iLogoutTimer = CHssLogoutTimer::NewL( *this );

    iMgtClient = CWlanMgmtClient::NewL();

    }

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

// NewL

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

//

CHotSpotSession* CHotSpotSession::NewL( CHotSpotServer& aServer )

    {

    CHotSpotSession* self = new( ELeave ) CHotSpotSession( aServer );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self ); // Should this class have a 2-way constructor?

    return self;

    }

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

// ~CHotSpotSession

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

//

CHotSpotSession::~CHotSpotSession()

        {

        iMgtClient->CancelNotifications();

        delete iMgtClient;

        }

        {

        delete iIapSettingsHandler;

        }

    if ( iClient != NULL )

        {

        delete iClient;

        }

    if ( iNotifications != NULL )

        {

        delete iNotifications;

        }

    if ( iLoginTimer != NULL )

        {

        iLoginTimer->Cancel();

        delete iLoginTimer;

        }

    if ( iLogoutTimer != NULL )

        {

        iLogoutTimer->Cancel();

        delete iLogoutTimer;

        }

    if ( iIcts != NULL )

        {

        delete iIcts;

        }

    DEBUG( "CHotSpotSession::~CHotSpotSession() Done" );

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

// ServiceL

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

//

void CHotSpotSession::ServiceL( const RMessage2& aMessage )

        {

        // Something went wrong. Complete message to let

        // the client to continue

        aMessage.Complete(err);

        } 

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

// ServiceL

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

//

void CHotSpotSession::DispatchMessageL( const RMessage2& aMessage )

    {

    DEBUG( "CHotSpotSession::DispatchMessageL()" );

    TUint value1(NULL);

    TInt value2(NULL);

    TInt err(KErrNone);

    TInt indx(KErrNone);

    TPckgBuf<TInt> iapPackage( iIapId );

    switch ( aMessage.Function() )

        {

        case EHssActivateNotifications :

            iAllowNotifications = EFalse;

            HandleOrderNotifications( aMessage );

            break;

        case EHssCancelNotifications :

            break;

        case EHssGetScanResults :

            // Handled now in client side. Left here for future use.

            break;

        case EHssRegister :

            break;

        case EHssUnRegister :

            break;

        case EHssJoin :

            // IAP id

            value1 = ( TInt )aMessage.Int0();

            iIapId = value1;

            indx = iServer.FindMessage(value1, EHssStart );

            if ( indx >= 0 )

                {

                }

            else

                {

                indx = iServer.FindMessage(value1, EHssStartAgain );

                if ( indx >= 0 )

                    {

                    iServer.CompleteMessage( indx , KErrNone );

                    }

                }

            aMessage.Complete( KErrNone );

            break;

        case EHssCancelStart :

            iServer.SetLogoutFlag( ETrue );

            // Do not send association status to client

            iServer.SetAssociationFlag( EFalse ); 

             // IAP id

            iIapId = ( TInt )aMessage.Int0();

            indx = iServer.FindMessage(iIapId, EHssStart );

            if ( indx >= 0 )

                if ( indx >= 0 )

                }

            aMessage.Complete( KErrNone );

            break;

        case EHssStop :

            iAllowNotifications = EFalse;

            iLogoutTimer->Cancel();

            // IAP id

            value1 = ( TInt )aMessage.Int0();

            for (TInt counter = EHssGetScanResults; counter <EHssServerShutdown ;counter++)

            aMessage.Complete( KErrNone );

            break;

        case EHssLoginComplete :

            // IAP id

            value1 = ( TInt )aMessage.Int0();

            // ret value

            value2 = ( TInt )aMessage.Int1();

            iLoginTimer->Cancel();

            DEBUG1( "EHssLoginComplete value2: %d", value2 );

            indx = iServer.FindMessage( value1, EHssStartLogin );

            if ( KErrNotFound != indx )

                {

                    iServer.SetLogoutFlag( ETrue );

                }

            aMessage.Complete( KErrNone );

            break;

        case EHssLogoutComplete :

            // IAP id

            value1 = ( TInt )aMessage.Int0();

            indx = iServer.FindMessage( value1, EHssCloseConnection );

            if ( KErrNotFound != indx )

                {

                iServer.CompleteMessage( indx, KErrNone );    

                }

            aMessage.Complete( KErrNone );

            break;

        case EHssStartLogin :

            // Do not send association status, since it's already done.

            iServer.SetAssociationFlag( EFalse ); 

            // IAP id

            iIapId = ( TInt )aMessage.Int0();

            // Network id

            iNetId = ( TInt )aMessage.Int1();

            err = iServer.SaveMessage( iIapId, aMessage, EHssStartLogin ); 

            if ( KErrNone != err )

                {

                aMessage.Complete( err );  

                }

            else

                {

                err = ProcessStartLoginL( iIapId, iNetId );

                // If client not found, an error was returned. 

                // Otherwise message completed elsewhere. 

                if ( KErrNone != err )

                    {

                    indx = iServer.FindMessage(iIapId, EHssStartLogin );

                    if ( indx >= 0 )

                        {

                        iServer.CompleteMessage( indx , KErrNone );

                        }

                    else

                        {

                        aMessage.Complete( KErrNone );

                        }

                    }

                }

            break;

        case EHssCancelLogin :

            // if client doesn't exist (is NULL), Login(.) has not been 

            // called to client -> that is CancelLogin() not needed to call

            if ( iClient != NULL )

                {

                iClient->CancelLogin( iIapId );

                }

            indx = iServer.FindMessage(iIapId, EHssStartLogin );

            if ( indx >= 0 )

                {

                iServer.CompleteMessage( indx , err );

                }

            aMessage.Complete( KErrNone );

            break;

        case EHssStart:

            err = iServer.SaveMessage( iIapId, aMessage, EHssStart ); 

           if ( err != KErrNone)

                {

                aMessage.Complete( err );  

                }

            else

                {

                TRAPD( startLeaved, err = ProcessStartL( iIapId ) );

                if ( startLeaved != KErrNone)

                    {

                    indx = iServer.FindMessage(iIapId, EHssStart );

                    if ( indx >= 0 )

                        {

                        iServer.CompleteMessage( indx , KErrNotSupported );

                        }

                    else

                        {

                        aMessage.Complete( KErrNotSupported );

                        }

                    }

                else if ( err != KErrNone)

                    {

                    indx = iServer.FindMessage(iIapId, EHssStart );

                    if ( indx >= 0 )

                        {

                        iServer.CompleteMessage( indx , KErrNotSupported );

                        }

                    else

                        {

                        aMessage.Complete( KErrNotSupported );

                        }

                    }

                // else -> client is created and called 

                // WLAN agent waits for 30 seconds before continuing connection setup.

                }

            break;

        case EHssStartAgain:

            err = iServer.SaveMessage( iIapId, aMessage, EHssStartAgain ); 

           if ( err != KErrNone)

                {

                aMessage.Complete( err );  

                }

            else

                {

                err = ProcessStartAgain( iIapId );

                if (   err != KErrNone)

                    {

                    indx = iServer.FindMessage(iIapId, EHssStartAgain );

                    if ( indx >= 0 )

                        {

                        iServer.CompleteMessage( indx , err );

                        }

                    else

                        {

                        aMessage.Complete( err );

                        }

                    }

                }

        case EHssCancel:

            iLogoutTimer->Cancel();

            if ( iServer.GetAssociationFlagValue() )

                {

                // We are in association phase and Agent failed it for some reason

                ProcessAssociationStatus( iIapId, EFalse );

                }

            indx = iServer.FindMessage(iIapId, EHssStart );

            if ( indx >= 0 )

            indx = iServer.FindMessage(iIapId, EHssStartAgain );

            if ( indx >= 0 )

            indx = iServer.FindMessage(iIapId, EHssCloseConnection );

            if ( indx >= 0 )

            //Not needed to send Logout()

            //iServer.SetLogoutFlag( ETrue )

            //ProcessCloseL( iIapId )

        break;

        case EHssCloseConnection:

            iLoginTimer->Cancel();

            if ( iServer.GetAssociationFlagValue() )

                {

                // We are in association phase and Agent failed it for some reason

                ProcessAssociationStatus( iIapId, EFalse );

                }

            err = iServer.SaveMessage( iIapId, aMessage, EHssCloseConnection ); 

            if ( KErrNone != err )

                {

                aMessage.Complete( err );  

                }

            else

                {

                err = ProcessCloseL( iIapId );

                // If client not found, an error was returned. 

                // Otherwise message completed elsewhere. 

                if ( KErrNone != err )

                    {

                    indx = iServer.FindMessage(iIapId, EHssCloseConnection );

                    if ( indx >= 0 )

                        {

                        iServer.CompleteMessage( indx , KErrNone );

                        }

                    else

                        {

                        aMessage.Complete( KErrNone );

                        }

                    }

                }

            break;

        case EHssServerShutdown:

            ProcessServerShutdown( aMessage );

            break;

        case EHssGetIAP:

            aMessage.Complete( KErrNone );

            break;

        case EHssUiState:

            ProcessUiState( aMessage );

            break;

        case EHssStartBrowser:

            {   

            TPtr ptr( buf->Des() );

            User::LeaveIfError( aMessage.Read( 0, ptr ) );     

            AuthenticateL( ptr );

            CleanupStack::PopAndDestroy(buf);

            }

        case EHssSetTimerValues:

            {

            TUid clientUid( TUid::Uid( aMessage.Int0() ) );

            TUint loginTimerValue = aMessage.Int1();

            TUint logoutTimerValue = aMessage.Int2();

            iServer.SetTimerValues( clientUid, loginTimerValue, logoutTimerValue );

            aMessage.Complete( KErrNone );

            }

            break;