/*

* 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 Plugin Server

*

*/

// INCLUDE FILES

#include <e32std.h>

#include <f32file.h>

#include <wlanmgmtclient.h>

#include <wlanmgmtinterface.h>

#include <e32std.h>

#include <commsdattypesv1_1.h>

#include <cmconnectionmethodext.h>

#include <cmconnectionmethoddef.h>

#include <cmpluginwlandef.h>

#include <cmmanagerext.h>

#include <cmmanagerdef.h>

#include <cmdestinationext.h>

#include "hotspotserver.h"

#include "am_debug.h"

#include "hotspotsession.h"

#include "hssclientplugin.h"

#include "hssiapsettingshandler.h"

// LOCAL FUNCTION PROTOTYPES

GLDEF_C TInt E32Main();

using namespace CMManager;

// CONSTANTS

// Panic codes for HotSpot server

const TInt KHotSpotPanicCleanupStackCreationFailed  = 1;

const TInt KHotSpotPanicOpenSemaforeFailed          = 2;

const TInt KHotSpotPanicCreationOfSchedulerFailed   = 3;

// Default timeout values

const TUint KMillion = 1000000;

const TUint KHssDefaultLoginTimeMicroSecs = 180 * KMillion;  // 180 seconds (3 mins)

const TUint KHssMinLoginTime =      5;   // 5 seconds

const TUint KHssMaxLoginTime =      1200; // 1200 seconds (20 mins)

const TUint KHssDefaultLogoutTimeMicroSecs  = 12 * KMillion;   // 12 seconds

const TUint KHssMinLogoutTime =     1;    // 1 seconds

const TUint KHssMaxLogoutTime =     30;   // 30 seconds

// Panic category of HotSpot server 

_LIT( KHotSpotModuleName, "HOTSPOTSRV" );

// ============================= LOCAL FUNCTIONS ===============================

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

// RunServerL

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

// 

static void RunServerL()

    {

    User::LeaveIfError( User::RenameThread( KHotSpotServerName ) );

    CActiveScheduler* s=new(ELeave) CActiveScheduler;

    if ( !s )

        {

        User::Panic( KHotSpotModuleName, KHotSpotPanicCreationOfSchedulerFailed );

        }

    CleanupStack::PushL(s);

    CActiveScheduler::Install(s);

    CHotSpotServer::NewLC(); // Is NewLC: Server was pushed into cleanup stack.

    RSemaphore started;

    TInt err = started.CreateGlobal( KHotSpotServerSemaphore, 0 );

    if ( err != KErrNone )

        {

        err = started.OpenGlobal( KHotSpotServerSemaphore );

        }

    __ASSERT_ALWAYS(

        err == KErrNone, 

        User::Panic( KHotSpotModuleName, KHotSpotPanicOpenSemaforeFailed )

        );

    // lets everyone know that the thread is ready to deal with requests            

    RProcess::Rendezvous(KErrNone);

    started.Signal();

    started.Close();

    DEBUG("**** HotspotServer: server fully running");

    CActiveScheduler::Start();

    CleanupStack::PopAndDestroy( 2, s ); // Cleanup both server and scheduler

    REComSession::FinalClose();

    }

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

// PanicClient

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

//    

void PanicClient(const RMessagePtr2& aMessage,THotspotPanic aPanic)

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

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

// CHotSpotServer

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

//

CHotSpotServer::CHotSpotServer()

    {

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

// NewLC

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

//

CHotSpotServer* CHotSpotServer::NewLC()

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

// ~CHotSpotServer

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

//

CHotSpotServer::~CHotSpotServer()

    iMap.Close();

    iNotificationArray.Close();

    iLoginLogoutTimerArray.Close();

        {

        iMgtClient->CancelNotifications();

#endif

        delete iMgtClient;

        }

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

// ConstructL

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

//

void CHotSpotServer::ConstructL()

    {

    DEBUG("**** HotSpotServer: CHotSpotServer::ConstructL");

    StartL( KHotSpotServerName );

    iIapCheckValue = EFalse;

    iLogoutSent = EFalse;

    iLoginValue = ETrue;

    iAssociationValue = EFalse;

    // Activate notifications for IAP check purposes. Done with every server startup.

    // When EWlanConnectionModeNotConnected is received we can cancel this and 

    // we know that it safe to go through IAPs.

    iMgtClient = CWlanMgmtClient::NewL();

#ifndef __WINS__

    iMgtClient->ActivateNotificationsL( *this );

#endif 

    }

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

// ConnectionStateChanged

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

//

void CHotSpotServer::ConnectionStateChanged( TWlanConnectionMode  aNewState ) 

    if ( aNewState == EWlanConnectionModeNotConnected )

            {

#ifndef __WINS__

            iMgtClient->CancelNotifications();

#endif

            }

    }

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

// CheckIapsL

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

//

void CHotSpotServer::CheckIapsL()

    {

    DEBUG("CHotSpotServer::CheckIapsL");

        CleanupClosePushL( cmArray );

                    delete client;

        CleanupStack::PopAndDestroy( &cmArray );

        CleanupStack::PopAndDestroy( &cmManager );

    }

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

// NewSessionL

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

//

CSession2* CHotSpotServer::NewSessionL( const TVersion& aVersion, 

                                        const RMessage2& /* aMessage */ ) const

    {

                      KHotSpotMinorVersionNumber,

                      KHotSpotBuildVersionNumber );

    if ( !User::QueryVersionSupported( version, aVersion ) )

        {

        User::Leave( KErrNotSupported );

        }

        CHotSpotSession::NewL( const_cast<CHotSpotServer&>( *this ) );

    return session;

    }

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

// NotifyAdd

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

//

void CHotSpotServer::NotifyAdd(

    CNotificationBase& aNotification )

    {

    DEBUG( "CHotSpotServer::NotifyAdd()" );

    iNotificationArray.Insert( &aNotification, 0 );

    }

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

// NotifyRemove

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

//

void CHotSpotServer::NotifyRemove(

    CNotificationBase& aNotification )

    {

    DEBUG( "CHotSpotServer::NotifyRemove()" );

    TInt index = iNotificationArray.Find( &aNotification );

    iNotificationArray.Remove( index );

    }

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

// SaveMessage

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

//

TInt CHotSpotServer::SaveMessage( TUint aIapId, const RMessage2& aMessage, 

                                  THotSpotCommands aCommand )

    {

    DEBUG("**** HotspotServer: SaveMessage");

    TInt ret( KErrNone );

    SRequestMapEntry entry;

    entry.iMessage = aMessage;

    entry.iFunction = aCommand;

    entry.iIapId = aIapId;

    ret = iMap.Append(entry);

    return ret;

    }

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

// CompleteMessage

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

//

void CHotSpotServer::CompleteMessage( TInt aIndex, TInt aResult )

    {

    DEBUG("**** HotspotServer: CompleteMessage");

    SRequestMapEntry entry = iMap[aIndex];

    RMessagePtr2 message = entry.iMessage;

    message.Complete( aResult );

    iMap.Remove( aIndex );

    }

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

// EditMessage

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

//

TInt CHotSpotServer::EditMessage( TInt aIndex, TPckg<HssScanList>& aData)

    {

    DEBUG("**** HotspotServer: EditMessage");

    TInt ret( KErrNone );

    iMap[aIndex].iMessage.Write(0, aData);

    DEBUG1("**** HotspotServer: EditMessage ret: %d", ret);

    return ret;

    }

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

// FindMessage

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

//

TInt CHotSpotServer::FindMessage( TUint aIapId, THotSpotCommands aCommand )

    {

    DEBUG("**** HotspotServer: FindMessage");

    TInt ret( KErrNotFound );

    SRequestMapEntry entry;

    for ( TInt i = 0; i < iMap.Count(); i++ ) 

        {

        entry = iMap[i];

        if ( ( entry.iFunction == aCommand ) && ( entry.iIapId == aIapId ) )

            {

            // Correct message found

            // Now stop loop and return index value, so that CompeteMessage can

            // be called with that

            ret = i;

            i = iMap.Count();

            }

        }

    DEBUG1("**** HotspotServer: FindMessage ret: %d", ret);

    return ret;

    }

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

// SetLogoutFlag

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

//

void CHotSpotServer::SetLogoutFlag( TBool aValue )

    {

    DEBUG("HotspotServer::SetLogoutFlag");

    iLogoutSent = aValue;

    }

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

// GetLogoutFlagValue

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

//

TBool CHotSpotServer::GetLogoutFlagValue()

    {

    DEBUG("HotspotServer::GetLogoutFlagValue()");

    return iLogoutSent;

    }

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

// SetLoginFlag

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

//

void CHotSpotServer::SetLoginFlag( TBool aValue )

    {

    DEBUG("HotspotServer::SetLoginFlag");

    iLoginValue = aValue;

    }

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

// GetLoginFlagValue

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

//

TBool CHotSpotServer::GetLoginFlagValue()

    {

    DEBUG("HotspotServer::GetLoginFlagValue()");

    return iLoginValue;

    }

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

// SetAssociationFlag

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

//

void CHotSpotServer::SetAssociationFlag( TBool aValue )

    {

    DEBUG("HotspotServer::SetAssociationFlag");

    iAssociationValue = aValue;

    }

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

// GetAssociationFlagValue

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

//

TBool CHotSpotServer::GetAssociationFlagValue()

    {

    DEBUG("HotspotServer::GetAssociationFlagValue()");

    return iAssociationValue;

    }

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

// SetServiceId

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

//

void CHotSpotServer::SetServiceId( TInt aServiceId )

    {

    DEBUG("HotspotServer::SetServiceId");

    iCurrentServiceIdInUse = aServiceId;

    }

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

// GetServiceId

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

//

TInt CHotSpotServer::GetServiceId()

    {

    DEBUG("HotspotServer::GetServiceId()");

    return iCurrentServiceIdInUse;

    }

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

// RunError

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

//

TInt CHotSpotServer::RunError( TInt aError )

    // error from CHotSpotSession::ServiceL

    Message().Complete( aError );

    // Continue  reading client requests

    ReStart();

    return (KErrNone);

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

// GetLoginTimerMicroSecs

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

//

TUint CHotSpotServer::GetLoginTimeMicroSecs( TUid aClientUid )

    {

    // Default timer value will be returned if matching client UID isn't found.

    TUint retval = KHssDefaultLoginTimeMicroSecs ;