#ifndef __HOST_TRANSFERS_H
#define __HOST_TRANSFERS_H

/*
* Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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:
* @file HostTransfers.h
* @internalComponent
* 
*
*/



#include <e32base.h>
#include <e32ver.h>
#include <d32usbdescriptors.h>
#include <d32usbtransfers.h>
#include <d32usbdi.h>
#include "testdebug.h"
#include "ControlTransferRequests.h"

namespace NUnitTesting_USBDI
	{

/**
This class describes an interface to a class which wants to observe transfers
*/
class MTransferObserver
	{
public: 
	/**
	Called when a transfer with the supplied transfer identity has completed
	@param aTransferId the identity of the transfer
	@param aCompletionCode the error completion code for the asynchronous transfer
	*/
	virtual void TransferCompleteL(TInt aTransferId,TInt aCompletionCode) = 0;
	};


/**
This class describes a base class for a transfer
*/
class CBaseTransfer : public CActive
	{
public:
	/**
	Destructor
	*/
	virtual ~CBaseTransfer()
		{
		}
	
	/**
	Retrieve the identity of the transfer
	@return the transfer identity
	*/
	TInt Identity() const
		{
		return iTransferIdentity;
		}
	
protected:
	/**
	Constructor 
	*/
	CBaseTransfer(RUsbPipe& aPipe,RUsbInterface& aInterface,MTransferObserver& aObserver,TInt aTransferIdentity)
	:	CActive(EPriorityStandard),
		iPipe(aPipe),
		iInterface(aInterface),
		iObserver(aObserver),
		iTransferIdentity(aTransferIdentity)
		{
		CActiveScheduler::Add(this);
		}
		
	/**
	*/
	void SelfComplete()
		{
		iStatus = KRequestPending;
		TRequestStatus* s = &iStatus;
		User::RequestComplete(s,KErrNone);
		SetActive();
		}
	
protected:
	/**
	*/
	virtual TInt RunError(TInt aError)
		{
		RDebug::Printf("<Error %d> a transfer RunL left",aError);
		return KErrNone;
		}
	
	/**
	*/
	void RunL()
		{
		TInt completionCode(iStatus.Int());
		RDebug::Printf("Transfer err=%d",completionCode);
		
		// Notify of transfer completion (successful or otherwise)
		iObserver.TransferCompleteL(iTransferIdentity,completionCode);
		}
	
	/**
	*/
	void DoCancel()
		{
		// Will cancel all transfers on this pipe
		
		Pipe().CancelAllTransfers();
		}
	
protected:
	
	/**
	Get the pipe object for the transfer
	@return a opened pipe for transfers
	*/
	RUsbPipe& Pipe()
		{
		return iPipe;
		}
	
	/**
	Get the interface for the transfer
	@return the opened interface 
	*/
	RUsbInterface& Interface()
		{
		return iInterface;
		}

	/**
	Access the observer of the transfers
	@return the transfer observer
	*/
	MTransferObserver& Observer()
		{
		return iObserver;
		}
	
private:
	/**
	The usb pipe that will be used for the transfer and where
	the buffer pool is located.
	*/
	RUsbPipe& iPipe;

	/**
	The interface that will be used for the transfer
	*/
	RUsbInterface& iInterface;
	
	/**
	The observer for the transfers
	*/
	MTransferObserver& iObserver;

	/**
	The identity of a transfer (not the type)
	*/
	TInt iTransferIdentity;
	};
	
/**
This class represents a interrupt transfer to the device
*/
class CInterruptTransfer : public CBaseTransfer
	{
public:
	/**
	C++ constructor, builds a interrupt transfer object with a transfer buffer of maximum fixed size.
	The caller must ensure that this instance can handle the transfer specified
	@param aPipe the pipe to be used for the transfer and buffer pool
	@param aTransferSize the required maximum size of the buffer to handle all transfers
	@param aObserver the observer of the transfer
	@param aTransferId a unique identity of the transfer
	*/
	CInterruptTransfer(RUsbPipe& aPipe,RUsbInterface& aInterface,TInt aMaxTransferSize,MTransferObserver& aObserver,TInt aTransferId);

	/**
	Destructor
	*/
	virtual ~CInterruptTransfer();
	
	/**
	Poll for interrupt data queued by the device and transfer to host 
	@param aSize the size of the data from requested from the client
	@return KErrNone if successful or system-wide error code
	*/
	TInt TransferInL(TInt aSize);
	
	/**
	Register the transfer descriptor
	@return KErrNone if successful or system-wide error code
	*/
	TInt RegisterTransferDescriptor();
	
	/**
	On successful completion of an interrupt 'in' transfer, obtain the polled data
	@return the interrupt data from the device
	*/
	TPtrC8 DataPolled();

private:
	/**
	The transfer descriptor for interrupt transfers
	*/
	RUsbIntrTransferDescriptor iTransferDescriptor;
	};

/**
This class represents a isochronous transfer to a device
*/
class CIsochTransfer : public CBaseTransfer
	{
public:
	/**
	C++ constructor, builds a isochronous transfer object with a transfer buffer of maximum fixed size.
	The caller must ensure that this instance can handle the transfer specified
	@param aPipe the pipe to be used for the transfer and buffer pool
	@param aMaxPacketSize the maximum packet size to send
	@param aMaxNumPackets the maximum number of packets to be transfered on this pipe
	@param aObserver the observer of the transfer
	@param aTransferId a unique identity of the transfer
	*/
	CIsochTransfer(RUsbPipe& aPipe,RUsbInterface& aInterface,TUint16 aMaxPacketSize,
					TInt aMaxNumPackets,MTransferObserver& aObserver,TInt aTransferId);

	/**
	Destructor
	*/
	virtual ~CIsochTransfer();
	
	TInt RegisterTransferDescriptor();

	/**
	Transfer the data to the device
	@param aIsochData the 8bit Isochronous data to transfer
	@return KErrNone if successful, or system wide error code
	*/	
	TInt TransferOut();
	
	/**
	Prepare the transfer before its sending
	@param aIsochData the 8bit Isochronous data to transfer
	@return KErrNone if successful, or system wide error code
	*/	
	TInt PrepareTransfer(const TDesC8& aIsochData);
	
	/**
	Start the IN transfer
	@param aPacketsExpected nb of expected packets
	@return KErrNone if successful, or system wide error code
	*/
	TInt TransferInL(TInt aPacketsExpected);
		
	/**
	Store the polled data into internal buffer
	@param[int] aPacketsToBeRead nb of packets to be read
	@param[out] aDataPolled data being transfered
	@return ETrue if successful, EFalse otherwise
	*/
	TBool DataPolled(TUint aPacketsToBeRead, RBuf8& aDataPolled);
				
private:
	/**
	The transfer descriptor for isochronous transfers
	*/
	RUsbIsocTransferDescriptor iTransferDescriptor;
	
	/**
	The maximum packet size for the respective isochronous endpoint
	*/
	TUint16 iMaxPacketSize;	
	
	};


/**
This class represents a bulk transfer to a device
*/
class CBulkTransfer : public CBaseTransfer
	{
public:
	/**
	C++ constructor
	*/
	CBulkTransfer(RUsbPipe& aPipe,RUsbInterface& aUsbInterface,TInt aMaxTransferSize,
		MTransferObserver& aObserver,TInt aTransferId);

	/**
	*/
	virtual ~CBulkTransfer();
	
	/**
	*/
	void TransferOut(const TDesC8& aBulkData, TBool aUseZLPIfRequired = ETrue);
		
	/**
	*/
	void TransferOut(const TDesC8& aBulkDataPattern, TUint aNumBytes, TBool aUseZLPIfRequired = ETrue);
				
	/**
	*/
	void TransferOut(const TDesC8& aBulkDataPattern, TUint aStartPoint, TUint aNumBytes, TBool aUseZLPIfRequired);
	
	/**
	*/
	void TransferIn(TInt aExpectedDataSize);
	
	/**
	*/
	RUsbPipe&  Pipe(){return CBaseTransfer::Pipe();};
	
	RUsbBulkTransferDescriptor& TransferDescriptor(){return iTransferDescriptor;};

	/**
	*/
	TPtrC8 DataPolled();
	
private:
	/**
	The transfer descriptor for bulk transfers
	*/
	RUsbBulkTransferDescriptor iTransferDescriptor;
	};

	
	}

#endif