/*

* Copyright (c) 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: CirWatcher for UDP

*

*

*/

// INCLUDE FILES

#include <ecom/ecom.h>

#include <f32file.h>

#include <flogger.h>

#include <msgconnmanagerapi.h>

#include "UdpCirWatcher.h"

#include "UdpSocketListener.h"

#include "CirWatcherDefines.h"

#include "ImpsIpCirWatcherAPI.h"

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

//

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

// CUdpCirWatcher::CUdpCirWatcher

//

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

//

CUdpCirWatcher::CUdpCirWatcher() : iReferenceCount( 1 )

    {

    }

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

// CUdpCirWatcher::NewL

//

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

//

CUdpCirWatcher* CUdpCirWatcher::NewL()

    {

    CUdpCirWatcher* self = NULL;

    if ( Dll::Tls() == NULL )

        {

        self = new ( ELeave ) CUdpCirWatcher();

        CleanupStack::PushL( self );

        self->ConstructL();

        CleanupStack::Pop();

        Dll::SetTls( self );

        }

    else

        {

        self = static_cast<CUdpCirWatcher*>( Dll::Tls() );

        self->IncreaseReferenceCount();

        }

    return self;

    }

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

// CUdpCirWatcher::Destroy

// Destructor

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

//

void CUdpCirWatcher::Destroy()

    {

    DecreaseReferenceCount();

    CImpsUdpCirWatcher::Destroy();

    if ( ReferenceCount() == 0 )

        {

        Dll::FreeTls();

        delete this;

        }

    }

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

// CUdpCirWatcher::DeleteSingleton

// Destructor

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

//

void CUdpCirWatcher::DeleteSingleton()

    {

    CImpsUdpCirWatcher::DeleteSingleton();

    Dll::FreeTls();

    delete this;

    }

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

// CUdpCirWatcher::Destroy

//

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

//

void CUdpCirWatcher::StoreDestructorKeyL( const TUid aDestructorKey )

    {

    User::LeaveIfError( iDestructorKeyArray.Append( aDestructorKey ) );

    }

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

// CUdpCirWatcher::ConstructL

//

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

//

void CUdpCirWatcher::ConstructL()

    {

#ifdef _DEBUG

    DeleteLogFileL();

    CUdpCirWatcher::WriteToLog( _L8( "CUdpCirWatcher::ConstructL()" ) );

#endif

    User::LeaveIfError( iSocketSession.Connect() );

    }

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

// CTcpCirWatcher::DeleteLogFileL

//

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

//

void CUdpCirWatcher::DeleteLogFileL()

    {

    RFs session;

    User::LeaveIfError( session.Connect() );

    CFileMan* manager = CFileMan::NewL( session );

    manager->Delete( _L( "C:\\Logs\\ImpsUdpWatcher\\*.*" ) );

    session.Close();

    delete manager;

    manager = NULL;

    }

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

// CUdpCirWatcher::~CUdpCirWatcher

// Destructor

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

//

CUdpCirWatcher::~CUdpCirWatcher()

    {

#ifdef _DEBUG

    CUdpCirWatcher::WriteToLog( _L8( "CUdpCirWatcher::~CUdpCirWatcher()" ) );

#endif

    iListenerQueue.ResetAndDestroy();

    iListenerQueue.Close();

    iSocketSession.Close();

#ifdef _DEBUG

    CUdpCirWatcher::WriteToLog( _L8( " Destructor ends" ) );

#endif

    }

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

// CUdpCirWatcher::FindListener

//

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

//

TBool CUdpCirWatcher::FindListenerL( const TInt aServicePort,

                                     const MImpsCirReceiver& aCirReceiver )

    {

#ifdef _DEBUG

    CUdpCirWatcher::WriteToLog( _L8( "CUdpCirWatcher::FindListener()" ) );

#endif

    TBool found = EFalse;

    TInt count = iListenerQueue.Count();

    CUdpSocketListener* listener = NULL;

    for ( TInt i = 0;!found && i < count;i++ )

        {

        listener = iListenerQueue[i];

        if ( listener->ServicePort() == aServicePort )

            {

#ifdef _DEBUG

            CUdpCirWatcher::WriteToLog( _L8(

                                            "  Port %d already on watch, attach the new listener to it" ), aServicePort );

#endif

            found = ETrue;

            listener->AppendReceiverL( aCirReceiver );

            }

        }

    return found;

    }

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

// CUdpCirWatcher::FindListener

//

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

//

CUdpSocketListener* CUdpCirWatcher::FindListener( TInt& aIndex,

                                                  const TInt aServicePort ) const

    {

#ifdef _DEBUG

    CUdpCirWatcher::WriteToLog( _L8( "CUdpCirWatcher::FindListener()" ) );

#endif

    TBool found = EFalse;

    TInt count = iListenerQueue.Count();

    CUdpSocketListener* listener = NULL;

    for ( TInt i = 0;!found && i < count;i++ )

        {

        listener = iListenerQueue[i];

        if ( listener->ServicePort() == aServicePort )

            {

            found = ETrue;

            aIndex = i;

            }

        }

    return listener;

    }

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

// CUdpCirWatcher::CreateListenerL

//

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

//

TInt CUdpCirWatcher::CreateListenerL( const TInt aServicePort,

                                      const MImpsCirReceiver& aCirReceiver )

    {

#ifdef _DEBUG

    CUdpCirWatcher::WriteToLog( _L8( "CUdpCirWatcher::CreateListenerL()" ) );

#endif

    CUdpSocketListener* listener = CUdpSocketListener::NewL( aServicePort, aCirReceiver );

    CleanupStack::PushL( listener );

    User::LeaveIfError( iListenerQueue.Append( listener ) );

    CleanupStack::Pop();  //listener

    return listener->StartUdpSocketListen( iSocketSession );

    }

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

// CUdpCirWatcher::RegisterCirReceiverL

//

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

//

void CUdpCirWatcher::RegisterCirReceiverL( const MImpsCirReceiver& aCirReceiver,

                                           const TInt aServicePort )

    {

#ifdef _DEBUG

    CUdpCirWatcher::WriteToLog( _L8( "CUdpCirWatcher::RegisterCirReceiverL() - Port: %d" ), aServicePort );

#endif

    TInt count = iListenerQueue.Count();

    if ( count > 0 )

        {

        if ( !FindListenerL( aServicePort, aCirReceiver ) )

            User::LeaveIfError( CreateListenerL( aServicePort, aCirReceiver ) );

        }

    else

        User::LeaveIfError( CreateListenerL( aServicePort, aCirReceiver ) );

    }

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

// CUdpCirWatcher::UnregisterCirReceiverL

//

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

//

void CUdpCirWatcher::UnregisterCirReceiverL( const MImpsCirReceiver& aCirReceiver )

    {

#ifdef _DEBUG

    CUdpCirWatcher::WriteToLog( _L8( "CUdpCirWatcher::UnregisterCirReceiverL()" ) );

#endif

    TBool found = EFalse;

    TInt count = iListenerQueue.Count();

    if ( count > 0 )

        {

        CUdpSocketListener* listener = NULL;

        for ( TInt i = 0;!found && i < count;i++ )

            {

            listener = iListenerQueue[i];

            if ( listener->Contains( aCirReceiver ) >= 0 )

                {

                found = ETrue;

                if ( !listener->RemoveReceiver( aCirReceiver ) )

                    {

                    iListenerQueue.Remove( i );

                    delete listener;

                    listener = NULL;

                    }

                }

            }

        if ( !found )

            User::Leave( KErrNotFound );

        }

    }

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

// CUdpCirWatcher::Reset

//

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

//

void CUdpCirWatcher::Reset( const TInt aServicePort )

    {

#ifdef _DEBUG

    CUdpCirWatcher::WriteToLog( _L8( "CUdpCirWatcher::Reset() - Port: %d" ), aServicePort );

#endif

    CUdpSocketListener* listener = NULL;

    if ( aServicePort != KErrArgument )

        {

        TInt index = KErrNotFound;

        listener = FindListener( index, aServicePort );

        if ( listener != NULL && index >= 0 )

            {

            iListenerQueue.Remove( index );

            delete listener;

            listener = NULL;

            }

        }

    else

        {

        TInt count = iListenerQueue.Count();

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

            {

            listener = iListenerQueue[i];

            iListenerQueue.Remove( i );

            delete listener;

            listener = NULL;

            }

        }

    }

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

// CUdpCirWatcher::IncreaseReferenceCount

//

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

//

void CUdpCirWatcher::IncreaseReferenceCount()

    {

    iReferenceCount++;

    }

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

// CUdpCirWatcher::DecreaseReferenceCount

//

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

//

void CUdpCirWatcher::DecreaseReferenceCount()

    {

    iReferenceCount--;

    }

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

// CUdpCirWatcher::ReferenceCount

//

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

//

const TInt CUdpCirWatcher::ReferenceCount() const

    {

    return iReferenceCount;

    }

#ifdef _DEBUG

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

// CCIRWatcher::WriteToLog

//

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

//

void CUdpCirWatcher::WriteToLog( TRefByValue<const TDesC8> aFmt, ... )

    {

    VA_LIST list;

    VA_START( list, aFmt );

    TBuf8<KUdpLogBufferMaxSize> buf;

    buf.FormatList( aFmt, list );

    RFileLogger::Write( KUdpLogDir, KUdpWatcherLogFile, EFileLoggingModeAppend, buf );

    }

#endif

// End of File