// 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:

//

#ifndef __CTESTSOCKETREADER_H__

#define __CTESTSOCKETREADER_H__

#include <e32base.h>

#include <minputstreamobserver.h>

class MInputStream;

class MTestReaderObserver;

/**	@class		CTestSocketReader

	The CTestSocketReader class encapsulates the input stream of a connected 

	socket. The state machine is initially in the Idle state. When data is 

	expected to be received, the observer passes the expected data using the 

	ExpectData() API. The descriptor buffer passed in must remain valid until 

	the test socket reader termibates.

	The ExpectData() API binds the test socket reader to the input stream. The

	state changes to PendingReceivedData and the test socket reader waits for 

	the input strean to notify it that data has been received.

	The input stream uses the MInputStreamObserver::ReceivedDataInd() API to 

	notify the test socket reader that data has been received. The test socket

	reader verifies that the received data is part of the expected data. If so

	that part is removed from the expected data. The test socket reader moves 

	to the ReceiveAck state and self-completes. If the received data was not 

	part of the expected data or if there was extra data in the received buffer

	then a panic occurs.

	In the ReceiveAck state the test socket reader notifies the input stream 

	that it has finished with the received buffer. If all the expected data has

	been received then the test socket reader moves to the Idle state. If more 

	data is expected the test socket reader moves to the PendingReceivedData.

	The test socket reader observer can request that the input stream be closed

	using the CloseReader() API. The test socket reader must be in the Idle 

	state or else there will be a panic. The state changes to Closing and the 

	test socket reader self-completes.

	In the Closing state the test socket reader requests that the input stream

	close asynchronously. The test socket reader moves to the PendingClosed 

	state and waits to be notified that the input stream is closed.

	Once the stream has closed, the test socket reader is notified via the 

	MInputStreamObserver::InputStreamCloseInd() API. The test socket reader 

	moves to the Closed state.

	If the input stream is closed, either because the corresponding output 

	stream has been closed, the remote host has closed the socket or there has

	been a socket error, the test socket reader is notified via the 

	MInputStreamObserver::InputStreamCloseInd() API.

	@componentInternal		

*/

class CTestSocketReader : public CActive,

						  public MInputStreamObserver

	{

public:	// methods

	static CTestSocketReader* NewL(MTestReaderObserver& aObserver, MInputStream& aInputStream, TBool aSecure);

	virtual ~CTestSocketReader();

	void ExpectData(const TDesC8& aData);

	void CloseReader();

private:	// methods from MInputStreamObserver

	virtual void ReceivedDataIndL(const TDesC8& aBuffer);

	virtual void InputStreamCloseInd(TInt aError);

	virtual void SecureServerCnf();

	virtual void MInputStreamObserver_Reserved();

	MHttpResponse* CurrentResponse();

    virtual void OnReceiveTimeOut(); 

private:	// methods from CActive

	virtual void RunL();

	virtual void DoCancel();

	virtual TInt RunError(TInt aError);

private:	// methods

	CTestSocketReader(MTestReaderObserver& aObserver, MInputStream& aInputStream, TBool aSecure);

	TInt UpdateData(const TDesC8& aReceivedData, TPtrC8& aExcessData);

	TInt CheckResponseStatusL(const TDesC8& aReceivedData);

	void CompleteSelf();

private:	// enums

/**	@enum		TReaderState

	The test socket reader state machine.

	@componentInternal		

*/

	enum TReaderState

		{

		/**	The test socket reader is idle.

		*/

		EIdle					=0,

		/**	The test socket reader is expecting to receive more data.

		*/

		EPendingReceivedData,

		/**	The test socket reader needs to acknowledge the received data packet.

		*/

		EReceiveAck,

		/** The test socket reader observer has requested that the test socket reader 

			close the input stream.

		*/

		EClosing,

		/**	The test socket reader is waiting for the input stream to notify it that

			it has closed.

		*/

		EPendingClosed,

		/**	The test socket reader is closed - no more data can be received.

		*/

		EClosed

		};

private:	// attributes

	MTestReaderObserver&	iObserver;

	MInputStream*			iInputStream;

	TReaderState			iState;

	TBool					iBoundToInputStream;

	TPtrC8					iExpectedData;

	TPtrC8					iReceivedBuffer;

	TBool					iSecure;

	TBool					iSecureTestPassed;

	};

#endif	// __CTESTSOCKETREADER_H__