/*

* Copyright (c) 2002-2007 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:  Event notifiers (active objects).

*

*/

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <es_enum_partner.h>

#endif

#include <e32base.h>

#include <rmmcustomapi.h>

#include <featmgr.h>

#include "ConnMonServ.h"

#include "ConnMonSess.h"

#include "CEventQueue.h"

#include "ConnMonIAP.h"

#include "ConnMonNoti.h"

#include "ConnMonAvailabilityManager.h"

#include "cellulardatausagekeyupdater.h"

#include "log.h"

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

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

// CConnUpDownNotifier::CConnUpDownNotifier

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

//

CConnUpDownNotifier::CConnUpDownNotifier(

        CConnMonServer* aServer )

        :

        CActive( EConnMonPriorityNormal ),

        iServer( aServer )

    {

    }

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

// CConnUpDownNotifier::ConstructL

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

//

void CConnUpDownNotifier::Construct()

    {

    //LOGENTRFN("CConnUpDownNotifier::Construct()")

    CActiveScheduler::Add( this );

    LOGIT("Created CConnUpDownNotifier")

    //LOGEXITFN("CConnUpDownNotifier::Construct()")

    }

// Destructor

CConnUpDownNotifier::~CConnUpDownNotifier()

    {

    Cancel();

    iServer = NULL;

    }

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

// CConnUpDownNotifier::Receive

// Requests a new event (connection up/down) from RConnection

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

//

void CConnUpDownNotifier::Receive()

    {

    if ( IsActive() )

        {

        Cancel();

        }

    iServer->Iap()->Rconnection()->AllInterfaceNotification( iInfoBuf, iStatus );

    SetActive();

    }

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

// CConnUpDownNotifier::DoCancel

// Cancels the request from RConnection.

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

//

void CConnUpDownNotifier::DoCancel()

    {

    if ( IsActive() )

        {

        iServer->Iap()->Rconnection()->CancelAllInterfaceNotification();

        }

    }

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

// CConnUpDownNotifier::RunL

// Handles the event that has arrived from RConnection

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

//

void CConnUpDownNotifier::RunL()

    {

    //LOGENTRFN("CConnUpDownNotifier::RunL()")

    // All RunL():s outside CServer-derived main class MUST NOT LEAVE.

    // Use TRAPD when needed.

    LOGIT(".")

    LOGIT1("RunL: CConnUpDownNotifier, status <%d>", iStatus.Int())

    if ( iStatus.Int() != KErrNone )

        {

        iErrorCounter++;

        if ( iErrorCounter > KConnMonEventErrorThreshold )

            {

            LOGIT1("Over %d consecutive errors, stopping", KConnMonEventErrorThreshold)

            return;

            }

        }

    else

        {

        iErrorCounter = 0;

        // Send event to clients

        TInt err( KErrNone );

        TBearerInfo bearerInfo;

        TConnInfo connInfo(

                iInfoBuf().iConnectionInfo.iIapId,

                iInfoBuf().iConnectionInfo.iNetId,

                0,

                0,

                bearerInfo );

        TInt listeners( iServer->NumberOfListeners() );

        LOGIT3("CConnUpDownNotifier, %d listeners, iap id %d, net id %d",

                listeners, connInfo.iIapId, connInfo.iNetId)

        iEventInfo.Reset();

        if ( iInfoBuf().iState == EInterfaceUp )

            {

            // Add to the connection table and fill in the new connectioId to connInfo

            TRAPD( ret, ( err = iServer->Iap()->AddConnectionL( connInfo ) ) );

            if ( ( ret != KErrNone ) || ( err != KErrNone ) )

                {

                LOGIT2("SERVER: FAILED to add a new connection <%d>,<%d>", ret, err)

                Receive();

                return; // Can't leave

                }

            // Send event to all clients that are listening

            if ( listeners > 0)

                {

                iEventInfo.iEventType    = EConnMonCreateConnection;

                iEventInfo.iConnectionId = connInfo.iConnectionId;

                iServer->EventQueue()->Add( iEventInfo );

                }

            LOGIT1("SERVER: EVENT -> connection %d created.", connInfo.iConnectionId)

            }

        else if ( iInfoBuf().iState == EInterfaceDown )

            {

            if ( listeners == 0 )

                {

                // Remove from the connection array. Note. when the notifications

                // are ON event handlers will remove the connection from the array.

                iServer->Iap()->RemoveConnection( connInfo );

                }

            else

                {

                TBool alreadyNotified( EFalse );

                // This updates the correct 'iConnectionId' and 'iBearer' to connInfo

                TInt ret = iServer->Iap()->GetDeleteNotifyStatus( connInfo, alreadyNotified );

                if ( ret == KErrNone )

                    {

                    CSubConnUpDownNotifier* subConnUpDownNotifier = 0;

                    ret = iServer->Iap()->GetSubConnUpDownNotifier(

                            connInfo.iConnectionId,

                            &subConnUpDownNotifier );

                    if ( ret == KErrNone )

                        {

                        subConnUpDownNotifier->SetInterfaceClosed();

                        if ( !subConnUpDownNotifier->DeleteSent() )

                            {

                            TNifProgress progress;

                            err = iServer->Iap()->LastProgressError(

                                    connInfo.iConnectionId,

                                    progress );

                            if ( progress.iError == KErrDisconnected )

                                {

                                // Enable WLAN scan for the next IAP availability check

                                // because the current bearer has been lost (-36). MPM needs

                                // a fresh list of available iaps on connection closure.

                                iServer->Iap()->EnableWlanScan();

                                }

                            // Progress and subconn notifiers have died and no delete has been sent

                            subConnUpDownNotifier->SendDeletedEvent();

                            }

                        else

                            {

                            // Delete has been sent. Just remove from internal table.

                            iServer->Iap()->RemoveConnection( connInfo );

                            }

                        }

                    }

                }

            LOGIT3("SERVER: EVENT (allinterface) -> connection %d (%d, %d) closed.",

                    connInfo.iConnectionId, connInfo.iIapId, connInfo.iNetId)

            }

        else

            {

            LOGIT("SERVER: Unknown event")

            Receive();

            return;

            }

        LOGIT("CConnUpDownNotifier::RunL triggered HandleAvailabilityChange()")

        iServer->AvailabilityManager()->HandleAvailabilityChange();

        }

    // New request

    Receive();

    //LOGEXITFN("CConnUpDownNotifier::RunL()")

    }

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

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

// CDataNotifier::CDataNotifier

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

//

CDataNotifier::CDataNotifier(

        CConnMonServer* aServer,

        RConnection* aConnection,

        const TUint& aConnectionId,

        const TUint& aSubConnectionId,

        const TInt& aDirection )

        :

        CActive( EConnMonPriorityNormal ),

        iServer( aServer ),

        iConnection( aConnection ),

        iConnectionId( aConnectionId),

        iSubConnectionId( aSubConnectionId ),

        iDirection( aDirection ),

        iVolume( 0 ),

        iPckgVolume( iVolume )

    {

    }

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

// CDataNotifier::Construct

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

//

void CDataNotifier::Construct()

    {

    //LOGENTRFN("CDataNotifier::Construct()")

    CActiveScheduler::Add( this );

    LOGIT("Created CDataNotifier")

    //LOGEXITFN("CDataNotifier::Construct()")

    }

// Destructor

CDataNotifier::~CDataNotifier()

    {

    Cancel();

    iServer = NULL;

    iConnection = NULL;

    }

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

// CDataNotifier::Receive

// Requests a new event (data transferred) from RConnection

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

//

void CDataNotifier::Receive()

    {

    // Don't make a new request if previous

    // status indicates that connection is closing

    if ( iStatus == KErrCancel )

        {

        return;

        }

    if ( IsActive() )

        {

        return;

        }

    iVolume = 0;

    if ( iDirection == EDownlink )

        {

        iServer->CalculateThreshold(

                iConnectionId,

                EDownlinkThreshold,

                iThreshold );

        if ( iThreshold > 0 )

            {

            iConnection->DataReceivedNotificationRequest(

                    iThreshold,

                    iPckgVolume,

                    iStatus );

            SetActive();

            }

        }

    else

        {

        iServer->CalculateThreshold(

                iConnectionId,

                EUplinkThreshold,

                iThreshold );

        if ( iThreshold > 0 )

            {

            iConnection->DataSentNotificationRequest(

                    iThreshold,

                    iPckgVolume,

                    iStatus );

            SetActive();

            }

        }

    }

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

// CDataNotifier::DoCancel

// Cancels the request from RConnection.

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

//

void CDataNotifier::DoCancel()

    {

    if ( IsActive() )

        {

        if ( iDirection == EDownlink )

            {

            iConnection->DataReceivedNotificationCancel();

            }

        else

            {

            iConnection->DataSentNotificationCancel();

            }

        }

    }

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

// CDataNotifier::RunL

// Handles the event that has arrived from RConnection

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

//

void CDataNotifier::RunL()

    {

    //LOGENTRFN("CDataNotifier::RunL()")

    // All RunL():s outside CServer-derived main class MUST NOT LEAVE.

    // Use TRAPD when needed.

    LOGIT(".")

    LOGIT1("RunL: CDataNotifier, status %d", iStatus.Int())

    if ( iStatus.Int() != KErrNone )

        {

        //LOGIT2("SERVER: Data volume event FAILED <%d>, id <%d>", iStatus.Int(), iConnectionId )

        iErrorCounter++;

        if ( iErrorCounter > KConnMonEventErrorThreshold )

            {

            LOGIT1("Over %d consecutive errors, stopping", KConnMonEventErrorThreshold)

            return;

            }

        }

    else

        {

        iErrorCounter = 0;

        iEventInfo.Reset();

        // Send event(s) to clients

        iEventInfo.iConnectionId = iConnectionId;

        iEventInfo.iSubConnectionId = iSubConnectionId;

        iEventInfo.iData = iPckgVolume();

        if ( iDirection == EDownlink )

            {

            iEventInfo.iEventType = EConnMonDownlinkDataThreshold;

            LOGIT2("SERVER: EVENT -> Downlink data <%d>, id <%d>", iEventInfo.iData, iEventInfo.iConnectionId )

            }

        else

            {

            iEventInfo.iEventType = EConnMonUplinkDataThreshold;

            LOGIT2("SERVER: EVENT -> Uplink data <%d>, id <%d>", iEventInfo.iData, iEventInfo.iConnectionId )

            }

        iServer->EventQueue()->Add( iEventInfo );

        }

    // New request

    Receive();

    //LOGEXITFN("CDataNotifier::RunL()")

    }

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

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

// CProgressNotifier::CProgressNotifier

// Priority is set to 10. Progress notifier must have higher priority than

// connection up/down notifier because otherwise connection delete event will

// arrive before status reaches KLinkLayerClosed.

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

//

CProgressNotifier::CProgressNotifier(

        CConnMonServer* aServer,

        RConnection* aConnection,

        const TUint& aConnectionId,

        const TUint& aSubConnectionId )

        :

        CActive( EConnMonPriorityHigh ),

        iServer( aServer ),

        iConnection( aConnection ),

        iConnectionId( aConnectionId),

        iSubConnectionId( aSubConnectionId ),

        iFilter( KNoFiltering )

    {

    }

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

// CProgressNotifier::Construct

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

//

void CProgressNotifier::Construct()

    {

    //LOGENTRFN("CProgressNotifier::Construct()")

    CActiveScheduler::Add( this );

    LOGIT("Created CProgressNotifier")

    //LOGEXITFN("CProgressNotifier::Construct()")

    }

// Destructor

CProgressNotifier::~CProgressNotifier()

    {

    if ( IsActive() )

        {

        Cancel();

        }

    iServer = NULL;

    iConnection = NULL;

    }

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

// CProgressNotifier::Receive

// Requests a new event (connection status changed) from RConnection

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

//

void CProgressNotifier::Receive()

    {

    if ( IsActive() )

        {

        Cancel();

        }

    iInfoBuf().iStage = 0;

    iInfoBuf().iError = 0;

    iConnection->ProgressNotification( iInfoBuf, iStatus );

    SetActive();

    }

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

// CProgressNotifier::Receive

// Requests a new event (connection status changed) from RConnection

// Uses filtering until status reaches aFilter

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

//

void CProgressNotifier::Receive( const TInt aFilter )

    {

    iFilter = aFilter;

    Receive();

    }

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

// CProgressNotifier::IsAuthDelete

// ETrue if the user has deactivated the connection

// by using Connection Monitor or if the applications issued

// RConnection::Stop( RConnection::EStopAuthoritative )

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

//

TBool CProgressNotifier::IsAuthDelete()

    {

    if ( iInfoBuf().iError == KErrConnectionTerminated )

        {

        return ETrue;

        }

    else

        {

        return EFalse;

        }

    }

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

// CProgressNotifier::CanReconnect

// ETrue if might reconnect after closing.

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

//

TBool CProgressNotifier::CanReconnect() const

    {

    // Reconnect is disabled for the moment

    return EFalse;

    }

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

// CProgressNotifier::DoCancel

// Cancels the request from RConnection.

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

//

void CProgressNotifier::DoCancel()

    {

    if ( IsActive() )

        {

        iConnection->CancelProgressNotification();

        }

    }