// Copyright (c) 2003-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:

//

#include <x509cert.h>

#include "chttprequestbatcher.h"

const TInt KBatchingTimeoutMicroSeconds = 100000;

CHttpRequestBatcher* CHttpRequestBatcher::NewL(MOutputStream& aOutputStream, const TInt aBufferSize)

	{

	CHttpRequestBatcher* self = new (ELeave) CHttpRequestBatcher(aOutputStream, aBufferSize);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CHttpRequestBatcher::CHttpRequestBatcher(MOutputStream& aOutputStream, const TInt aBufferSize)

: CActive(CActive::EPriorityStandard + 1), iDataToSend(TPtr8(NULL, 0)), iExcessData(TPtrC8(NULL, 0)), iMaxBufferSize(aBufferSize)

	{

	__FLOG_OPEN("http", "httpclienthandler.txt");

	CActiveScheduler::Add(this);

	iOutputStream = &aOutputStream;

	iOutputStream->Bind(*this);

	iFuncPtr = &CHttpRequestBatcher::SendRequestImmediatelyL;

	}

void CHttpRequestBatcher::ConstructL()

	{

	iBuffer = HBufC8::NewL(iMaxBufferSize);

	iDataToSend.Set(iBuffer->Des());

	iTimer.CreateLocal();

	iTimerCompleted = EFalse;

	}

CHttpRequestBatcher::~CHttpRequestBatcher()

	{

	Cancel();

	delete iBuffer;

	iTimer.Close();

	__FLOG_CLOSE;

	}

void CHttpRequestBatcher::SendRequestImmediatelyL(const TDesC8& aBuffer)

	{

#if defined (_DEBUG) && defined (_LOGGING)

		__FLOG_0(_T8("!! Send the first request i.e. not batching"));

#endif

	iOutputStream->SendDataReqL(aBuffer);

	}

void CHttpRequestBatcher::SendRequestsBatchedL(const TDesC8& aBuffer)

	{

	StartTimer();

	BatchRequestsL(aBuffer);

	}

void CHttpRequestBatcher::BatchRequestsL(const TDesC8& aBuffer)

	{

	if (iTimerCompleted)

		iExcessData.Set(aBuffer);

	else if ((aBuffer.Length() + iDataToSend.Length()) < iMaxBufferSize)

		{

		iDataToSend.Append(aBuffer);

		// Buffer is not yet full, so request observer to send more data

		iObserver->SendDataCnfL();

		}

	else

		{

		TInt pos = iMaxBufferSize - iDataToSend.Length();

		// Fill up the buffer

		iDataToSend.Append(aBuffer.Left(pos));

		// Cancel the timer

		Cancel();

#if defined (_DEBUG) && defined (_LOGGING)

		__FLOG_0(_T8("!! Buffer has been filled - cancel timer and send batched requests now"));

#endif

		// Send the request with a filled-up buffer

		iOutputStream->SendDataReqL(iDataToSend);

		// Save the excess data from this request

		iExcessData.Set(aBuffer.Mid(pos));

		}

	}

void CHttpRequestBatcher::StartTimer()

	{

	if(!IsActive())

		{

#if defined (_DEBUG) && defined (_LOGGING)

		__FLOG_0(_T8("!! Start the batching timer"));

#endif

		SetActive();

		iTimer.After(iStatus, KBatchingTimeoutMicroSeconds);

		}

	}

/*

 *	Methods from MOutputStream

 */

void CHttpRequestBatcher::Bind(MOutputStreamObserver& aObserver)

	{

	// Bind to the output stream observer

	iObserver = &aObserver;

	}

void CHttpRequestBatcher::SendDataReqL(const TDesC8& aBuffer)

	{

	// Call the appropriate function depending on what the function pointer has been set to.

	// For the first request, the pointer will be set to the SendRequestImmediately() function.

	// For subsequent requests, i.e. when batching, the pointer will be set to the

	// SendRequestsBatched() function.

	(*this.*iFuncPtr)(aBuffer);

	}

void CHttpRequestBatcher::ShutdownReq()

	{

	iOutputStream->ShutdownReq();

	}

void CHttpRequestBatcher::SecureClientReq(const TDesC8& aHostName)

	{

	iOutputStream->SecureClientReq(aHostName);

	}

void CHttpRequestBatcher::Close()

	{

	iOutputStream->Close();

	}

const CX509Certificate* CHttpRequestBatcher::ServerCert()

 	{

	return iOutputStream->ServerCert();

 	}

TInt CHttpRequestBatcher::CipherSuite(TDes8& aCipherSuite)

	{

	return iOutputStream->CipherSuite(aCipherSuite);

	}

void CHttpRequestBatcher::MOutputStream_Reserved()

	{

	User::Invariant();

	}

void CHttpRequestBatcher::Reset ()

	{

	iOutputStream->Reset ();

	}

/*

 *	Methods from MOutputStreamObserver

 */

void CHttpRequestBatcher::SendDataCnfL()

	{

	// If this is the first request send a confirmation to the observer that the data

	// has been sent and then set the function pointer to the SendRequestBatched() method.

	if (iFuncPtr == &CHttpRequestBatcher::SendRequestImmediatelyL)

		{

#if defined (_DEBUG) && defined (_LOGGING)

		__FLOG_0(_T8("!! Received conf back for first request i.e. not batching"));

#endif

		iObserver->SendDataCnfL();

		iFuncPtr = &CHttpRequestBatcher::SendRequestsBatchedL;

		}

	// If the timer did not complete then by implication a filled-up buffer was sent in the request.

	else if (!iTimerCompleted)

		{

#if defined (_DEBUG) && defined (_LOGGING)

		__FLOG_0(_T8("!! Received conf back for batched requests"));

#endif

		iDataToSend.Zero();

		HandleExcessDataL();

		}

	else	// Timer did complete

		{

		iDataToSend.Zero();

		// Check for any requests that may have been sent by the observer after the RunL fired

		// i.e. the timer completed, but before we received a conf from the output stream.

		if (iExcessData.Length() > 0)

			HandleExcessDataL();

		// Reset the flag

		iTimerCompleted = EFalse;

		}

	}

void CHttpRequestBatcher::HandleExcessDataL()

	{

	if (iExcessData.Length() > iMaxBufferSize)

		{

#if defined (_DEBUG) && defined (_LOGGING)

		__FLOG_0(_T8("!! Handling excess data - have enough data to fill up another buffer so send it"));

#endif

		// It's possible that the excess data is larger than the maximum allowable size of the buffer in

		// which case this excess data is used to fill up another buffer and a request made.

		iDataToSend.Append(iExcessData.Left(iMaxBufferSize));

		iOutputStream->SendDataReqL(iDataToSend);

		iExcessData.Set(iExcessData.Mid(iMaxBufferSize));

		}

	else

		{

		// Not enough data to fill up a buffer therefore store the data

		iDataToSend.Append(iExcessData);

		iExcessData.Set(KNullDesC8());

		iObserver->SendDataCnfL();

#if defined (_DEBUG) && defined (_LOGGING)

		__FLOG_0(_T8("!! Handling excess data - but not enough data to fill up buffer"));

#endif

		// start the timer again

		StartTimer();			

		}

	}

void CHttpRequestBatcher::SecureClientCnf()

	{

	iObserver->SecureClientCnf();

	}

void CHttpRequestBatcher::OutputStreamCloseInd(TInt aError)

	{

	Cancel();

	iObserver->OutputStreamCloseInd(aError);

	}

TBool CHttpRequestBatcher::SecureRetry()

     {

         return iObserver->SecureRetry();

     }

void CHttpRequestBatcher::MOutputStreamObserver_Reserved()

	{

	User::Invariant();

	}

/*

 * Methods from CActive

 */

void CHttpRequestBatcher::RunL()

	{

	if (iDataToSend.Length() > 0)

		{

#if defined (_DEBUG) && defined (_LOGGING)

		__FLOG_0(_T8("!! Timer has completed before buffer has been filled - send request now"));

#endif

		// Timer has completed before the buffer has been filled, therefore send the request now.

		iOutputStream->SendDataReqL(iDataToSend);

		}

	iTimerCompleted = ETrue;

	}

void CHttpRequestBatcher::DoCancel()

	{

	iTimer.Cancel();

	}

TInt CHttpRequestBatcher::RunError(TInt /*aError*/)

	{

	// The RunL() cannot leave - nothing to do here.

	return KErrNone;

	}

void CHttpRequestBatcher::OnSendTimeOut()

	{

	iObserver->OnSendTimeOut();

	}

TInt CHttpRequestBatcher::SendTimeOutVal()

	{

	return iObserver->SendTimeOutVal();

	}

void CHttpRequestBatcher::SetTCPCorking(TBool  aValue )

    {

    if (iOutputStream)

            {

            iOutputStream->SetTCPCorking(aValue);

            }

    }