// 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_*/