// 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 endpointwriter.cpp

// @internalComponent

//

#include <e32base.h>

#include <e32base_private.h>

#include <d32usbc.h>

#include "endpointwriter.h"

#include "testdebug.h"

namespace NUnitTesting_USBDI

	{

const TUint KMaxTransferBuffer = 0x1000;

CEndpointWriter::CEndpointWriter(RDevUsbcClient& aClientDriver,TEndpointNumber aEndpoint)

:	CActive(EPriorityStandard),

	iClientDriver(aClientDriver),

	iEndpoint(aEndpoint),

	iBufPtr(NULL,0)

	{

	CActiveScheduler::Add(this);

	}

CEndpointWriter::~CEndpointWriter()

	{

	Cancel();

	if(iBuffer)

		{

		}

	delete iBuffer;

	}

void CEndpointWriter::DoCancel()

	{

	// Cancel the write to the endpoint

	iClientDriver.WriteCancel(iEndpoint);

	}

TUint CEndpointWriter::NumBytesWrittenSoFar()

	{

	return iNumBytesWritten;

	}

void CEndpointWriter::RunL()

	{

	TInt completionCode(iStatus.Int());

	iNumBytesWritten += iNumBytesOnCurrentWrite; // all zero if not a repeated write

	if(iNumBytesWritten < iTotalNumBytes)

		//'iNumBytesWritten' and 'iTotalNumBytes' will both be zero.

		{

		TUint totalNumBytesStillToWrite = iTotalNumBytes - iNumBytesWritten;

		//NB iNumBytesOnCurrentWrite should remain at the requested 'bytes per Write' value until the last iteration

		iNumBytesOnCurrentWrite = totalNumBytesStillToWrite <= iNumBytesOnCurrentWrite ? totalNumBytesStillToWrite : iNumBytesOnCurrentWrite;

		//Only add a ZLP, if requested and if the last 'Write'

		TBool useUsb = totalNumBytesStillToWrite <= iNumBytesOnCurrentWrite ? iUseZLP : EFalse;

		TPtrC8 writeDesc = iBufPtr.Mid(iNumBytesWritten%iDataPatternLength, iNumBytesOnCurrentWrite);

		Write(writeDesc, useUsb, EFalse);

		}

	else

		{

		if(iBuffer!=NULL)

			{

			}

		else

			{

			}

		if(iTotalNumBytes != 0)

			//if a repeated write

			{

			}

		delete iBuffer;

		iBuffer = 0;

		iNumBytesOnCurrentWrite = 0;

		iNumBytesWritten = 0;

		iTotalNumBytes = 0;

		iDataPatternLength = 0;

		iUseZLP = EFalse;

		}

	}

TInt CEndpointWriter::RunError(TInt aError)

	{

	aError = KErrNone;

	return aError;

	}

void CEndpointWriter::Write(const TDesC8& aData, TBool aUseZLP, TBool aCreateBuffer)

	{

  	if(aCreateBuffer == EFalse)

  		{

  		iClientDriver.Write(iStatus,iEndpoint,aData,aData.Length(),aUseZLP);

  		SetActive();

 		return;

  		}

	//Copy aData to this object's buffer

	delete iBuffer;

  	iBuffer = NULL;

	iBuffer = HBufC8::NewL(aData.Length());

	iBufPtr.Set(iBuffer->Des());

	iBufPtr.Copy(aData);

	// Write the data to the host through the endpoint (host opened pipe)

	iClientDriver.Write(iStatus,iEndpoint,iBufPtr,iBufPtr.Length(),aUseZLP);

	SetActive();

	}

TInt CEndpointWriter::WriteSynchronous(const TDesC8& aData, TBool aUseZLP)

	{

	TRequestStatus status = KRequestPending;

	iClientDriver.Write(status,iEndpoint,aData,aData.Length(),aUseZLP);

	User::WaitForRequest(status);

	return status.Int();

	}

void CEndpointWriter::WriteSynchronousUsingPatternL(const TDesC8& aData, const TUint aNumBytes, const TBool aUseZLP)

	{

	TBool useZLP = EFalse; //only want this if you are making the last call to client Write (=WriteSynchronous)

	if(aNumBytes <= aData.Length())

	//Don't need to allocate a buffer and copy to it - write will be done synchronously

		{

		if(aUseZLP)

			{

			useZLP = ETrue;

			}

		WriteSynchronous(aData.Left(aNumBytes),useZLP);

		}

	else if(aNumBytes <= KMaxTransferBuffer)

	//Create a buffer based on the data pattern sent and use just one 'Synchronous Write'

		{

		if(aUseZLP)

			{

			useZLP = ETrue;

			}

	  	TInt repeats = aNumBytes/aData.Length();

	  	TInt extraBytes = aNumBytes%aData.Length();

	  	delete iBuffer;

	  	iBuffer = NULL;

	 	iBuffer = HBufC8::NewL(aNumBytes);

	 	TPtr8 ptr = iBuffer->Des();

	 	ptr.Zero();

	  	for(TUint i =0; i<repeats; i++)

	  		{

	  		ptr.Append(aData);

	  		}

	  	if(extraBytes)

	  		{

	  		ptr.Append(aData.Left(extraBytes));

	  		}

	  	WriteSynchronous(ptr, useZLP);

	  	delete iBuffer;

		}

	else

	//Create a buffer based on the data pattern sent and use SEVERAL 'Synchronous Write's

		{

		//Write data in reasonably sized chunks

		//Create buffer using max whole number of data patterns

	  	TInt repeats = KMaxTransferBuffer/aData.Length();

	  	CreateBigBuffer(aData, repeats);

		//Now write data

	  	repeats = aNumBytes/iBufPtr.Length(); //re-use 'repeats'

	  	TInt endBytes = aNumBytes%iBufPtr.Length();

	  	for(TInt i=0;i<repeats;i++)

	  		{

			if(i==(repeats-1)&&endBytes==0)

				//last loop - request ZLP if appropriate

				{

				WriteSynchronous(*iBuffer, aUseZLP); //if last 'Write'

				}

			else

				{

				WriteSynchronous(*iBuffer, EFalse);

				}

	  		}

	  	if(endBytes)

	  		{

			WriteSynchronous(iBufPtr.Left(endBytes), aUseZLP); //if last 'Write'

	  		}

		}

	delete iBuffer;

	iBuffer = 0;

	}

void CEndpointWriter::WriteSynchronousUsingPatternL(const TDesC8& aData, const TUint aNumBytes)

	{

	WriteSynchronousUsingPatternL(aData, aNumBytes, ETrue);

	}

void CEndpointWriter::WriteSynchronousUsingPatternAndHaltL(const TDesC8& aData, const TUint aNumBytes)

	{

	WriteSynchronousUsingPatternL(aData, aNumBytes, EFalse);

	iClientDriver.HaltEndpoint(iEndpoint);

	}

void CEndpointWriter::WriteUsingPatternL(const TDesC8& aData, const TUint aNumBytes, const TBool aUseZLP)

	{

  	delete iBuffer;

  	iBuffer = NULL;

	iBuffer = HBufC8::NewL(aNumBytes);

	iBufPtr.Set(iBuffer->Des());

	iBufPtr.Zero();

	TInt repeats = aNumBytes/aData.Length();

	for(TUint i =0; i<repeats; i++)

		{

		iBufPtr.Append(aData);

		}

	if(TInt extraBytes = aNumBytes%aData.Length())

		{

		iBufPtr.Append(aData.Left(extraBytes));

		}

	Write(*iBuffer, aUseZLP, EFalse);

	}

void CEndpointWriter::WriteInPartsUsingPatternL(const TDesC8& aData, const TUint aNumBytesPerWrite, TUint aTotalNumBytes, const TBool aUseZLP)

	{

	iUseZLP = aUseZLP;

	TInt repeats = aNumBytesPerWrite/aData.Length() + 1;

	repeats *= 2;

	CreateBigBuffer(aData, repeats);

	iDataPatternLength = aData.Length();

	iTotalNumBytes = aTotalNumBytes;

	iNumBytesOnCurrentWrite = aNumBytesPerWrite;

	iNumBytesWritten = 0;

	Write(iBufPtr.Mid(iNumBytesWritten%iDataPatternLength, iNumBytesOnCurrentWrite), EFalse, EFalse); //this is not the first 'Write' so do not use a ZLP

	}

void CEndpointWriter::CreateBigBuffer(const TDesC8& aData, const TUint aRepeats)

/*

Create a payload buffer a section of which can always be used for each cyclic 'Write'.

*/

	{

	//We require a buffer containing a sufficient number of repeats of the data pattern

	//to allow us simply to use a section of it for any individual 'Write' payload.

 	delete iBuffer;

 	iBuffer = NULL;

 	iBuffer = HBufC8::NewL(aRepeats*aData.Length());

	iBufPtr.Set(iBuffer->Des());

	iBufPtr.Zero();

 	for(TUint i =0; i<aRepeats; i++)

  		{

  		iBufPtr.Append(aData);

  		}

	}

	}