// Copyright (c) 2002-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 "ctestsocketwriter.h"

#include <moutputstream.h>

#include "mtestwriterobserver.h"

#include "thttptrhndtestpanic.h"

GLREF_D TBool gInvalidSecureHost;

GLREF_D TBool gWriterShutdown;

GLREF_D TBool gReqCertificate;

CTestSocketWriter* CTestSocketWriter::NewL(MTestWriterObserver& aObserver, MOutputStream& aOutputStream)

/**	

	Factory constructor.

	@componentInternal		

	@param		aObserver		The socket writer observer.

	@param		aOutputStream	The output stream.

	@return		A pointer to a fully created object.

*/

	{

	return new (ELeave) CTestSocketWriter(aObserver, aOutputStream);

	}

CTestSocketWriter::~CTestSocketWriter()

/**	

	Destructor.

	@componentInternal		

*/

	{

	Cancel();

	// Shutdown the output stream

	if( iOutputStream && iBoundToOutputStream )

		iOutputStream->Close();

	}

CTestSocketWriter::CTestSocketWriter(MTestWriterObserver& aObserver, MOutputStream& aOutputStream)

: CActive(CActive::EPriorityStandard), iObserver(aObserver), iOutputStream(&aOutputStream)

/**	

	Constructor.

	@componentInternal 

	@param		aObserver		The socket writer observer.

	@param		aOutputStream	The output stream.

*/

	{

	CActiveScheduler::Add(this);

	}

void CTestSocketWriter::SendData(const TDesC8& aData)

/**	

	Request to send data to the output stream. The data supplied is sent to the

	output data stream. The supplied descriptor buffer should remain valid until

	the send terminates. The data is sent in packets.

	@componentInternal		

	@param		aData	The data to be sent.

*/

	{

	__ASSERT_DEBUG( iState == EIdle, THttpTrHndTestPanic::Panic(THttpTrHndTestPanic::EBadSocketWriterState) );

	// Observer wants to send data - store the data.

	iSendData.Set(aData);

	// Bind to the output stream

	iOutputStream->Bind(*this);

	iBoundToOutputStream = ETrue;

	if(iSecure)

		iState = ESecureHandshake;

	else

		iState = ESendData;

	// Move into the SendData state and self-complete

	CompleteSelf();

	}

void CTestSocketWriter::CloseWriter()

/**	

	Closes the socket writer asynchronously.

	@componentInternal		

*/

	{

	__ASSERT_DEBUG( iState == EIdle, THttpTrHndTestPanic::Panic(THttpTrHndTestPanic::EBadSocketWriterState) );

	// Move into the Closing state and self-complete

	iState = EClosing;

	CompleteSelf();

	}

void CTestSocketWriter::CompleteSelf()

/**	

	Self-completes function. Ensures that the active scheduler calls the RunL()

	at the possible moment.

	@componentInternal		

*/

	{

	TRequestStatus* pStat = &iStatus;

	User::RequestComplete(pStat, KErrNone);

	SetActive();

	}

/*

 *	Methods from MOutputStreamObserver

 */

void CTestSocketWriter::SendDataCnfL()

/**

	@see		MOutputStreamObserver

	@componentInternal

*/

	{

	__ASSERT_DEBUG( iState == EPendingAck, THttpTrHndTestPanic::Panic(THttpTrHndTestPanic::EBadSocketWriterState) );

	// Reset the send buffer

	iSendBuffer.Zero();

	// Is there more data to send?

	if( iSendData.Length() == 0 )

		{

		// Nope - inform the observer that all the data has sent

		iObserver.DataSent();

		// Move to the Idle state

		iState = EIdle;

		}

	else

		{

		// Got more data to send - move to the SendData state and go active

		iState = ESendData;

		CompleteSelf();

		}

	}

void CTestSocketWriter::OutputStreamCloseInd(TInt aError)

/**

	@see		MOutputStreamObserver

	@componentInternal

*/

	{

	// The output stream is no longer valid.

	iOutputStream = NULL;

	// Move into the Closed state

	iState = EClosed;

	// The output stream is closed - inform observer.

	iObserver.WriterClosed(aError);

	}

void CTestSocketWriter::MOutputStreamObserver_Reserved()

/**

	@see		MOutputStreamObserver

	@componentInternal

*/

	{

	User::Invariant();

	}

/*

 *	Methods from CActive

 */

void CTestSocketWriter::RunL()

/**

	Asynchronous request servicing.

	@componentInternal		

*/

	{

	switch( iState )

		{

	case ESecureHandshake:

		{

		if (!gWriterShutdown && !gInvalidSecureHost)

			{

			iOutputStream->SecureClientReq(_L8("lon-cn-lxwaptest2.closedtest.intra"));	

			}		

		else if(gWriterShutdown && gInvalidSecureHost)

			{

			iOutputStream->SecureClientReq(_L8("lon-cn-lxwap.closedtest.intra"));

			iOutputStream->ShutdownReq();

			}		

		else if(!gWriterShutdown && gInvalidSecureHost)

			{

			iOutputStream->SecureClientReq(_L8("google.com"));

			}

		} break;

	case ESendData:

		{

		// Need to get the next buffer's worth of data.

		TInt dataLength = iSendBuffer.MaxLength();

		// Adjust length is there is less data to send than a buffer's worth

		TInt sendLength = iSendData.Length();

		if( sendLength < dataLength )

			{

			dataLength = sendLength;

			}

		// Copy the data into the buffer

		iSendBuffer.Copy(iSendData.Left(dataLength));

		// Update the send data...

		iSendData.Set(iSendData.Mid(dataLength));

		// Send the data to the output stream

		iOutputStream->SendDataReqL(iSendBuffer);

		// Move to the PendingAck state

		iState = EPendingAck;

		if (gReqCertificate)

			{	

			iOutputStream->ServerCert();

			}

		} break;

	case EClosing:

		{

		// Request close on the output stream

		iOutputStream->ShutdownReq();

		// Move to the PendingClosed state

		iState = EPendingClosed;

		} break;

	default:

		break;

		}

	}

void CTestSocketWriter::DoCancel()

/**	

	Cancel the asynchronous request

*/

	{

	// Nothing to do...

	}

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

/**	

	Handle asynchronous request servicing error. The RunL() has left and the 

	error is handled here.

	@componentInternal		

	@param		aError	The error code.

	@return		A value of KErrNone if the error has been handled, or any other

				value if it has not been.

*/

	{

	return KErrNone;

	}

void CTestSocketWriter::SecureClientCnf()

	{

	iState = ESendData;

	CompleteSelf();

	}

void CTestSocketWriter::SetSecure(TBool aSecure)

	{

	iSecure = aSecure;

	}

void CTestSocketWriter::OnSendTimeOut()

	{

	}

TInt CTestSocketWriter::SendTimeOutVal()

	{

	return 0;

	}