/*

* Copyright (c) 2008 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:  UPnP Connection Monitor class implementation.

*

*/

// INCLUDE FILES

#include <nifvar.h>

#include "upnpconnectionmonitor.h"

// logging

_LIT( KComponentLogfile, "upnputilities.txt");

#include "upnplog.h"

const TInt KWaitIapInterval = 10000000; // 10 seconds

const TInt KWaitIapMaximum = 180000000; // 3 minutes

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

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

// CUPnPConnectionMonitor::NewL

// Two-phased constructor.

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

//

EXPORT_C CUPnPConnectionMonitor* CUPnPConnectionMonitor::NewL( TInt aAccessPoint )

    {

    CUPnPConnectionMonitor* self = new(ELeave) CUPnPConnectionMonitor( aAccessPoint );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;    

    }

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

// CUPnPConnectionMonitor::~CUPnPConnectionMonitor()

// Destructor

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

//

CUPnPConnectionMonitor::~CUPnPConnectionMonitor()

    {

    Cancel();

    // Disconnect from CM server

    iConnectionMonitor.CancelNotifications();

    iConnectionMonitor.Close();

    iTimer.Close();

    DeleteTimeoutTimer();

    }

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

// CUPnPConnectionMonitor::SetObserver

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

//

EXPORT_C void CUPnPConnectionMonitor::SetObserver(

    MUPnPConnectionMonitorObserver& aObserver )

    {

    iObserver = &aObserver;

    }

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

// CUPnPConnectionMonitor::NotifyIap

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

//

EXPORT_C void CUPnPConnectionMonitor::NotifyIap( TInt aAccessPoint )

    {

    __LOG1( "CUPnPConnectionMonitor::NotifyIap, aAccessPoint %d", aAccessPoint );

    iAccessPoint = aAccessPoint;

    if( IsActive() )

        {

        Cancel();

        }

    DeleteTimeoutTimer();

    // Create a timer for switching off Iap observation.

    iTimeout = CPeriodic::NewL( CActive::EPriorityStandard );

    iTimeout->Start( KWaitIapMaximum, KWaitIapMaximum, TCallBack( TimeoutCallback, this ) );

    // EConnMonIapAvailabilityChange event is generated only is there is

    // background scanning active. That is why iap is checked actively here.

    iMonitorState = EMonitorStateWait;

    iTimer.After( iStatus, KWaitIapInterval );

    SetActive();

    }

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

// CUPnPConnectionMonitor::NotifyIapCancel

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

//

EXPORT_C void CUPnPConnectionMonitor::NotifyIapCancel()

    {

    __LOG( "CUPnPConnectionMonitor::NotifyIapCancel" );

    DeleteTimeoutTimer();

    Cancel();

    }

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

// CUPnPConnectionMonitor::DoCancel()

// Active object cancel implementation

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

//

void CUPnPConnectionMonitor::DoCancel()

    {

    __LOG( "CUPnPConnectionMonitor::DoCancel" );

    iTimer.Cancel();

    }

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

// CUPnPConnectionMonitor::RunL()

// Active object run loop

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

//

void CUPnPConnectionMonitor::RunL()

    {

    __LOG2( "CUPnPConnectionMonitor::RunL, state %d, iStatus %d", 

        iMonitorState, iStatus.Int() );

    switch( iMonitorState )

        {

        case EMonitorStateWait:

            {

            iMonitorState = EMonitorStateIap;

            iConnectionMonitor.GetPckgAttribute(

                    EBearerIdWLAN,

                    0,

                    KIapAvailability,

                    iIapBuf,

                    iStatus );

            SetActive();

            break;

            }

        case EMonitorStateIap:

            {

            TBool found( EFalse );

            TConnMonIapInfo iaps = iIapBuf();

            TInt count( iaps.Count() );

            __LOG2( "CUPnPConnectionMonitor::RunL, iapCount %d, iAccessPoint %d", 

                count, iAccessPoint );

            for( TInt i = 0; i < count; i++ )

                {

                __LOG1( "CUPnPConnectionMonitor::RunL, iap %d", iaps.iIap[i].iIapId );

                if( iaps.iIap[i].iIapId == iAccessPoint )

                    {

                    found = ETrue;

                    DeleteTimeoutTimer();

                    if( iObserver )

                        {

                        iObserver->IapAvailable( iAccessPoint );

                        }

                    break;

                    }

                }

            if( !found )

                {

                iMonitorState = EMonitorStateWait;

                iTimer.After( iStatus, KWaitIapInterval );

                SetActive();

                }

            break;

            }

        default:

            break;

        }

    }

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

// CUPnPConnectionMonitor::EventL()

// Receives event from connection monitor

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

//

void CUPnPConnectionMonitor::EventL( const CConnMonEventBase& aConnMonEvent )

    {

    __LOG1( "CUPnPConnectionMonitor::EventL type %d", aConnMonEvent.EventType() );

    TUint connectionId = 0;

    switch ( aConnMonEvent.EventType() )

        {

        case EConnMonCreateConnection:

            {

            const CConnMonCreateConnection* eventCreate; 

            eventCreate = (const CConnMonCreateConnection*)&aConnMonEvent;

            connectionId = eventCreate->ConnectionId();

            // Save connectionId if type is WLAN

            if( IsWlanConnection( connectionId ))

                {

                __LOG1( "CUPnPConnectionMonitor::EventL EConnMonCreateConnection \

WLAN connection found, connectionId %d", connectionId );

                if( iObserver )

                    {

                    iObserver->ConnectionCreated( connectionId );

                    }

                iConnectionIdOnCreate = connectionId;

                }

            break;

            }

        // Connection is deleted

        case EConnMonDeleteConnection:

            {

            const CConnMonDeleteConnection* eventDelete; 

            eventDelete = 

                    ( const CConnMonDeleteConnection* ) &aConnMonEvent;

            connectionId = eventDelete->ConnectionId();

            __LOG3( "CUPnPConnectionMonitor::EventL EConnMonDeleteConnection \

WLAN connection lost, connectionId %d (%d, %d)", 

                connectionId, iConnectionId, iConnectionIdOnCreate );

            // If there is new id for wlan we will pass if statement

            // because then the current is invalid then

            ParseCurrentConnections();

            if( connectionId == iConnectionId || 

                connectionId == iConnectionIdOnCreate )

                {

                TBool authoritativeDelete = eventDelete->AuthoritativeDelete();

                __LOG1( "CUPnPConnectionMonitor::EventL EConnMonDeleteConnection \

authoritativeDelete %d", authoritativeDelete );

                if( iObserver )

                    {

                    iObserver->ConnectionLost( authoritativeDelete );

                    }

                }

            break;

            }

         default:

            {

            break;

            }

        }

    }

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

// CUPnPConnectionMonitor::CUPnPConnectionMonitor

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

// might leave.

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

//

CUPnPConnectionMonitor::CUPnPConnectionMonitor( TInt aAccessPoint ) :

    CActive( EPriorityStandard ),

    iAccessPoint( aAccessPoint )

    {

    }

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

// CUPnPConnectionMonitor::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CUPnPConnectionMonitor::ConstructL()

    {

    __LOG( "CUPnPConnectionMonitor::ConstructL" );

    CActiveScheduler::Add( this );

    iConnectionMonitor.ConnectL();

    iConnectionMonitor.NotifyEventL( *this );

    ParseCurrentConnections();

    User::LeaveIfError(iTimer.CreateLocal());

    }

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

// CUPnPConnectionMonitor::IsWlanConnection()

// Checks if connection type is WLAN

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

//

TBool CUPnPConnectionMonitor::IsWlanConnection( TInt aConnectionId)

    {

    __LOG( "CUPnPConnectionMonitor::IsWlanConnection" );

    TBool ret = EFalse;

    TInt bearer = 0;

    TInt bearerinfo = 0;

    TRequestStatus status = KRequestPending;

    iConnectionMonitor.GetIntAttribute( 

                                    aConnectionId, 

                                    0, 

                                    KBearer, 

                                    (TInt &) bearer,

                                    status );

    User::WaitForRequest( status ); 

    TRequestStatus status2 = KRequestPending;

    iConnectionMonitor.GetIntAttribute( 

                                    aConnectionId, 

                                    0, 

                                    KBearerInfo, 

                                    (TInt &) bearerinfo,

                                    status2 );

    User::WaitForRequest( status2 ); 

    if( bearer == EBearerWLAN && bearerinfo == EBearerWLAN )

        {

        ret = ETrue;

        }

    return ret;

    }

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

// CUPnPConnectionMonitor::ParseCurrentConnections()

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

//

void CUPnPConnectionMonitor::ParseCurrentConnections()

    {    

    // Get the count of connections

    TRequestStatus status = KRequestPending;

    TUint connectionCount = 0;

    iConnectionMonitor.GetConnectionCount(connectionCount, status);

    User::WaitForRequest( status ); 

    // Go through available connections and check to see

    // WLAN connection is already running

    if( !status.Int() )

        {

        for( TUint i=1; i < connectionCount+1;  i++ )

            {

            TUint connectionId;

            TUint subConnectionCount;

            iConnectionMonitor.GetConnectionInfo( 

                                            i,

                                            connectionId, 

                                            subConnectionCount);

            if( IsWlanConnection( connectionId ) )

                {

                __LOG( "CUPnPConnectionMonitor - Found WLAN connection" );

                iConnectionId = connectionId;

                }

            }   

        }  

    __LOG2( "CUPnPConnectionMonitor::ParseCurrentConnections() \

    wlanId = %d connectionCount = %d ", iConnectionId , connectionCount );

    }

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

// CUPnPConnectionMonitor::TimeoutCallback

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

//

TInt CUPnPConnectionMonitor::TimeoutCallback( TAny* aSelf )

    {

    __LOG( "CUPnPConnectionMonitor::TimeoutCallback" );

    if( aSelf )

        {

        CUPnPConnectionMonitor* self = static_cast<CUPnPConnectionMonitor*>( aSelf );

        self->StopIapObservation();

        }

    return KErrNone;

    }

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

// CUPnPConnectionMonitor::StopIapObservation

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

//

void CUPnPConnectionMonitor::StopIapObservation()

    {

    __LOG( "CUPnPConnectionMonitor::StopIapObservation" );

    DeleteTimeoutTimer();

    Cancel();

    }

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

// CUPnPConnectionMonitor::DeleteTimeoutTimer

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

//

void CUPnPConnectionMonitor::DeleteTimeoutTimer()

    {

    __LOG( "CUPnPConnectionMonitor::DeleteTimeoutTimer" );

    if( iTimeout )

        {

        iTimeout->Cancel();

        delete iTimeout;

        iTimeout = 0;

        }

    }

// end of file