/*
* 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"

// CONSTANTS
#ifdef __UPNP_CONSOLE_MT__
_LIT( KConnectionBreakdownSimulationFile, "C:\\Data\\Wlan" );
#endif // __UPNP_CONSOLE_MT__



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


// ---------------------------------------------------------------------------
// CUPnPConnectionMonitor::CUPnPConnectionMonitor
// C++ default constructor can NOT contain any code, that
// might leave.
// ---------------------------------------------------------------------------
//
CUPnPConnectionMonitor::CUPnPConnectionMonitor(
    MUPnPConnectionMonitorObserver& aObserver, TInt aAccessPoint ) :
    CActive( EPriorityStandard ),
    iObserver( aObserver ),
    iAccessPoint( aAccessPoint )
    {
    }


// ---------------------------------------------------------------------------
// CUPnPConnectionMonitor::NewL
// Two-phased constructor.
// ---------------------------------------------------------------------------
//
EXPORT_C CUPnPConnectionMonitor* CUPnPConnectionMonitor::NewL(
    MUPnPConnectionMonitorObserver& aObserver, TInt aAccessPoint )
    {
    CUPnPConnectionMonitor* self = new(ELeave) CUPnPConnectionMonitor(
        aObserver, aAccessPoint );
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;    
    }


// ---------------------------------------------------------------------------
// CUPnPConnectionMonitor::ConstructL
// Symbian 2nd phase constructor can leave.
// ---------------------------------------------------------------------------
//
void CUPnPConnectionMonitor::ConstructL()
    {
    __LOG( "CUPnPConnectionMonitor::ConstructL" );

#ifdef __UPNP_CONSOLE_MT__

    // monitor filesystem for connection breakdown simulation
    CActiveScheduler::Add( this );
    User::LeaveIfError( iFs.Connect() );
    iFs.NotifyChange( ENotifyFile, iStatus,
        KConnectionBreakdownSimulationFile );
    SetActive();

#endif // __UPNP_CONSOLE_MT__

    iConnectionMonitor.ConnectL();
    iConnectionMonitor.NotifyEventL( *this );

    ParseCurrentConnections();
    }

// ---------------------------------------------------------------------------
// 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::~CUPnPConnectionMonitor()
// Destructor
// ---------------------------------------------------------------------------
//
CUPnPConnectionMonitor::~CUPnPConnectionMonitor()
    {
#ifdef __UPNP_CONSOLE_MT__

    // stop monitoring filesystem
    Cancel();
    iFs.Close();

#endif // __UPNP_CONSOLE_MT__

    // Disconnect from CM server
    iConnectionMonitor.CancelNotifications();
    iConnectionMonitor.Close();
    }

// ---------------------------------------------------------------------------
// 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 ))
                {
                __LOG( "CUPnPConnectionMonitor::EventL EConnMonCreateConnection \
WLAN connection found" );
                iConnectionId = connectionId;
                }

            break;
            }

        // Connection is deleted
        case EConnMonDeleteConnection:
            {
            const CConnMonDeleteConnection* eventDelete; 
            eventDelete = 
                    ( const CConnMonDeleteConnection* ) &aConnMonEvent;
            connectionId = eventDelete->ConnectionId();
            
            // If there is new id for wlan we will pass if statement
            // because then the current is invalid then
            ParseCurrentConnections();
            if( connectionId == iConnectionId )
                {
                __LOG( "CUPnPConnectionMonitor::EventL EConnMonDeleteConnection \
WLAN connection found" );
                iObserver.ConnectionLost();
                }
            break;
            }
         default:
            {
            break;
            }
        }
    }

// ---------------------------------------------------------------------------
// 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::RunL()
// Active object run loop
// ---------------------------------------------------------------------------
//
void CUPnPConnectionMonitor::RunL()
    {
#ifdef __UPNP_CONSOLE_MT__
    // simulated connection break has been activated
    iObserver.ConnectionLost();
    iFs.Delete( KConnectionBreakdownSimulationFile );
#endif // __UPNP_CONSOLE_MT__
    }

// ---------------------------------------------------------------------------
// CUPnPConnectionMonitor::DoCancel()
// Active object cancel implementation
// ---------------------------------------------------------------------------
//
void CUPnPConnectionMonitor::DoCancel()
    {
#ifdef __UPNP_CONSOLE_MT__
    // cancel notifications from FS
    iFs.NotifyChangeCancel();
#endif // __UPNP_CONSOLE_MT__    
    }

// ---------------------------------------------------------------------------
// CUPnPConnectionMonitor::DebugSimulateConnectionLostL()
// Simulate connection lost case.
// ---------------------------------------------------------------------------
//
EXPORT_C void CUPnPConnectionMonitor::DebugSimulateConnectionLostL()
    {
#ifdef __UPNP_CONSOLE_MT__
    // signal connection breakdown via filesystem
    RFs fs;
    CleanupClosePushL( fs );
    User::LeaveIfError( fs.Connect() );
    TInt err = fs.Delete( KConnectionBreakdownSimulationFile );
    if ( err != KErrNone &&
         err != KErrNotFound )
        {
        User::Leave( err );
        }
    
    RFile file;
    CleanupClosePushL( file );
    User::LeaveIfError( file.Create( fs,
        KConnectionBreakdownSimulationFile, EFileWrite ) );
    
    CleanupStack::PopAndDestroy( &file );
    CleanupStack::PopAndDestroy( &fs );
    
#else // __UPNP_CONSOLE_MT__
    // connection simulation method called, but feature is not active !
    __PANICD( __FILE__, __LINE__ );
#endif // __UPNP_CONSOLE_MT__
    }

// end of file