/*

* Copyright (c) 2003-2005 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:  Im circle Manager.

*

*

*/

// INCLUDE FILES

#include    <e32std.h>

#include    "impsactivecirmonitor.h"

#include    "impsutils.h"

#include    <msgconnmanagerapi.h>

// CONSTANTS

// TCP/IP CIR ping interval in seconds

const TInt KImpsPingInt = 900;

// MACROS

#ifndef _DEBUG

#define _NO_IMPS_LOGGING_

#endif

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

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

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

// might leave.

//

//**********************************

// CImpsCirManager

//**********************************

CImpsCirManager::CImpsCirManager(

    MImpsCSPSession& aServer,

    TInt aPriority )

        : CActive( aPriority ),

        iServer( aServer ),

        iState( EImpsCirOffline ),

        iCanceled( EFalse ),

        iManager( NULL ),

        iTCPWatcher( NULL ),

        iUDPWatcher( NULL ),

        iChannels ( 0 ),

        iReqChannels ( 0 )

    {

    // Add this to the scheduler

    CActiveScheduler::Add( this );

    }

// EPOC default constructor can leave.

void CImpsCirManager::ConstructL()

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "CImpsCirManager: Constructor rel200517.1+" ) );

#endif

    }

// Two-phased constructor.

CImpsCirManager* CImpsCirManager::NewL(

    MImpsCSPSession& aServer,

    TInt aPriority )

    {

    CImpsCirManager* self = new ( ELeave ) CImpsCirManager(

        aServer, aPriority );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

// Destructor

CImpsCirManager::~CImpsCirManager()

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "CImpsCirManager: Destructor" ) );

#endif

    Cancel();

    if ( iTCPWatcher )

        {

        delete iTCPWatcher;

        iTCPWatcher = NULL;

        }

    if ( iUDPWatcher )

        {

        iUDPWatcher->Destroy();

        iUDPWatcher = NULL;

        }

    // REcomSession::FinalClose() is not called here but in the engine core

    // just before active acheduler is stopped.

    }  //lint !e1740 iManager is not deleted here, it's only reference

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

// CImpsCirManager::OpenChL

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

//

void CImpsCirManager::OpenChL(

    TImpsCirChannels aChannels,

    MMsgConnManager& aManager,

    TUint aServerport,

    const TDesC& aServerAddress,

    const TDesC8& aCSPSessionID,

    TUint aUDPPort )

    {

    if  ( ( iState == EImpsCirOnline ) || ( aChannels == 0 ) )

        {

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "CImpsCirManager: OpenChL ignored" ) );

#endif

        iServer.CirChOpened();

        // Nothing to open

        return;

        }

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "CImpsCirManager: OpenChL" ) );

#endif

    iManager = &aManager;

    iReqChannels = aChannels;

    iUDPPort = aUDPPort;

    // Start TCP watcher first if required

    if ( ( aChannels & KImpsCirTcp ) && ~( iChannels & KImpsCirTcp ) )

        {

        DoOpenTCPL( aServerport, aServerAddress,

                    aCSPSessionID );

        // Another watcher started in RunL if needed

        }

    // UPD start here if TCP not required

    else if ( ( aChannels & KImpsCirUdp ) && ~( iChannels & KImpsCirUdp ) )

        {

        DoOpenUDP( iUDPPort );

        }

    }

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

// CImpsCirManager::DoOpenTCPL

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

//

void CImpsCirManager::DoOpenTCPL(

    TUint aServerport,

    const TDesC& aServerAddress,

    const TDesC8& aCSPSessionID )

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "CImpsCirManager: DoOpenTCPL" ) );

#endif

    // If opening fails then this method leaves. TCP is tried to open

    // so CSP session gets information about failure.

    // Start watchers, TCP watcher first

    iTCPWatcher = CImpsTcpCirWatcher::NewL( KImpsPingInt, *this, *iManager );

    iState = EImpsCirOpeningTcp;

    ActivateMe();

    iTCPWatcher->StartTCPWatcherL( iStatus, aServerport, aServerAddress, aCSPSessionID );

    }

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

// CImpsCirManager::DoOpenUDP

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

//

void CImpsCirManager::DoOpenUDP(

    TUint aUDPPort )

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "CImpsCirManager: DoOpenUDP" ) );

#endif

    // UPD watcher registeration

    TInt err = KErrNone;

    TRAP( err, iUDPWatcher = CImpsUdpCirWatcher::NewL() );

    if ( err )

        {

        // UDP open erros are reported to csp session asynchronously via RunL

        DoHandleError( err, EImpsUdpCir );

        }

    TRAP( err, iUDPWatcher->RegisterCirReceiverL( *this, aUDPPort ) );

    if ( err )

        {

        // UDP open erros are reported to csp session asynchronously via RunL

        DoHandleError( err, EImpsUdpCir );

        }

    else

        {

        iChannels = iChannels | KImpsCirUdp;

        }

    }

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

// CImpsCirManager::CloseCh

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

//

void CImpsCirManager::CloseCh(

    TImpsCirChannels aChannels )

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "CImpsCirManager: CloseCh" ) );

#endif

    // If active then have to wait

    Cancel();

    if ( !( aChannels & iChannels ) ||

         iState == EImpsCirOffline ||

         ( !iTCPWatcher && !iUDPWatcher ) )

        {

        // Nothing to close

        return;

        }

    // Channels that required to be closed

    iReqChannels = aChannels;

    // Close TCP

    if ( ( iReqChannels & KImpsCirTcp ) &&

         ( iChannels & KImpsCirTcp ) )

        {

        iTCPWatcher->StopTCPWatcher();

        iChannels = iChannels & ~KImpsCirTcp;

        }

    // Close UDP

    if ( ( iReqChannels & KImpsCirUdp ) &&

         ( iChannels & KImpsCirUdp ) )

        {

        TInt err = KErrNone;

        TRAP( err, iUDPWatcher->UnregisterCirReceiverL( *this ) );

        iChannels = iChannels & ~KImpsCirUdp;

        }

    // Destructor handles the rest of the shut down activies

    iState = EImpsCirOffline;

    }

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

// CImpsCirManager::CirReceivedL

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

//

void CImpsCirManager::CirReceivedL(

    const TDesC8& aMessage,

    const TImpsSupportedCirTypes aCirType )

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "CImpsCirManager: CirReceivedL type=%d" ), aCirType );

#endif

    // notice: This is not very clear how to handle multiple IP-CIR channels

    // Better keep on listening them

    /*

    if ( ( aCirType == EImpsTcpCir ) && ( iChannels & KImpsCirUdp ) )

        {

        // Stop UDP if another CIR channel in use

        iUDPWatcher->StopUDPWatcher();

        }

    else if ( ( aCirType == EImpsUdpCir ) && ( iChannels & KImpsCirTcp ) )

        {

        // Stop TCP if another CIR channel in use

        iTCPWatcher->StopTCPWatcher();

        }

        */

    iServer.CirMessageL( aMessage );

    }

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

// CImpsCirManager::HandleErrorL

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

//

void CImpsCirManager::HandleErrorL(

    const TInt aReceiverError,

    const TImpsSupportedCirTypes aCirType )

    {

    DoHandleError( aReceiverError, aCirType );

    }

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

// CImpsCirManager::DoHandleError

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

//

void CImpsCirManager::DoHandleError(

    const TInt aReceiverError,

    const TImpsSupportedCirTypes aCirType )

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "CImpsCirManager: DoHandleError %d type=%d" ),

                            aReceiverError, aCirType );

#endif

    // We suppose that this is not called if this is active, but

    // better to check anyway. Then do the following actions.

    // - Yield to ifself with an error code.

    // - In RunL stop channels

    // - Then call iServer.CirChError() that destroys us.

    if ( !IsActive() )

        {

        iStatus = KRequestPending;

        SetActive();

        iCanceled = EFalse;

        TRequestStatus* s = &iStatus;

        User::RequestComplete( s, aReceiverError );

        }

    }

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

// CImpsCirManager::RunL

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

//

void CImpsCirManager::RunL( )

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "CImpsCirManager: RunL %d" ), iStatus.Int() );

#endif

    if ( iCanceled )

        {

#ifndef _NO_IMPS_LOGGING_

        CImpsClientLogger::Log( _L( "CImpsCirManager: RunL ignored" ) );

#endif

        iCanceled = EFalse;

        if ( iChannels )

            {

            iState = EImpsCirOnline;

            }

        else

            {

            iState = EImpsCirOffline;

            }

        return;

        }

    // Error handling, common for both open methods and HandleErrorL methods.

    // CSP session entity will call destrcutor, so no need to do else than

    // close watcher

    if ( iStatus.Int() != KErrNone )

        {

        if ( iState == EImpsCirOnline )

            {

            if ( iChannels & KImpsCirTcp )

                {

                iTCPWatcher->StopTCPWatcher();

                }

            if ( iChannels & KImpsCirUdp )

                {

                TInt err = KErrNone;

                TRAP( err, iUDPWatcher->UnregisterCirReceiverL( *this ) );

                }

            iState = EImpsCirOffline;

            }

        iServer.CirChError();

        return;

        }

    // asynchronous TCP CIR opening completed

    if ( iState == EImpsCirOpeningTcp )

        {

        iChannels = iChannels | KImpsCirTcp;

        // if UDP were supported

        if ( ( iReqChannels & KImpsCirUdp ) &&

             !( iChannels & KImpsCirUdp ) )

            {

            // load UDP listener synchronously

            DoOpenUDP( iUDPPort );

            }

        }

    // Everything is OK and opened

    iState = EImpsCirOnline;

    iServer.CirChOpened();

    }

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

// CImpsCirManager::DoCancel

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

//

void CImpsCirManager::DoCancel()

    {

#ifndef _NO_IMPS_LOGGING_

    CImpsClientLogger::Log( _L( "CImpsCirManager: DoCancel" ) );

#endif

    // This just waits IAP connection operation to end.

    iCanceled = ETrue;

    if ( iState == EImpsCirOpeningTcp )

        {

        // This returns KErrCancel if an operation is not ready

        iTCPWatcher->StopTCPWatcher();

        }

    }

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

// CImpsCirManager::ActivateMe

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

//

TInt CImpsCirManager::ActivateMe(  )

    {

    if ( !IsActive() )

        {

        iStatus = KRequestPending;

        SetActive();

        iCanceled = EFalse;

        return KErrNone;

        }

    else

        {

        return KErrNotReady;

        }

    }

//  End of File