/*

* Copyright (c) 2008 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:  This is the implementation of application class

 *

*/

#include "sockets.pan"

#include "socketwriter.h"

#include "socketobserver.h"

#include "timeouttimer.h"

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

// Initial size of the buffers for data to write

const TInt KWriteBufferInitialSize = 20;

// 5 seconds socket write time-out

const TInt CSocketWriter::KTimeOut = 5000000;

CSocketWriter* CSocketWriter::NewL(TUint aSocketID,

        MSocketObserver& aObserver)

    {

    CSocketWriter* self = CSocketWriter::NewLC(aSocketID, aObserver);

    CleanupStack::Pop(self);

    return self;

    }

CSocketWriter* CSocketWriter::NewLC(TUint aSocketID,

        MSocketObserver& aObserver)

    {

    CSocketWriter* self = new (ELeave) CSocketWriter(aSocketID, aObserver);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

CSocketWriter::CSocketWriter(TUint aSocketID, MSocketObserver& aObserver) :

    CActive(EPriorityStandard), iSocketID(aSocketID), iObserver(aObserver)

    {

    }

CSocketWriter::~CSocketWriter()

    {

    Cancel();

    delete iTimer;

    delete iWriteBuffer[0];

    delete iWriteBuffer[1];

    }

void CSocketWriter::DoCancel()

    {

    // Cancel asynchronous write request

    iSocket->CancelWrite();

    iTimer->Cancel();

    // Clear the buffers

    *iWriteBuffer[0] = KNullDesC8;

    *iWriteBuffer[1] = KNullDesC8;

    }

void CSocketWriter::ConstructL()

    {

    CActiveScheduler::Add(this);

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

    iWriteBuffer[0] = HBufC8::NewL(KWriteBufferInitialSize);

    iWriteBuffer[1] = HBufC8::NewL(KWriteBufferInitialSize);

    iCurrentBuffer = 0;

    }

void CSocketWriter::TimerExpired()

    {

    Cancel();

    // Clear the buffers

    *iWriteBuffer[0] = KNullDesC8;

    *iWriteBuffer[1] = KNullDesC8;

    iObserver.HandleSocketError(iSocketID, EFalse, KErrTimedOut);

    }

void CSocketWriter::RunL()

    {

    iTimer->Cancel();

    // Remember the current status

    TInt status = iStatus.Int();

    // Clear the buffer that has been written

    *iWriteBuffer[iCurrentBuffer] = KNullDesC8;

    // If the other buffer has data, write it now

    if (iWriteBuffer[1 - iCurrentBuffer]->Length() > 0)

        {

        iCurrentBuffer = 1 - iCurrentBuffer;

        DoWrite();

        }

    // Handle status of completed write

    if (KErrNone == status)

        {

        iObserver.HandleWriteComplete(iSocketID);

        }

    else

        {

        // Error: pass it up to user interface

        iObserver.HandleSocketError(iSocketID, EFalse, status);

        }

    }

void CSocketWriter::Initialise(RSocket* aSocket)

    {

    __ASSERT_ALWAYS(!IsActive(),

            User::Panic(KPanicSocketsEngineWrite, ESocketsBadState));

    iSocket = aSocket;

    }

void CSocketWriter::IssueWriteL(const TDesC8& aData)

    {

    if (IsActive())

        {

        // Put the data in the other buffer

        StoreDataL(aData, 1 - iCurrentBuffer);

        }

    else

        {

        // Put the data in the current buffer and write immediately

        StoreDataL(aData, iCurrentBuffer);

        DoWrite();

        }

    }

void CSocketWriter::DoWrite()

    {

    // If we aren't in the correct state for a write, panic.

    __ASSERT_ALWAYS(!IsActive(),

            User::Panic(KPanicSocketsEngineWrite, ESocketsBadState));

    // Initiate actual write

    iSocket->Write(*iWriteBuffer[iCurrentBuffer], iStatus);

    // Request timeout

    if (!iTimer->IsActive())

        iTimer->After(KTimeOut);

    SetActive();

    }

void CSocketWriter::StoreDataL(const TDesC8& aData, TInt aBuffer)

    {

    __ASSERT_ALWAYS(iWriteBuffer[aBuffer]->Length() == 0,

            User::Panic(KPanicSocketsEngineWrite, ESocketsBadState));

    // Reallocate the buffer if it's too small

    if (aData.Length() > iWriteBuffer[aBuffer]->Des().MaxLength())

        {

        // Make sure we have a new buffer before deleting the old one

        HBufC8* newBuffer = HBufC8::NewL(aData.Length());

        delete iWriteBuffer[aBuffer];

        iWriteBuffer[aBuffer] = newBuffer;

        }

    *iWriteBuffer[aBuffer] = aData;

    }