/*

* Copyright (c) 2002-2008 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:  Session class is required by the client/server framework

*

*/

/*

* %version: 23 %

*/

// INCLUDE FILES

#include "wlmsession.h"

#include "genscanlist.h"

#include "wlmserver.h"

#include "am_debug.h"

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

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

// CWlmSession::CWlmSession

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CWlmSession::CWlmSession(

    CWlmServer& aServer ) :

    iId( 0 ),

    iWlmServer( aServer ),

    iIsNotificationRequestPending( EFalse ),

    iNotificationHandle( NULL )

    {

    }

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

// CWlmSession::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CWlmSession::ConstructL()

    {

    iPendingNotifications.Reset();

    iId = iWlmServer.NotifySessionCreated();

    }

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

// CWlmSession::NewL

// Two-phased constructor.

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

//

CWlmSession* CWlmSession::NewL(

    CWlmServer& aServer )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// Destructor

CWlmSession::~CWlmSession()

    {

    iPendingNotifications.Close();

    if( iNotificationHandle )

        {

        iWlmServer.NotifyRemove( *iNotificationHandle );

        delete iNotificationHandle;

        }

    iWlmServer.NotifySessionClosed( iId );

    }

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

// CWlmSession::ServiceL

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

//

void CWlmSession::ServiceL(

    const RMessage2& aMessage )

    {    

    DEBUG1( "CWlmSession: Function %d received", aMessage.Function() );

#ifdef _DEBUG    

    TInt totalAllocated = 0;

    TInt cellCount = User::AllocSize( totalAllocated );

    DEBUG2("WLMSERVER MEMORYINFO: mem allocated == %d, cellcount == %d",

        totalAllocated, cellCount );

#endif // _DEBUG

    TInt cmd = aMessage.Function();

    switch ( cmd )

        {

        case EOrderNotifications:

            HandleOrderNotifications( aMessage );

            break;

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

        case ECancelNotifications:

            HandleCancelNotifications( aMessage );

            break;

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

        case EGetScanResults:

            iWlmServer.GetScanResult( iId, aMessage );

            break;

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

        case ECancelGetScanResults:

            iWlmServer.CancelGetScanResult( iId, aMessage );

            break;

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

        case EJoinByProfileId:

            // Joining/creating network requires capabilities

            aMessage.HasCapabilityL( ECapabilityNetworkServices );

            iWlmServer.Connect( iId, aMessage );

            break;

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

        case ECancelJoin:

            iWlmServer.CancelConnect( iId, aMessage );

            break;

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

        case EReset:

            // Releasing network connections requires capabilities

            aMessage.HasCapabilityL( ECapabilityNetworkServices );

            iWlmServer.ReleaseComplete( iId, aMessage );

            break;

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

        case EGetAvailableIaps:

            iWlmServer.GetAvailableIaps( iId, aMessage );

            break;

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

        case ECancelGetAvailableIaps:

            iWlmServer.CancelGetAvailableIaps( iId, aMessage );

            break;

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

        case EGetCurrentState:

            iWlmServer.GetConnectionState( iId, aMessage );

            break;

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

        case EGetCurrentRSSI:

            iWlmServer.GetCurrentRCPI( iId, aMessage );

            break;

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

        case EGetMacAddress:

            iWlmServer.GetCurrentBSSID( iId, aMessage );

            break;

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

        case EGetNetworkName:

            iWlmServer.GetCurrentSSID( iId, aMessage );

            break;

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

        case EGetSecurityMode:

            iWlmServer.GetCurrentSecurityMode( iId, aMessage );

            break;

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

        case EGetSystemMode:

            iWlmServer.GetCurrentSystemMode( iId, aMessage );

            break;

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

        case ENotifyChangedSettings:

            iWlmServer.NotifyChangedSettings( iId, aMessage );

            break;        

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

        case EAddBssidToRoguelist:

            iWlmServer.AddBssidToRoguelist( iId, aMessage );

            break;        

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

        case EUpdateRcpNotificationBoundaries:

            iWlmServer.UpdateRcpNotificationBoundary( iId, aMessage );

            break;        

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

        case EConfigureMulticastGroup:

            iWlmServer.ConfigureMulticastGroup( iId, aMessage );

            break;        

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

        case EGetPacketStatistics:

            iWlmServer.GetPacketStatistics( iId, aMessage );

            break;        

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

        case EClearPacketStatistics:

            iWlmServer.ClearPacketStatistics( iId, aMessage );

            break;        

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

        case EGetUapsdSettings:

            iWlmServer.GetUapsdSettings( iId, aMessage );

            break;        

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

        case ESetUapsdSettings:

            iWlmServer.SetUapsdSettings( iId, aMessage );

            break;

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

        case EGetPowerSaveSettings:

            iWlmServer.GetPowerSaveSettings( iId, aMessage );

            break;

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

        case ESetPowerSaveSettings:

            iWlmServer.SetPowerSaveSettings( iId, aMessage );

            break;

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

        case ERunProtectedSetup:

            iWlmServer.RunProtectedSetup( iId, aMessage );

            break;

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

        case ECancelProtectedSetup:

            iWlmServer.CancelProtectedSetup( iId, aMessage );

            break;

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

        case ECreateTrafficStream:

            iWlmServer.CreateTrafficStream( iId, aMessage );

            break;

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

        case ECancelCreateTrafficStream:

            iWlmServer.CancelCreateTrafficStream( iId, aMessage );

            break;

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

        case EDeleteTrafficStream:

            iWlmServer.DeleteTrafficStream( iId, aMessage );

            break;

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

        case ECancelDeleteTrafficStream:

            iWlmServer.CancelDeleteTrafficStream( iId, aMessage );

            break;

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

        case EGetAccessPointInfo:

            iWlmServer.GetAccessPointInfo( iId, aMessage );

            break;

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

        case EGetRoamMetrics:

            iWlmServer.GetRoamMetrics( iId, aMessage );

            break;

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

        case EGetRogueList:

            iWlmServer.GetRogueList( iId, aMessage );

            break;

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

        case EGetRegulatoryDomain:

            iWlmServer.GetRegulatoryDomain( iId, aMessage );

            break;

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

        case EGetPowerSaveMode:

            iWlmServer.GetPowerSaveMode( iId, aMessage );

            break;

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

        case EAddIapSsidList:

            iWlmServer.AddIapSsidListL( iId, aMessage );

            break;

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

        case ERemoveIapSsidList:

            iWlmServer.RemoveIapSsidListL( iId, aMessage );

            break;      

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

        case ESetPowerSaveMode:

            iWlmServer.SetPowerSaveMode( iId, aMessage );

            break;

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

        case ENotifyChangedPsmSrvMode:

            iWlmServer.NotifyChangedPsmSrvMode( iId, aMessage );

            break;

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

        case EGetAcTrafficStatus:

            iWlmServer.GetAcTrafficStatus( iId, aMessage );

            break;                

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

        case EDirectedRoam:

            iWlmServer.DirectedRoam( iId, aMessage );

            break;

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

        case ECancelDirectedRoam:

            iWlmServer.CancelDirectedRoam( iId, aMessage );

            break;        

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

        default:

            aMessage.Complete( KErrNotSupported );

        }

    }

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

// CWlmSession::HandleOrderNotifications

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

//

void CWlmSession::HandleOrderNotifications(

    const RMessage2& aMessage )

    {

    iPendingNotificationRequest = aMessage;

    iIsNotificationRequestPending = ETrue;

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

        {

        TRAPD( err, iNotificationHandle =

            CSessionNotification::NewL( *this, aMessage.Int1() ) );

        if ( err == KErrNone )

            {

            iWlmServer.NotifyAdd( *iNotificationHandle );

            }

        else

            {

            iIsNotificationRequestPending = EFalse;

            aMessage.Complete( err );

            return;

            }

        }

    HandleNotification(); // check is there any unsent notifications

    }

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

// CWlmSession::HandleCancelNotifications

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

//

void CWlmSession::HandleCancelNotifications(

    const RMessage2& aMessage )

    {

    if( iIsNotificationRequestPending )

        {

        iPendingNotificationRequest.Complete( EWlmNotifyNotificationsCancelled );

        iIsNotificationRequestPending = EFalse;

        iPendingNotifications.Reset();

        }

    if( iNotificationHandle )

        {

        iWlmServer.NotifyRemove( *iNotificationHandle );

        delete iNotificationHandle;

        iNotificationHandle = NULL;

        }

    aMessage.Complete( KErrNone );

    }

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

// CWlmSession::AddNotification

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

//

void CWlmSession::AddNotification(

    TInt aNotification,

    const TDesC8& aData )

    {

    DEBUG( "CWlmSession::AddNotification" );

    TNotification notif;

    notif.id = aNotification;

    notif.data = aData;

    iPendingNotifications.Append( notif );

    HandleNotification(); // check is there client waiting for notification

    }

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

// CWlmSession::HandleNotification

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

//

void CWlmSession::HandleNotification()

    {

    DEBUG( "CWlmSession::HandleNotification" );

    // Check is there message to wait notification and 

    // notification that is not sent.

    if ( iIsNotificationRequestPending && iPendingNotifications.Count() != 0 )

        {

        DEBUG( "CWlmSession::HandleNotification - sending response..." );

        iIsNotificationRequestPending = EFalse;

        TPckgBuf<TWlmNotifyData> pckg;

        pckg().data = iPendingNotifications[0].data;

        TInt ret( iPendingNotificationRequest.Write( 0, pckg ) );

        if ( ret != KErrNone )

            {

            iPendingNotificationRequest.Complete( ret );

            return;

            }

        iPendingNotificationRequest.Complete( iPendingNotifications[0].id );

        iPendingNotifications.Remove( 0 );

        }

    }

//  End of File