applayerprotocols/httptransportfw/Test/t_httptransporthandler/ctestsocketwriter.h
// 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 __CTESTSOCKETWRITER_H__
#define __CTESTSOCKETWRITER_H__
#include <e32base.h>
#include <moutputstreamobserver.h>
const TInt KDefaultBuffer = 100;
class MOutputStream;
class MTestWriterObserver;
/** @class CTestSocketWriter
The CTestSocketWriter class encapsulates the output stream of a connected
socket. The state machine is initially in the Idle state. When the observer
requests that data should be sent (using the SendData() API), the test
socket writer binds to the output stream. The state changes the SendData
state and the object self-completes. Note the descriptor buffer containing
the data to be sent must remain valid until the socket writer terminates.
When in the SendData the test socket writer does a send request. The data to
send is placed in the send packet and the sedn data is updated, removing the
data sent in the current buffer.
The test socket writer moves into the PendingAck state and waits for the
output stream to notify the it that the data has been sent. This is done via
the MOutputStreamObserver::SendDataCnf() API.
When the test socket writer is notified that the data has been sent it checks
to see if more data needs to be sent. If there is then the test socket writer
moves to the SendData state and self-completes. If there is no more data to
send the test socket writer moves to the Idle state.
The test socket writer observer can request that the output stream be closed
using the CloseWriter() API. The test socket writer must be in the Idle state
or else there will be a panic. The state changes to Closing and the test
socket writer self-completes.
In the Closing state the test socket writer requests that the output stream
close asynchronously. The test socket writer moves to the PendingClosed
state and waits to be notified that the output stream is closed.
Once the stream has closed, the test socket writer is notified via the
MOutputStreamObserver::OutputStreamCloseInd() API. The test socket writer
moves to the Closed state.
If the output stream is closed, either because the corresponding input stream
has been closed, the remote host has closed the socket or there has been a
socket error, the socket writer is notified via the
MOutputStreamObserver::OutputStreamCloseInd() API.
@componentInternal
*/
class CTestSocketWriter : public CActive,
public MOutputStreamObserver
{
public: // methods
static CTestSocketWriter* NewL(MTestWriterObserver& aObserver, MOutputStream& aOutputStream);
virtual ~CTestSocketWriter();
void SendData(const TDesC8& aData);
void SetSecure(TBool aSecure);
void CloseWriter();
private: // methods from MOutputStreamObserver
virtual void SendDataCnfL();
virtual void OutputStreamCloseInd(TInt aError);
virtual void SecureClientCnf();
virtual void MOutputStreamObserver_Reserved();
virtual void OnSendTimeOut();
virtual TInt SendTimeOutVal();
private: // methods from CActive
virtual void RunL();
virtual void DoCancel();
virtual TInt RunError(TInt aError);
private: // methods
CTestSocketWriter(MTestWriterObserver& aObserver, MOutputStream& aOutputStream);
void CompleteSelf();
private: // enums
/** @enum TWriterState
The state machine for the socket writer.
@componentInternal
*/
enum TWriterState
{
/** The socket writer is in idle.
*/
EIdle =0,
/** The socket writer needs to send the next data packet.
*/
ESendData,
/** The socket writer is waiting for the output stream to notify it that
the data packet has been sent.
*/
EPendingAck,
/** The socket writer observer has requested that the socket writer close
the output stream.
*/
EClosing,
/** The socket writer is waiting for the output stream to notify it that
it has closed.
*/
EPendingClosed,
/** The socket writer is closed - no more data can be sent.
*/
EClosed,
ESecureHandshake
};
private: // attributes
MTestWriterObserver& iObserver;
MOutputStream* iOutputStream;
TWriterState iState;
TBool iBoundToOutputStream;
TPtrC8 iSendData;
TBuf8<KDefaultBuffer> iSendBuffer;
TBool iSecure;
};
#endif // __CTESTSOCKETWRITER_H__