/*

* 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:  Writes to socket.

*

*/

// INCLUDE FILES

#include "socketswriter.h"

#include "timeouttimer.h"

#include "BtSerialEngine.pan"

#include "SocketObserver.h"

#include "HtiBtEngineLogging.h"

// STATIC MEMBER INITIALISATIONS

const TInt KTimeOut = 10 * 1000 * 1000; // 10 seconds time-out

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

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

CSocketsWriter* CSocketsWriter::NewL( MSocketObserver& aEngineNotifier,

                                      RSocket& aSocket )

    {

    CSocketsWriter* self = new ( ELeave ) CSocketsWriter( aEngineNotifier,

                                                          aSocket );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

CSocketsWriter::CSocketsWriter( MSocketObserver& aEngineNotifier,

                                RSocket& aSocket )

: CActive( EPriorityStandard ),

  iSocket( aSocket ),

  iObserver( aEngineNotifier )

    {

    // No implementation required

    }

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

void CSocketsWriter::ConstructL()

    {

    CActiveScheduler::Add( this );

    iTimeOut = KTimeOut;

    iTimer = CTimeOutTimer::NewL( CActive::EPriorityUserInput, *this );

    iWriteStatus = EIdle;

    }

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

CSocketsWriter::~CSocketsWriter()

    {

    CancelSending();

    delete iTimer;

    }

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

void CSocketsWriter::DoCancel()

    {

    // Cancel asychronous write request

    iSocket.CancelWrite();

    iTimer->Cancel();

    iWriteStatus = EIdle;

    }

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

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:

                LOGFMT_E( "CSocketsWriter: Bad write status: %d", iWriteStatus )

                Panic( EBTSerialEngineWriteSocketBadState );

                break;

            };

        }

    else

        {

        iWriteStatus = EIdle;

        iWriteBuffer.Zero();

        iTransferBuffer.Zero();

        iObserver.ReportError( MSocketObserver::EGeneralWriteError,

                                     iStatus.Int() );

        }

    }

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

void CSocketsWriter::TimerExpired()

    {

    Cancel();

    iWriteStatus = EIdle;

    iObserver.ReportError( MSocketObserver::ETimeOutOnWrite,

                                 KErrTimedOut );

    }

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

void CSocketsWriter::SendL(const TDesC8& aData)

    {

    if ( aData.Length() > FreeSpaceInSendBuffer() )

        User::Leave( KErrOverflow );

    iTransferBuffer.Append( aData );

    SendNextPacket();

    }

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

TInt CSocketsWriter::FreeSpaceInSendBuffer()

    {

    return iTransferBuffer.MaxSize() - iTransferBuffer.Size();

    }

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

TInt CSocketsWriter::SendBufferMaxSize()

    {

    return iTransferBuffer.MaxLength();

    }

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

void CSocketsWriter::SendNextPacket()

    {

    if ( IsActive() )

        {

        return; // already sending

        }

    if ( iTransferBuffer.Length() > 0 )

        {

        // Move data from transfer buffer to actual write buffer

        iWriteBuffer.Copy(iTransferBuffer.Left(iWriteBuffer.MaxLength()));

        iTransferBuffer.Delete(0, iWriteBuffer.MaxLength());

        iSocket.Write( iWriteBuffer, iStatus ); // Initiate actual write

        iWriteStatus = ESending;

        iTimer->After( iTimeOut );

        SetActive();

        }

    else

        {

        iWriteStatus = EIdle;

        iObserver.AllBufferedDataSent();

        }

    }

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

void CSocketsWriter::CancelSending()

    {

    Cancel();

    iWriteBuffer.Zero();

    iTransferBuffer.Zero();

    }

// End of File