/*

* 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 <WlanCdbCols.h>

#include <starterclient.h>

#include <e32std.h>

#include <ecom.h>

#include <f32file.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()

    {

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

    iPendingNotifications.Close();

    if ( iMgtClient != NULL )

        {

        iMgtClient->CancelNotifications();

        delete iMgtClient;

        }

    if ( iIapSettingsHandler != NULL )

        {

        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;

        }

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

    }

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

// ServiceL

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

//

void CHotSpotSession::ServiceL( const RMessage2& aMessage )

    {

    DEBUG1( "CHotSpotSession::ServiceL message: %d", aMessage.Function() );

    TRAPD( err, DispatchMessageL( aMessage) );

    if (err != KErrNone)

        {

        // Something went wrong. Complete message to let

        // the client to continue

        aMessage.Complete(err);

        } 

    }

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

// ServiceL

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

//

void CHotSpotSession::DispatchMessageL( const RMessage2& aMessage )

    {

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

    TInt value( NULL );

    TInt err( KErrNone );

    TInt indx( KErrNone );

    TPckgBuf<TInt> iapPackage( iIapId );

    switch ( aMessage.Function() )

        {

        case EHssActivateNotifications :

            DEBUG( "CHotSpotSession::ActivateNotificationsL" );

            iAllowNotifications = EFalse;

            if ( iNotifications == NULL )

                {

                iNotifications = new ( ELeave ) HssNotifications( *this );

                iMgtClient->ActivateNotificationsL( *iNotifications );

                }

            HandleOrderNotifications( aMessage );

            break;

        case EHssCancelNotifications :

            DEBUG( "CHotSpotSession::CancelNotifications" );

            iAllowNotifications = EFalse;

            iMgtClient->CancelNotifications( );

            if ( iNotifications != NULL )

                {

                delete iNotifications;

                }

            iNotifications = NULL;

            HandleCancelNotifications( aMessage );

            break;

        case EHssRegister :

            break;

        case EHssUnRegister :

            ProcessUnRegister( aMessage );

            break;

        case EHssJoin :

            iAllowNotifications = EFalse;

            iIapId = ( TInt )aMessage.Int0();

            indx = iServer.FindMessage( iIapId, EHssStart );

            if ( indx >= 0 )

                {

                iServer.CompleteMessage( indx , KErrNone );

                }

            else

                {

                indx = iServer.FindMessage( iIapId, 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 ); 

            iIapId = ( TInt )aMessage.Int0();

            indx = iServer.FindMessage(iIapId, EHssStart );

            if ( indx >= 0 )

                {

                iServer.CompleteMessage( indx , KErrAbort);

                }

            else

                {

                indx = iServer.FindMessage(iIapId, EHssStartAgain );

                if ( indx >= 0 )

                    {

                    iServer.CompleteMessage( indx , KErrAbort );

                    }

                }

            aMessage.Complete( KErrNone );

            break;

        case EHssStop :

            iAllowNotifications = EFalse;

            iServer.SetLogoutFlag( ETrue );

            iLoginTimer->Cancel();

            iLogoutTimer->Cancel();

            iIapId = ( TInt )aMessage.Int0();

            for ( TInt counter = EHssGetScanResults; 

                  counter <EHssServerShutdown ;counter++ )

                {

                indx = iServer.FindMessage( iIapId, 

                                            THotSpotCommands( counter ) );

                if ( indx >= 0 )

                    {

                    iServer.CompleteMessage( indx , KErrCancel );

                    }

                }

            aMessage.Complete( KErrNone );

            break;

        case EHssLoginComplete :

            iAllowNotifications = EFalse;

            iLoginTimer->Cancel();

            iIapId = ( TInt )aMessage.Int0();

            value = ( TInt )aMessage.Int1();

            DEBUG1( "EHssLoginComplete return value: %d", value );

            indx = iServer.FindMessage( iIapId, EHssStartLogin );

            if ( KErrNotFound != indx )

                {

                if ( value == KErrNone )

                    {

                    DEBUG( "EHssLoginComplete1" );

                    iServer.CompleteMessage( indx, KErrNone );

                    }

                else

                    {

                    DEBUG( "EHssLoginComplete2" );

                    iServer.CompleteMessage( indx, KErrCancel );

                    iServer.SetLogoutFlag( ETrue );

                    }

                }

            aMessage.Complete( KErrNone );

            break;

        case EHssLogoutComplete :

            iAllowNotifications = EFalse;

            iLogoutTimer->Cancel();

            iIapId = ( TInt )aMessage.Int0();

            indx = iServer.FindMessage( iIapId, 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 ); 

            iIapId = ( TInt )aMessage.Int0();

            iNetId = ( TInt )aMessage.Int1();

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

            if ( KErrNone != err )

                {

                aMessage.Complete( err );  

                }

            else

                {

                err = ProcessStartLogin( 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 :

            iLoginTimer->Cancel();

            // 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:

            iServer.SetLoginFlag( ETrue );

            iIapId = ( TInt )aMessage.Int0();

            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 );

                        }

                    }

                }

            break;

        case EHssStartAgain:

            iServer.SetLoginFlag( ETrue );

            iIapId = ( TInt )aMessage.Int0();

            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 );

                        }

                    }

                }

            break;

        case EHssCancel:

            iLoginTimer->Cancel();

            iLogoutTimer->Cancel();

            iIapId = ( TInt )aMessage.Int0();

            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 )

                {

                iServer.CompleteMessage( indx , KErrCancel );

                }

            indx = iServer.FindMessage(iIapId, EHssStartAgain );

            if ( indx >= 0 )

                {

                iServer.CompleteMessage( indx , KErrCancel );

                }

            indx = iServer.FindMessage(iIapId, EHssCloseConnection );

            if ( indx >= 0 )

                {

                iServer.CompleteMessage( indx , KErrCancel );

                }

            aMessage.Complete( KErrNone );

            break;

        case EHssCloseConnection:

            iLoginTimer->Cancel();

            iLogoutTimer->Cancel();           

            iIapId = ( TInt )aMessage.Int0();

            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.WriteL( 0, iapPackage );

            aMessage.Complete( KErrNone );

            break;

        case EHssUiState:

            aMessage.Complete( KErrNotSupported );

            break;

        case EHssStartBrowser:

            {

            aMessage.Complete( KErrNotSupported );

            break;

            }

        case EHssSetTimerValues:

            {

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

            TBuf<KUidLength> uid;

            uid.Copy( clientUid.Name() );

            ModifyClientUid( uid );

            TUint loginTimerValue = aMessage.Int1();

            TUint logoutTimerValue = aMessage.Int2();

            aMessage.Complete( KErrNone );

            break;

            }

        default:

            aMessage.Complete( KErrNotSupported );  

            break;

        }

       iAllowNotifications = TRUE;

    }

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

// HandleOrderNotifications

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

//

void CHotSpotSession::HandleOrderNotifications( const RMessage2& aMessage )

    {

    iPendingNotificationRequest = aMessage;

    iIsNotificationRequestPending = ETrue;

    if( !iNotificationHandle ) // == NULL i.e. is not activated

        {

        TRAPD( err, iNotificationHandle = CSessionNotification::NewL( *this ) );

        if ( err == KErrNone )

            {

            iServer.NotifyAdd( *iNotificationHandle );

            }

        else

            {

            iIsNotificationRequestPending = EFalse;