/* Copyright (c) 2004, Nokia. All rights reserved */


// INCLUDE FILES
#include "SocketsWriter.h"
#include "TimeOutTimer.h"
#include "Sockets.pan"
#include "EngineNotifier.h"

// STATIC MEMBER INITIALISATIONS
const TInt CSocketsWriter::KTimeOut = 30000000; // 30 seconds time-out

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

// -----------------------------------------------------------------------------
// CSocketsWriter::NewL()
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CSocketsWriter* CSocketsWriter::NewL( MEngineNotifier& aEngineNotifier,
                                      RSocket& aSocket )
    {
    CSocketsWriter* self = CSocketsWriter::NewLC( aEngineNotifier,
                                                  aSocket );
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CSocketsWriter::NewLC()
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CSocketsWriter* CSocketsWriter::NewLC( MEngineNotifier& aEngineNotifier,
                                       RSocket& aSocket )
    {
    CSocketsWriter* self = new ( ELeave ) CSocketsWriter( aEngineNotifier,
                                                          aSocket );
    CleanupStack::PushL( self );
    self->ConstructL();
    return self;
    }

// -----------------------------------------------------------------------------
// CSocketsWriter::CSocketsWriter()
// C++ default constructor can NOT contain any code, that might leave.
// -----------------------------------------------------------------------------
//
CSocketsWriter::CSocketsWriter( MEngineNotifier& aEngineNotifier,
                                RSocket& aSocket )
: CActive( EPriorityStandard ),
  iSocket( aSocket ),
  iEngineNotifier( aEngineNotifier )
    {
    // No implementation required
    }

// -----------------------------------------------------------------------------
// CSocketsWriter::ConstructL()
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CSocketsWriter::ConstructL()
    {
    CActiveScheduler::Add( this );

    iTimeOut = KTimeOut;
    iTimer = CTimeOutTimer::NewL( CActive::EPriorityUserInput, *this );
    iWriteStatus = EWaiting;
    }

// -----------------------------------------------------------------------------
// CSocketsWriter::~CSocketsWriter()
// Destructor.
// -----------------------------------------------------------------------------
//
CSocketsWriter::~CSocketsWriter()
    {
    Cancel();
    delete iTimer;
    iTimer = NULL;
    }

// -----------------------------------------------------------------------------
// CSocketsWriter::DoCancel()
// Cancels any outstanding operation.
// -----------------------------------------------------------------------------
//
void CSocketsWriter::DoCancel()
    {
    // Cancel asychronous write request
    iSocket.CancelWrite();
    iTimer->Cancel();
    iWriteStatus = EWaiting;
    }

// -----------------------------------------------------------------------------
// CSocketsWriter::RunL()
// Called when operation completes.
// -----------------------------------------------------------------------------
//
void CSocketsWriter::RunL()
    {
    iTimer->Cancel();

    // Active object request complete handler
    if ( iStatus == KErrNone )
        {
        switch( iWriteStatus )
            {
            // Character has been written to socket
            case ESending:
                SendNextPacket();
                break;
            default:
                User::Panic( KPanicSocketsEngineWrite, ESocketsBadStatus );
                break;
            };
        }
    else
        {
        // Error: pass it up to user interface
        iEngineNotifier.ReportError( MEngineNotifier::EGeneralWriteError,
                                     iStatus.Int() );
        iWriteStatus = EWaiting;
        }
    }

// -----------------------------------------------------------------------------
// CSocketsWriter::TimerExpired()
// Handles a timeout event.
// -----------------------------------------------------------------------------
//
void CSocketsWriter::TimerExpired()
    {
    Cancel();
    iWriteStatus = EWaiting;
    iEngineNotifier.ReportError( MEngineNotifier::ETimeOutOnWrite, 
                                 KErrTimedOut );
    }

// -----------------------------------------------------------------------------
// CSocketsWriter::IssueWriteL()
// Writes the data to the socket ( buffered ).
// -----------------------------------------------------------------------------
//
void CSocketsWriter::IssueWriteL( const TDesC8& aData )
    {
    if ( ( iWriteStatus != EWaiting ) && ( iWriteStatus != ESending ) )
        {
        User::Leave( KErrNotReady );
        }

    if ( ( aData.Length() + iTransferBuffer.Length() ) >
         iTransferBuffer.MaxLength() )
        {
        // Not enough space in buffer
        User::Leave( KErrOverflow );
        }

    // Add new data to buffer
    iTransferBuffer.Append( aData );

    if ( !IsActive() )
        {
        SendNextPacket();
        }
    }

// -----------------------------------------------------------------------------
// CSocketsWriter::SendNextPacket()
// Handles a 'write buffer empty' situation.
// -----------------------------------------------------------------------------
//
void CSocketsWriter::SendNextPacket()
    {
    if ( iTransferBuffer.Length() > 0 )
        {
        // Move data from transfer buffer to actual write buffer
        iWriteBuffer = iTransferBuffer;
        iTransferBuffer.Zero();
        iSocket.Write( iWriteBuffer, iStatus ); // Initiate actual write

        iWriteStatus = ESending;
        // Request timeout
        iTimer->After( iTimeOut );
        SetActive();
        }
    else
        {
        iWriteStatus = EWaiting;
        }
    }

// End of File