/** @file

* Copyright (c) 2005-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:  Defines the CUpnpConnManagerSession class

*

*/

// INCLUDE FILES

#include "upnpconnmanagersession.h"

#include "upnpconnmanagerengine.h"

#include "upnpconnmanager.h"

#include <upnpsymbianserverbase.h>

#define KLogFile _L("UPnPConnManager.txt")

#include "upnpcustomlog.h"

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

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

// CUpnpConnManagerSession::NewL

// Two-phased constructor.

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

//

CUpnpConnManagerSession* CUpnpConnManagerSession::NewL(

    CUpnpConnManagerEngine& aEngine )

    {

    LOG_FUNC_NAME;

    CUpnpConnManagerSession* self =

        CUpnpConnManagerSession::NewLC( aEngine );

    CleanupStack::Pop( self ) ;

    return self ;

    }

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

// CUpnpConnManagerSession::NewLC

// Two-phased constructor.

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

//

CUpnpConnManagerSession* CUpnpConnManagerSession::NewLC(

    CUpnpConnManagerEngine& aEngine )

    {

    LOG_FUNC_NAME;

    CUpnpConnManagerSession* self =

        new( ELeave ) CUpnpConnManagerSession( aEngine );

    CleanupStack::PushL( self );

    return self ;

    }

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

// CUpnpConnManagerSession::CUpnpConnManagerSession

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

// might leave.

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

//

CUpnpConnManagerSession::CUpnpConnManagerSession( CUpnpConnManagerEngine& aEngine )

        : CSession2(),

        iConnEngine( aEngine ),

        iLastEvent( EUnknownEvent )

    {

#ifdef _DEBUG

    TInt reqsInStart = RThread().RequestCount();

    TInt processHandlesInStart;

    TInt threadHandlesInStart;

    RThread().HandleCount( processHandlesInStart, threadHandlesInStart );

    LOGS1( "reqsInStart: %d", reqsInStart);

    LOGS1( "processHandlesInStart: %d", processHandlesInStart );

    LOGS1( "threadHandlesInStart: %d", threadHandlesInStart );

#endif // _DEBUG

    }

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

// CUpnpConnManagerSession::~CUpnpConnManagerSession

// Destructor.

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

//

CUpnpConnManagerSession::~CUpnpConnManagerSession()

    {

    LOG_FUNC_NAME;

    iConnEngine.CheckAndCloseConnection( this );

    }

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

// CUpnpConnManagerSession::ServiceL

// Handle client requests.

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

//

void CUpnpConnManagerSession::ServiceL( const RMessage2& aMessage )

    {

    LOG_FUNC_NAME;

    TInt err;

    switch ( aMessage.Function() )

        {

        case EEnsureStartRConnection:

            {

            err = EventEnsureStartRConnectionL( aMessage );

            aMessage.Complete( err );

            break;

            }

        case EIsRConnectionStarted:

            {

            EventIsRConnectionStartedL( aMessage );

            aMessage.Complete( KErrNone );

            break;

            }

        case EEventSubscribe:

            {

            // subscribe to: 1) wlan lost or 2) address change

            EventSubscribeToNetworkEventL( aMessage );

            break;

            }

        case ECancelEventSubscribe:

            {

            EventCancelSubscribeToNetworkEvent();

            aMessage.Complete( KErrNone );

            break;

            }    

        case ECmActiveIap:

            {

            EventActiveIapL( aMessage );

            aMessage.Complete( KErrNone );

            break;

            }  

        case ECmGetAddress:

            {

            EventLocalAddressL( aMessage );

            aMessage.Complete( KErrNone );

            break;

            }

        default:

            PanicClient( aMessage, CUpnpSymbianServerBase::EBadRequest );

            break;

        }

    }

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

// CUpnpConnManagerSession::PanicClient

// Panic client.

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

//

void CUpnpConnManagerSession::PanicClient( const RMessage2& aMessage, TInt aPanic ) const

    {

    LOG_FUNC_NAME;

    static_cast<const CUpnpSymbianServerBase*>( Server() )->PanicClient( aMessage, aPanic );

    }

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

// CUpnpConnManagerSession::EventEnsureStartRConnectionL

// Device list change.

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

//

TInt CUpnpConnManagerSession::EventEnsureStartRConnectionL( const RMessage2& aMessage )

    {

    LOG_FUNC_NAME;

    TInt accessPoint;

    TInt result = iConnEngine.EnsureStart( accessPoint );

    TPtr8 ptr( reinterpret_cast<TUint8*>( &accessPoint ), sizeof( TInt ), sizeof( TInt ) );

    aMessage.WriteL( 0, ptr );

    iSessionUseConnection = ETrue;

    return result;

    }

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

// CUpnpConnManagerSession::EventIsRConnectionStartedL

// Checks if connection is started

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

//

void CUpnpConnManagerSession::EventIsRConnectionStartedL( const RMessage2& aMessage )

    {

    LOG_FUNC_NAME;

    TBool result = iConnEngine.IsStarted();

    TPtr8 ptr( reinterpret_cast<TUint8*>( &result ), sizeof( TBool ),

               sizeof( TBool ) );

    aMessage.WriteL( 0, ptr );

    }

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

// CUpnpConnManagerSession::EventSubscribeToNetworkEventL

// Subscribes to Wlan lost event

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

//

void CUpnpConnManagerSession::EventSubscribeToNetworkEventL( const RMessage2& aMessage )

    {

    LOG_FUNC_NAME;

    if ( !iSubscriberMessage.IsNull() )

        {

        aMessage.Complete( KErrServerBusy );

        return;

        }

    else 

        {

        iSubscriberMessage = aMessage;

        }    

    switch( iLastEvent.Type() )

        {

        case EWlanLostEvent: 

                WLanLostCompleteL();

            break;

        case EAddressChangeEvent: 

                AddressChangeCompleteL();

            break;

        default: 

            break;

        }

    }

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

// CUpnpConnManagerSession::EventCancelSubscribeToNetworkEvent

// Cancel subscription

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

//

void CUpnpConnManagerSession::EventCancelSubscribeToNetworkEvent()

    {

    LOG_FUNC_NAME;

    CancelSubscription();

    }

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

// CUpnpConnManagerSession::EventActiveIap

// Returns active Iap.

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

//

void CUpnpConnManagerSession::EventActiveIapL( const RMessage2 &aMessage )

    {

    LOG_FUNC_NAME;

    TInt iap = iConnEngine.ActiveIap();

    TPtr8 ptr( reinterpret_cast<TUint8*>( &iap ), sizeof( TInt ), sizeof( TInt ) );

    aMessage.WriteL( 0, ptr );

    }

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

// CUpnpConnManagerSession::EventLocalAddressL

// Returns local address

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

//

void CUpnpConnManagerSession::EventLocalAddressL( const RMessage2 &aMessage )

    {

    LOG_FUNC_NAME;

    TInetAddr localAddress = iConnEngine.LocalAddress();

    TPtr8 ptr( reinterpret_cast<TUint8*>( &localAddress ), 

               sizeof( TInetAddr ), 

               sizeof( TInetAddr ) );

    aMessage.WriteL( 0, ptr );       

    }

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

// CUpnpConnManagerSession::CancelSubscription

// Cancel subscription

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

//

void CUpnpConnManagerSession::CancelSubscription()

    {

    if ( !iSubscriberMessage.IsNull() )

        {

        iSubscriberMessage.Complete( KErrCancel );

        }

    iLastEvent.SetType( EUnknownEvent );    

    }

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

// CUpnpConnManagerSession::WLanLostOccured

// Ends subscription with Wlan lost code

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

//

void CUpnpConnManagerSession::WLanLostOccuredL()

    {

    iLastEvent.SetType( EWlanLostEvent );

    if ( !iSubscriberMessage.IsNull() )

        {

        WLanLostCompleteL();

        }    

    }

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

// CUpnpConnManagerSession::WLanLostComplete

// Notify client about WLan lost event

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

//

void CUpnpConnManagerSession::WLanLostCompleteL()

    {

    TPtr8 ptr( reinterpret_cast<TUint8*>( &iLastEvent ),

               sizeof( TUpnpConnectionManagerNetworkEvent ),

               sizeof( TUpnpConnectionManagerNetworkEvent ) );

    iSubscriberMessage.WriteL( KNetworkEventSlot, ptr );

    iSubscriberMessage.Complete( KErrNone );

    iLastEvent.SetType( EUnknownEvent );

    }

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

// CUpnpConnManagerSession::AddressChangeOccuredL

// Ends subscription with address change code

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

//

void CUpnpConnManagerSession::AddressChangeOccuredL( TInetAddr& aAddr )

    {

    iLastEvent.SetType( EAddressChangeEvent );

    iLastEvent.SetAddress( aAddr );

    if ( !iSubscriberMessage.IsNull() )

        {

        AddressChangeCompleteL();

        }    

    }

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

// CUpnpConnManagerSession::AddressChangeCompleteL

// Notify client about address change event

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

//

void CUpnpConnManagerSession::AddressChangeCompleteL()

    {

    TPtr8 ptr( reinterpret_cast<TUint8*>( &iLastEvent ),

               sizeof( TUpnpConnectionManagerNetworkEvent ),

               sizeof( TUpnpConnectionManagerNetworkEvent ) );

    iSubscriberMessage.WriteL( KNetworkEventSlot, ptr );

    iSubscriberMessage.Complete( KErrNone );

    iLastEvent.SetType( EUnknownEvent );

    }

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

// CUpnpConnManagerSession::SessionUseConnection

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

//

TBool CUpnpConnManagerSession::SessionUseConnection()

    {

    return iSessionUseConnection;

    }

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

// CUpnpConnManagerSession::ConnectionClosedL

// Ends subscription with connection close code

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

//

void CUpnpConnManagerSession::ConnectionClosedL()

    {

    if ( iLastEvent.Type() != EConnectionClosedEvent )

        {

        iLastEvent.SetType( EConnectionClosedEvent );

        if ( !iSubscriberMessage.IsNull() )

            {

            ConnectionClosedCompleteL();

            }    

        }

    }

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

// CUpnpConnManagerSession::ConnectionClosedCompleteL

// Notify client about connection close event

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

//

void CUpnpConnManagerSession::ConnectionClosedCompleteL()

    {

    TPtr8 ptr( reinterpret_cast<TUint8*>( &iLastEvent ),

               sizeof( TUpnpConnectionManagerNetworkEvent ),

               sizeof( TUpnpConnectionManagerNetworkEvent ) );

    iSubscriberMessage.WriteL( KNetworkEventSlot, ptr );

    iSubscriberMessage.Complete( KErrNone );

    }

// End of File