/*

* Copyright (c) 2009 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:  UDP packet sender

*

*/

// INCLUDE FILES

#include "CUDPSender.h"

#include "MUDPSenderObserver.h"

#include <badesca.h>

#define DEBUG_FILENAME "IPProxyEngine.log"

#include "DebugPrint.h"

const TInt KServerBusyWaiting = 200000;  //200 ms delay

const TInt KUDPSenderSlots = 50;

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

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

// CUDPSender::CUDPSender

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

//

CUDPSender::CUDPSender( MUDPSenderObserver* aObserver ) :

    CActive( EPriorityStandard ), iObserver( aObserver )

    {

    __ASSERT_DEBUG( iObserver, User::Invariant() );

    }

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

// CUDPSender::ConstructL

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

//

void CUDPSender::ConstructL()

    {

    User::LeaveIfError( iSocketServ.Connect( KUDPSenderSlots ) );

    // Create the socket

    User::LeaveIfError( iSocket.Open( iSocketServ, KAfInet, KSockDatagram,

        KProtocolInetUdp  ) );

    iRemoteAddr.SetAddress(KInetAddrLoop);

    iTransferBufferArray = new (ELeave) CDesC8ArraySeg( 10 );

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

    CActiveScheduler::Add( this );

    }

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

// CUDPSender::NewL

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

//

CUDPSender* CUDPSender::NewL( MUDPSenderObserver* aObserver )

    {

    CUDPSender* self = CUDPSender::NewLC( aObserver );

    CleanupStack::Pop();

    return self;

    }

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

// CUDPSender::NewLC

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

//

CUDPSender* CUDPSender::NewLC( MUDPSenderObserver* aObserver )

    {

    CUDPSender* self = new( ELeave ) CUDPSender( aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// Destructor

CUDPSender::~CUDPSender()

    {

    Cancel();

    iSocket.Close();

    iSocketServ.Close();

    iTimer.Close();

    delete iTransferBufferArray;

    }

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

// CUDPSender::IssueWriteL

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

//

void CUDPSender::IssueWriteL( TUint aPort, const TDesC8& aData )

    {

    iRemoteAddr.SetPort(aPort);

    // slice the size of data if bigger than KWriteBufferSize

    TInt dsize = aData.Size();

    for ( TInt i = 0; i < dsize; i+=KWriteBufferSize )

        {

        if ( i + KWriteBufferSize - 1 >= dsize )

            {

            __ASSERT_DEBUG( i + aData.Mid( i ).Size() == dsize ,

                User::Panic( _L( "writer" ), 100 ) );

            iTransferBufferArray->AppendL( aData.Mid(i) );

            }

        else

            {

            iTransferBufferArray->AppendL( aData.Mid( i, KWriteBufferSize ) );

            }

        }

    if ( !IsActive() )

        {

        IssueWrite();

        }

    }

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

// CUDPSender::IssueWrite

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

void CUDPSender::IssueWrite()

    {

    DEBUG_PRINT( DEBUG_STRING(

        "CUDPSender::IssueWrite" ) );

    iWriteBuffer = (*iTransferBufferArray)[ 0 ];

    DEBUG_PRINT( DEBUG_STRING(

        "CSocketWriter::IssueWrite()" ) );

    iSocket.SendTo( iWriteBuffer, iRemoteAddr, 0, iStatus );

    SetActive();

    }

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

// CUDPSender::ContinueAfterError

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

void CUDPSender::ContinueAfterError()

    {

    if ( iTransferBufferArray->Count() > 0 )

        {

        IssueWrite();

        }

    }

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

// CUDPSender::ResetTransferBuffer

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

void CUDPSender::ResetTransferBuffer()

    {

    iTransferBufferArray->Reset();

    }

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

// CUDPSender::RunL

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

//

void CUDPSender::RunL()

    {

    TInt status = iStatus.Int();

    if ( status == KErrNone )

        {

        if ( iWaiting )

            {

            DEBUG_PRINT( DEBUG_STRING(

                "Trying to write again..." ) );

            iWaiting = EFalse;

            IssueWrite();

            }

        else

            {

            iTransferBufferArray->Delete( 0 );

            if ( iTransferBufferArray->Count() > 0 )

                {

                IssueWrite();

                }

            }

        }

    else

        {

        DEBUG_PRINT( DEBUG_STRING(

            "CUDPSender::RunL(), iStatus=%d" ), status );

        iObserver->UDPSenderErrorL( status );

        //If Socket server is busy, wait for a while and try again

        if ( status == KErrServerBusy )

            {

            DEBUG_PRINT( DEBUG_STRING(

                "Socket server busy. Waiting for a while..." ) );

            iWaiting = ETrue;

            iTimer.After( iStatus, KServerBusyWaiting );

            SetActive();

            }

        }

    }

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

// CUDPSender::DoCancel

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

//

void CUDPSender::DoCancel()

    {

    iTimer.Cancel();

    iSocket.CancelWrite();

    }

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

// CUDPSender::RunError

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

//

TInt CUDPSender::RunError( TInt aError )

    {

    iObserver->UDPSenderLeavedL( aError );

    return KErrNone;

    }