/*

* 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:  Socket writer

*

*/

// INCLUDE FILES

#include "CSocketWriter.h"

#include "MSocketWriterObserver.h"

#include <in_sock.h>

#include <badesca.h>

#define DEBUG_FILENAME "IPProxyEngine.log"

#include "DebugPrint.h"

const TInt KServerBusyWaiting = 200000;  //200 ms delay

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

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

// CSocketWriter::CSocketWriter

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

//

CSocketWriter::CSocketWriter( RSocket& aSocket,

        TInt aUDPRemotePort /*= -1*/ ) :

    CActive( EPriorityStandard ),

    iSocket( aSocket ),

    iUDPRemotePort( aUDPRemotePort )

    {

    }

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

// CSocketWriter::ConstructL

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

//

void CSocketWriter::ConstructL()

    {

    iTransferBufferArray = new (ELeave) CDesC8ArraySeg( 10 );

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

    CActiveScheduler::Add( this );

    }

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

// CSocketWriter::NewL

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

//

CSocketWriter* CSocketWriter::NewL( RSocket& aSocket,

        TInt aUDPRemotePort /* = -1 */ )

    {

    CSocketWriter* self = CSocketWriter::NewLC( aSocket,

        aUDPRemotePort );

    CleanupStack::Pop();

    return self;

    }

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

// CSocketWriter::NewLC

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

//

CSocketWriter* CSocketWriter::NewLC( RSocket& aSocket,

        TInt aUDPRemotePort /* = -1 */ )

    {

    CSocketWriter* self = new( ELeave ) CSocketWriter( aSocket,

        aUDPRemotePort );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// Destructor

CSocketWriter::~CSocketWriter()

    {

    Cancel();

    iTimer.Close();

    delete iTransferBufferArray;

    }

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

// CSocketWriter::SetObserver

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

//

void CSocketWriter::SetObserver( MSocketWriterObserver* aObserver )

    {

    iObserver = aObserver;

    }

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

// CSocketWriter::IssueWriteL

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

//

void CSocketWriter::IssueWriteL( const TDesC8& aData )

    {

    // 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();

        }

    }

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

// CSocketWriter::IssueWrite

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

void CSocketWriter::IssueWrite()

    {

    DEBUG_PRINT( DEBUG_STRING(

        "CSocketWriter::IssueWrite" ) );

    iWriteBuffer = (*iTransferBufferArray)[ 0 ];

    TProtocolDesc desc;

    iSocket.Info( desc );

    if ( desc.iProtocol == KProtocolInetUdp && iUDPRemotePort > -1 )

        {

        // UDP

        DEBUG_PRINT( DEBUG_STRING(

            "CSocketWriter::IssueWrite(), UDP, remote port=%d" ),

            iUDPRemotePort );

        TInetAddr addrLocalHost( KInetAddrLoop, iUDPRemotePort );

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

        }

    else

        {

        // TCP

        iSocket.Write( iWriteBuffer, iStatus );

        }

    SetActive();

    }

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

// CSocketWriter::ContinueAfterError

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

void CSocketWriter::ContinueAfterError()

    {

    if ( iTransferBufferArray->Count() > 0 )

        {

        IssueWrite();

        }

    }

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

// CSocketWriter::ResetTransferBuffer

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

void CSocketWriter::ResetTransferBuffer()

    {

    iTransferBufferArray->Reset();

    }

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

// CSocketWriter::RunL

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

//

void CSocketWriter::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

                {

                iObserver->BufferUnderrunL();

                }

            }

        }

    else

        {

        DEBUG_PRINT( DEBUG_STRING(

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

        iObserver->WriterErrorL( 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();

            }

        }

    }

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

// CSocketWriter::DoCancel

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

//

void CSocketWriter::DoCancel()

    {

    iTimer.Cancel();

    iSocket.CancelWrite();

    }

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

// CSocketWriter::RunError

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

//

TInt CSocketWriter::RunError( TInt aError )

    {

    iObserver->ObserverLeaved( aError );

    return KErrNone;

    }