// Copyright (c) 2008-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:
//
/**
@internalComponent
*/
#ifndef CSOCKETHANDLER_H_
#define CSOCKETHANDLER_H_
#include "es_sock.h"
#include "in_sock.h"
#include "e32base.h"
#include "cptpipconnection.h"
#include "mtpdebug.h"
#include "ptpipprotocolconstants.h"
//The maximum number of bytes buffered locally before sending over socket
// If the data chunk is larger than this, it is sent directly, if its smaller its buffered.
const TInt KBufferSize = 64;
/**
This class encapsulates the functions for sending and receving data over
the @see RSocket over TCP/IP
It has the common functionality for handling and communicating with the socket,
and for communicating with the ptpip connection class.
The command and Event handler classes derived from this class.
*/
class CPTPIPSocketHandlerBase : public CActive
{
public :
enum TSocketState
{
EIdle = 0x00000000,
EInitSendInProgress = 0x80000005,
// The receive data stream is active.
EReceivingState = 0x40000000,
EReceiveInProgress = 0x40000001,
EReceiveFastInProgress = 0x40000002,
EReceiveComplete = 0x40000003,
// The send data stream is active.
ESendingState = 0x80000000,
ESendInitialising = 0x80000001,
ESendInProgress = 0x80000002,
ESendCompleting = 0x80000003,
ESendComplete = 0x80000004,
// Send stream is active and is sending the data in packets during R to I data phase
ESendDataState = 0x60000000,
ESendDataInitialising = 0x60000001,
ESendingDataHeader = 0x60000002,
ESendingDataPacket = 0x60000003,
ESendDataPacketCompleting = 0x60000004,
ESendDataComplete = 0x60000005,
ESendDataCancelled = 0x60000006,
EStateDirection = 0xF0000000
};
// Data Sending functions
void SendDataL(const MMTPType& aData, TUint32 aTransactionId);
virtual void SendDataCompleteL(TInt aError, const MMTPType& aSource);
void CancelSendL(TInt aReason);
// Data Receiving functions
void ReceiveDataL(MMTPType& aData);
virtual void ReceiveDataCompleteL(TInt aError, MMTPType& aSink);
void CancelReceiveL(TInt aReason);
// Other helper functions
virtual ~CPTPIPSocketHandlerBase();
CPTPIPConnection& Connection();
RSocket& Socket();
void SetSocket(RSocket& aSocket);
void SetState(TSocketState aState);
void SetSocketOptions();
void SetCancel()
{
iCancelReceived = ETrue;
}
// From CActive
void DoCancel();
public:
/*Flag to inidicate whether to populate the chunk given by MTP framework,
from the last saved location or beginning if its a new chunk
* */
TBool iUseOffset ;
protected:
CPTPIPSocketHandlerBase(CPTPIPConnection& aConnection, TPriority priority );
#ifdef __FLOG_ACTIVE
virtual void ConstructL(const TDesC8& aComponentName);
#else
virtual void ConstructL();
#endif
virtual TInt ParsePTPIPHeaderL() = 0;
virtual TBool HandleInitAck() = 0;
private:
// From CActive
void RunL();
TInt RunError(TInt aError);
// other helper functions.
void ProcessSendDataL();
void ProcessFirstReceivedChunkL();
void ResumeReceiveDataStreamL();
void InitiateFirstChunkReceiveL();
void ResetSendDataStream();
void ResetReceiveDataStream();
void CompleteSelf(TInt aCompletionCode);
TInt32 DataStreamDirection() const;
void SendDataPacketL();
void SendHeaderPacketL();
void CreateAndSendDataPacketsL();
protected :
/**
This is the socket used for transferring data ,
it is controlled by the socketHandler
*/
RSocket iSocket;
/**
The active data stream chunk status.
*/
TInt iChunkStatus;
/**
The pointer to the current chunk in the send data stream.
*/
TPtrC8 iSendChunkData;
/**
The send data stream data pointer.
*/
TPtrC8 iSendData;
/**
The pointer to the current chunk in the receive data stream
*/
TPtr8 iReceiveChunkData;
/**
The amount of data expected in one ptpip packet, this is filled from the size from ptp header
*/
TUint32 iPTPPacketLength;
/**
Keeps track of whether socket is sending, receiving, idle etc.
*/
TSocketState iState;
/**
FLOGGER debug trace member variable.
*/
__FLOG_DECLARATION_MEMBER_MUTABLE;
private :
/**
The packet data buffer used to copy and append the chunk locally
if the individual chunks are too small to send as one tcp packet.
*/
RBuf8 iPacketBuffer;
/**
The maximum size of the packet buffer
*/
TUint iPacketSizeMax;
/**
The receive data stream data pointer.
*/
TPtr8 iReceiveData;
/**
A flag to tell if the receive stream is the first chunk.
*/
TBool iIsFirstChunk;
/**
The amount of data received so far, keeps incrementing with each tcp packet.
*/
TUint32 iPTPPacketLengthReceived;
/**
The receive data stream commit flag.
*/
TBool iReceiveDataCommit;
/**
The send data stream data pointer.
*/
TPtrC8 iSendHeaderData;
/**
The header for the ptp ip data packet.
*/
CPTPIPDataContainer* iPTPIPDataHeader;
/**
The flag to keep track whether cancel has been received.
*/
TBool iCancelReceived;
private : // Not owned
CPTPIPConnection& iConnection;
/**
This is the buffer used to receive data from the socket. This will be a pointer
to the PTPIP data type.
*/
MMTPType* iReceiveDataSink;
/**
This is the buffer used to send data to the socket. This will be a pointer
to the PTPIP data type.
*/
const MMTPType* iSendDataSource;
/**
The pointer to the current chunk in the receive data stream
*/
TPtr8 iCurrentChunkData;
/*Type of the current PTP/IP Packet */
TUint32 iType;
};
#endif /*CSOCKETHANDLER_H_*/