/*

* 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:  Connection Monitor session.

*

*/

#include <featmgr.h>

#include <etelmm.h>

#include <rconnmon.h>

#include "ConnMonSess.h"

#include "ConnMonServ.h"

#include "ConnMonIAP.h"

#include "ConnMonDef.h"

#include "CEventQueue.h"

#include "CIapSupport.h"

#include "CUiDialogAO.h"

#include "ConnMonUtils.h"

#include "ConnMonAvailabilityManager.h"

#include "ConnMonBearerGroupManager.h"

#include "connmonwlannetwork.h"

#include "CPlugin.h"

#include "log.h"

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

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

// TConnSettings::TConnSettings

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

//

TConnSettings::TConnSettings(

        TUint aActivityTimeThreshold,

        TUint aDLDataThreshold,

        TUint aULDataThreshold )

        :

        iActivityTimeThreshold( aActivityTimeThreshold ),

        iDLDataThreshold( aDLDataThreshold ),

        iULDataThreshold( aULDataThreshold )

    {

    }

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

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

// TConnRequest::TConnRequest

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

//

TConnRequest::TConnRequest( TUint8 aType, const RMessage2 aMessage )

        :

        iType( aType ),

        iMessage( aMessage )

    {

    }

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

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

// TConnParams::TConnParams

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

//

TConnParams::TConnParams( TUint aConnectionId )

        :

        iConnectionId( aConnectionId ),

        iSettings( 0, 0, 0 )

    {

    iRequests.Reset();

    }

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

// TConnParams::MatchId

// Finds TConnParams item matching by connection Id.

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

//

TBool TConnParams::MatchId( const TConnParams& aFirst, const TConnParams& aSecond )

    {

    if ( aFirst.iConnectionId == aSecond.iConnectionId )

        {

        return ETrue;

        }

    return EFalse;

    }

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

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

// CConnMonSession::CConnMonSession

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

//

CConnMonSession::CConnMonSession( CConnMonServer* aServer )

        :

        CSession2(),

        iCmServer( aServer )

    {

    }

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

// CConnMonSession::ConstructL

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

//

void CConnMonSession::ConstructL()

    {

    //LOGENTRFN("CConnMonSession::ConstructL()")

    iListening = EFalse;

    iEnumConnInfo = new( ELeave ) CArrayFixFlat<TUint>( 1 );

    iEnumConnInfo->Reset();

    // Initialize last event time

    iLastEventTime = iCmServer->EventQueue()->LastEventTime();

    // Create a new object index (it stores the plug-in objects owned by this session)

    iPlugins = CObjectIx::NewL();

    // Initialize the object container using the object container index in the server

    // (Object container provides unique ids for the objects owned by this session)

    iContainer = iCmServer->NewContainerL();

    //LOGEXITFN("CConnMonSession::ConstructL()")

    }

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

// CConnMonSession::~CConnMonSession

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

//

CConnMonSession::~CConnMonSession()

    {

    LOGIT(".")

    LOGENTRFN("CConnMonSession::~CConnMonSession()")

    if ( iListening && ( iBearerAvailabilityThreshold == 1 ) )

        {

        // Resets plugin threshold, so plugin can stop sending bearer

        // availability events when no longer needed.

        SetPluginThreshold( EBearerAvailabilityThreshold, 0 );

        }

    // Cancel any 'receive' request

    CancelReceiveEvent();

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

        {

        iConnParams[i].iRequests.Close();

        }

    iConnParams.Close();

    if ( iEnumConnInfo != 0 )

        {

        iEnumConnInfo->Reset();

        delete iEnumConnInfo;

        iEnumConnInfo = NULL;

        }

    // Delete the object index

    delete iPlugins;

    iPlugins = NULL;

    // Delete the object container

    if ( iContainer != 0 )

        {

        iCmServer->RemoveContainer( iContainer );

        iContainer = NULL;

        }

    // Check WLAN support

    if ( iCmServer->Iap()->WlanSupport() )

        {

        // Delete WLAN session from WlanSessions array if exists

        iCmServer->Iap()->WlanSupport()->DeleteWlanSession( this );

        }

    // Decrement session count, so server may terminate if no longer needed

    iCmServer->DecrementSessions();

    iCmServer = NULL;

    iReceiveBuffer = NULL;

    LOGEXITFN("CConnMonSession::~CConnMonSession()")

    }

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

// CConnMonSession::ServiceL

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

//

void CConnMonSession::ServiceL( const RMessage2& aMessage )

    {

    //LOGENTRFN("CConnMonSession::ServiceL()")

    TInt rc( KErrNone );

    #ifdef _DEBUG

    if ( aMessage.Function() != EReqReceiveEvent )

        {

        LOGIT(".")

        LOGIT2("ServiceL: function %d, id %X", aMessage.Function(), aMessage.SecureId().iId)

        }

    #endif // _DEBUG

    iMessage2 = aMessage;

    switch ( aMessage.Function() )

        {

        case EReqGetConnectionCount:

            rc = GetConnectionCountL();

            CompleteMessage( rc );

            break;

        case EReqGetConnectionInfo:

            rc = GetConnectionInfo();

            CompleteMessage( rc );

            break;

        case EReqGetSubConnectionInfo:

            rc = GetSubConnectionInfo();

            CompleteMessage( rc );

            break;

        case EReqGetIntAttribute:

            rc = GetIntAttributeL();

            CompleteMessage( rc );

            break;

        case EReqGetUintAttribute:

            rc = GetUintAttributeL();

            CompleteMessage( rc );

            break;

        case EReqGetBoolAttribute:

            rc = GetBoolAttributeL();

            CompleteMessage( rc );

            break;

        case EReqGetStringAttribute:

            rc = GetStringAttributeL();

            CompleteMessage( rc );

            break;

        case EReqGetPckgAttribute:

            rc = GetPckgAttributeL();

            CompleteMessage( rc );

            break;

        case EReqSetIntAttribute:

            rc = SetIntAttributeL();

            CompleteMessage( rc );

            break;

        case EReqSetUintAttribute:

            rc = SetUintAttributeL();

            CompleteMessage( rc );

            break;

        case EReqSetBoolAttribute:

            rc = SetBoolAttribute();

            CompleteMessage( rc );

            break;

        case EReqSetStringAttribute:

            rc = SetStringAttributeL();

            CompleteMessage( rc );

            break;

        case EReqSetPckgAttribute:

            rc = SetPckgAttribute();

            CompleteMessage( rc );

            break;

        case EReqCancelAsyncRequest:

            rc = CancelAsyncRequest();

            CompleteMessage( rc );

            break;

        case EReqReceiveEvent: // TAny& aBuffer - async

            ReceiveEventL( aMessage.Ptr0() );

            break;

        case EReqCancelReceiveEvent:

            CancelReceiveEvent();

            CompleteMessage( 0 );

            break;

        // Plug-in specific, fall-through intended

        case EReqPluginCreateSubSession:

        case EReqPluginCloseSubSession:

        case EReqPluginRegisterAttribute:

        case EReqPluginCancelRegisterAttribute:

        case EReqPluginEvent:

        case EReqPluginGetQuery:

        case EReqPluginCancelGetQuery:

        case EReqPluginAttribute:

            ServicePluginL( aMessage );

            break;

        default:

            iCmServer->PanicClient( EBadRequest );

            break;

        }

    //LOGEXITFN("CConnMonSession::ServiceL()")

    }

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

// CConnMonSession::CompleteMessage

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

//

void CConnMonSession::CompleteMessage( const TInt aStatus )

    {

    // Check if async message

    if ( aStatus != KRequestPending )

        {

        // Complete message

        Message().Complete( aStatus );

        }

    }

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

// CConnMonSession::GetConnectionCountL

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

//

TInt CConnMonSession::GetConnectionCountL()

    {

    LOGENTRFN("CConnMonSession::GetConnectionCountL()")

    TInt err( KErrNone );

    TUint count( 0 );

    // Call comms APIs

    err = iCmServer->Iap()->EnumerateConnectionsL( count, *iEnumConnInfo );

    LOGIT2("SERVER: EReqGetConnectionCount OUT: -> count %d, ret <%d>", count, err)

    if ( KErrNone == err )

        {

        // Write "count" back to the client's address space

        TPtrC8 d( reinterpret_cast<TUint8*>( &count ), sizeof( count ) );

        err = Message().Write( 0, d );

        if ( err != KErrNone )

            {

            LOGIT1("SERVER: EReqGetConnectionCount: -> error, Message().Write(0, d) returned <%d>", err)

            iCmServer->PanicClient( EBadDescriptor );

            }

        LOGIT("SERVER: EReqGetConnectionCount. -> RemoveObsoleteConnectionParams()")

        // Remove obsolete connection settings

        RemoveObsoleteConnectionParams();

        }

    LOGEXITFN1("CConnMonSession::GetConnectionCountL()", err)

    return err;

    }

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

// CConnMonSession::GetConnectionInfo

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

//

TInt CConnMonSession::GetConnectionInfo()

    {

    LOGENTRFN("CConnMonSession::GetConnectionInfo()")

    TInt err( KErrNone );

    TUint id( 0 );

    TUint subConnectionCount( 1 );

    TInt index = Message().Int0();

    if ( !iEnumConnInfo )

        {

        err = KErrUnknown;

        }

    // Indexes given to client start from 1

    else if ( ( index <= 0 ) || ( index > iEnumConnInfo->Count() ) )

        {

        err = KErrArgument;

        }

    else

        {

        // Enumerated connection IDs are stored in session

        id = (*iEnumConnInfo)[index - 1];

        // Get subconnection count

        err = iCmServer->Iap()->GetConnectionInfo( id, subConnectionCount );

        LOGIT4("SERVER: EReqGetConnectionInfo: index %d -> id %d, subConnCount %d, ret <%d>",

                index, id, subConnectionCount, err)

        if ( KErrNone == err )

            {

            // Write "id" back to the client's address space

            TPtrC8 d( reinterpret_cast<TUint8*>( &id ), sizeof( id ) );

            err = Message().Write( 1, d );

            if ( KErrNone != err )

                {

                iCmServer->PanicClient( EBadDescriptor );

                }

            else

                {

                // Write "subConnectionCount" back to the client's address space

                TPtrC8 e(

                        reinterpret_cast<TUint8*>( &subConnectionCount ),

                        sizeof( subConnectionCount ) );

                err = Message().Write( 2, e );

                if ( KErrNone != err )

                    {

                    iCmServer->PanicClient( EBadDescriptor );

                    }

                }

            }

        }

    LOGEXITFN1("CConnMonSession::GetConnectionInfo()", err)

    return err;

    }

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

// CConnMonSession::GetSubConnectionInfo

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

//

TInt CConnMonSession::GetSubConnectionInfo() const

    {

    LOGENTRFN("CConnMonSession::GetSubConnectionInfo()")

    LOGEXITFN1("CConnMonSession::GetSubConnectionInfo()", KErrNotSupported)

    return KErrNotSupported;

    }

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

// CConnMonSession::GetIntAttributeL

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

//

TInt CConnMonSession::GetIntAttributeL()

    {

    LOGENTRFN("CConnMonSession::GetIntAttributeL()")

    TInt err( KErrNone );

    TInt value( 0 );

    // Call comms APIs

    err = iCmServer->Iap()->GetIntAttributeL( Message(), value );

    LOGIT1("SERVER: CConnMonSession::GetIntAttributeL: Iap()->GetIntAttributeL <%d>", err)

    // Check if this request should be served by a plug-in engine

    if ( ( Message().Int0() >= EBearerIdGPRS ) &&

            ( err != KErrNone ) &&

            ( err != KRequestPending ) )

        {

        RMessage2 msg = Message();

        err = iCmServer->SendRequestToPlugin( EReqGetIntAttribute, msg );

        }

    LOGIT5("SERVER: EReqGetIntAttribute. id %d, subConnId %d, attr %d -> value %d, ret <%d>",

            Message().Int0(), Message().Int1(), Message().Int2(), value, err)

    if ( KErrNone == err )

        {

        // Write "value" back to the client's address space

        TPtrC8 d( reinterpret_cast<TUint8*>( &value ), sizeof( value ) );

        err = Message().Write( KAttributeParameterIndex, d );

        if ( KErrNone != err )

            {

            iCmServer->PanicClient( EBadDescriptor );

            }

        }

    LOGEXITFN1("CConnMonSession::GetIntAttributeL()", err)

    return err;

    }

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

// CConnMonSession::GetUintAttributeL

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

//

TInt CConnMonSession::GetUintAttributeL()

    {

    LOGENTRFN("CConnMonSession::GetUintAttributeL()")

    TInt err( KErrNone );

    TUint value( 0 );

    TUint connectionId( Message().Int0() );

    TInt attribute( Message().Int2() );

    switch ( attribute )

        {

        case KDownlinkDataThreshold:

        case KUplinkDataThreshold:

        case KActivityTimeThreshold:

            {

            if ( iCmServer->Iap()->ConnectionExists( connectionId ) )

                {

                TConnSettings settings( 0, 0, 0 );

                err = GetConnectionSettings( connectionId, settings );

                if ( KErrNone == err )

                    {

                    if ( attribute == KDownlinkDataThreshold )

                        {

                        value = settings.iDLDataThreshold;

                        }

                    else if ( attribute == KUplinkDataThreshold )

                        {

                        value = settings.iULDataThreshold;

                        }

                    else

                        {

                        value = settings.iActivityTimeThreshold;

                        }

                    }