// 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 PBASE-T_USBDI-0482.cpp

// @internalComponent

// 

//

#include "PBASE-T_USBDI-0482.h"

#include "tada22.h"

#include <d32usbdescriptors.h>

namespace NUnitTesting_USBDI

	{

_LIT(KTestCaseId,"PBASE-T_USBDI-0482");

const TFunctorTestCase<CUT_PBASE_T_USBDI_0482,TBool> CUT_PBASE_T_USBDI_0482::iFunctor(KTestCaseId);	

_LIT8(KHighRecordSamplingRate, "\x80\xBB\x00");	// sampling rate : 48,000 Hz

_LIT8(KLowSamplingRate		 , "\x22\x56\x00"); // sampling rate : 22,050 Hz

_LIT(KTrackFileName, "Z:\\scripts\\track.dat");

const TInt KRecordedDataId 			  = 0x12345;

const TUint KRecordedPacketsExpected  = 1000;

const TUint KAudioCDQualityFrequency  = 176; // 176 kB/s

const TUint KMaxPacketSizeOutExpected = 192;

const TUint KMaxPacketSizeInExpected  = 96;

const TUint KMaxPacketSizeOffset  	  = 4;

const TUint KIsochInMaxNumPackets  	  = 2000;

const TUint KChunkSize 				  = 500000; // 0.5 Mb

TInt CUT_PBASE_T_USBDI_0482::iExpectedTransferId = 0;

CUT_PBASE_T_USBDI_0482* CUT_PBASE_T_USBDI_0482::NewL(TBool aHostRole)

	{

	CUT_PBASE_T_USBDI_0482* self = new (ELeave) CUT_PBASE_T_USBDI_0482(aHostRole);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CUT_PBASE_T_USBDI_0482::CUT_PBASE_T_USBDI_0482(TBool aHostRole)

:	CBaseTestCase(KTestCaseId,aHostRole),

	iCaseStep(EInProgress)

	{

	iEndpointAddressIn = 0x84;

	iEndpointAddressOut = 0x01;

	iOutTransferBuf.CreateL(KChunkSize);

	} 

void CUT_PBASE_T_USBDI_0482::ConstructL()

	{

	BaseConstructL();

	}

CUT_PBASE_T_USBDI_0482::~CUT_PBASE_T_USBDI_0482()

	{

	LOG_FUNC

	Cancel();

	// Close pipes before interfaces	

	iPipeOut.Close();

	iPipeIn.Close();

	iUsbInterface0.Close();

	iUsbInterface1.Close();

	iUsbInterface2.Close();

	// Destroy transfers

	iOutTransfers.ResetAndDestroy();

	iOutTransferBuf.Close();

	iDataPolledBuf.Close();

	delete iIsochInTransfer;

	delete iControlEp0;

	delete iActorFDF;

	}

void CUT_PBASE_T_USBDI_0482::ExecuteHostTestCaseL()	

	{

	LOG_FUNC

	iActorFDF = CActorFDF::NewL(*this);

	iControlEp0 = new (ELeave) CEp0Transfer(iUsbInterface0);

	iActorFDF->Monitor();

	// Wait for the usb headset to be connected	

	TimeoutIn(30);

	}

void CUT_PBASE_T_USBDI_0482::HostDoCancel()

	{

	LOG_FUNC	

	}	

void CUT_PBASE_T_USBDI_0482::ExecuteDeviceTestCaseL()	

	{

	LOG_FUNC

	}

void CUT_PBASE_T_USBDI_0482::DeviceDoCancel()

	{

	LOG_FUNC

	}

void CUT_PBASE_T_USBDI_0482::DeviceStateChangeL(RUsbDevice::TDeviceState aPreviousState,RUsbDevice::TDeviceState aNewState,

		TInt aCompletionCode)

	{

	LOG_FUNC	

	}

TInt CUT_PBASE_T_USBDI_0482::FindOUTIsochronousEndpoint(TUsbGenericDescriptor*& aDescriptor)

	{

	LOG_FUNC	

	aDescriptor = NULL;

	TUsbInterfaceDescriptor alternate;

	TInt err = iUsbInterface1.GetAlternateInterfaceDescriptor(1, alternate);

	if(err)

		{

		RDebug::Printf("iUsbInterface1.GetAlternateInterfaceDescriptor error = %d",err);

		return err;

		} 

	TUsbGenericDescriptor* descriptor = alternate.iFirstChild;

	while(descriptor)

		{

		RDebug::Printf("ibDescriptorType = %d", descriptor->ibDescriptorType);

		if(descriptor->ibDescriptorType == EEndpoint)

			{

			aDescriptor = descriptor;

			RDebug::Printf("found descriptor return KErrNone");

			return KErrNone;

			}	

		descriptor = descriptor->iNextPeer;

		}

	return KErrNotFound;	

	}

TInt CUT_PBASE_T_USBDI_0482::FindINIsochronousEndpoint(TUsbGenericDescriptor*& aDescriptor)

	{

	LOG_FUNC	

	aDescriptor = NULL;

	TUsbInterfaceDescriptor alternate;

	TInt err = iUsbInterface2.GetAlternateInterfaceDescriptor(1, alternate);

	if(err)

		{

		RDebug::Printf("iUsbInterface2.GetAlternateInterfaceDescriptor error = %d",err);

		return err;

		} 

	TUsbGenericDescriptor* descriptor = alternate.iFirstChild;

	while(descriptor)

		{

		RDebug::Printf("ibDescriptorType = %d", descriptor->ibDescriptorType);

		if(descriptor->ibDescriptorType == EEndpoint)

			{

			aDescriptor = descriptor;

			RDebug::Printf("found descriptor return KErrNone");

			return KErrNone;

			}

		descriptor = descriptor->iNextPeer;

		}

	return KErrNotFound;	

	}	

void CUT_PBASE_T_USBDI_0482::DeviceInsertedL(TUint aDeviceHandle)

	{

	LOG_FUNC

	Cancel();

	CUsbTestDevice& testDevice = iActorFDF->DeviceL(aDeviceHandle);

	CHECK(CheckTreeAfterDeviceInsertion(testDevice, _L("RLogitechHeadSet")) == KErrNone);

	TUint32 token0, token1, token2;

	CHECK(testDevice.Device().GetTokenForInterface(0,token0) == KErrNone);

	CHECK(iUsbInterface0.Open(token0) == KErrNone); // Default interface setting 0

	// open interface 1, alt. sett. 1

	CHECK(testDevice.Device().GetTokenForInterface(1,token1) == KErrNone);

	CHECK(iUsbInterface1.Open(token1) == KErrNone); // Default interface setting 0

	RDebug::Printf("Selecting alternate interface setting 1");		

	CHECK(iUsbInterface1.SelectAlternateInterface(1) == KErrNone);

	// open interface 2, alt. sett. 1

	CHECK(testDevice.Device().GetTokenForInterface(2,token2) == KErrNone);

	CHECK(iUsbInterface2.Open(token2) == KErrNone); // Default interface setting 0

	RDebug::Printf("Selecting alternate interface setting 1");		

	CHECK(iUsbInterface2.SelectAlternateInterface(1) == KErrNone);

	iCaseStep = EWaitEndOfMusicTrack;

	// Open a pipe for endpoint (Isoch out)		

	RDebug::Printf("Finding address for an out isoch endpoint on interface 1 setting 1");

	// Isochronous OUT	

	TUsbGenericDescriptor* isochEpDescriptorOut;

	CHECK(KErrNone == FindOUTIsochronousEndpoint(isochEpDescriptorOut));

	// Get the maximum packet size for this isochronous endpoint

	TUint16 wMaxPacketSizeOut = isochEpDescriptorOut->TUint16At(KMaxPacketSizeOffset);	

	RDebug::Printf("wMaxPacketSizeOut = %d", wMaxPacketSizeOut);

	CHECK(wMaxPacketSizeOut == KMaxPacketSizeOutExpected); 

	// Isochronous IN		

	TUsbGenericDescriptor* isochEpDescriptorIn;

	CHECK(KErrNone == FindINIsochronousEndpoint(isochEpDescriptorIn));

	// Get the maximum packet size for this isochronous endpoint

	TUint16 wMaxPacketSizeIn = isochEpDescriptorIn->TUint16At(KMaxPacketSizeOffset);	

	RDebug::Printf("wMaxPacketSizeIn = %d", wMaxPacketSizeIn);

	CHECK(wMaxPacketSizeIn == KMaxPacketSizeInExpected); 

	// open pipes now.

	// Out

	RDebug::Printf("Opening a pipe to %08x",iEndpointAddressOut);

	CHECK(iUsbInterface1.OpenPipeForEndpoint(iPipeOut,iEndpointAddressOut,EFalse) == KErrNone);

	RDebug::Printf("Opened pipe to endpoint address %08x for isochronous transfer to device",iEndpointAddressOut);

	// In

	RDebug::Printf("Opening a pipe to %08x",iEndpointAddressIn);		

	CHECK(iUsbInterface2.OpenPipeForEndpoint(iPipeIn,iEndpointAddressIn,EFalse) == KErrNone);

	RDebug::Printf("Opened pipe to endpoint address %08x for isochronous transfer to device",iEndpointAddressIn);

	// SET_CUR class specific command

	TSetCurRequest request(KHighRecordSamplingRate ,iEndpointAddressIn);

	iControlEp0->SendRequest(request,this);

	// Que transfers now		

	// Transfer IN	

	 iIsochInTransfer = new (ELeave) CIsochTransfer(iPipeIn,iUsbInterface2,wMaxPacketSizeIn,

					KIsochInMaxNumPackets ,*this, KRecordedDataId);

	CHECK(iIsochInTransfer->RegisterTransferDescriptor() == KErrNone);

	// Initialise the descriptors for transfer	

	RDebug::Printf("Initialising the transfer descriptors interface 2"); 

	CHECK(iUsbInterface2.InitialiseTransferDescriptors() == KErrNone);

	// que interrupt transfer

	CHECK(iIsochInTransfer->TransferInL(KRecordedPacketsExpected) == KErrNone);

	// Transfer OUT

	RFs iFs;

	TInt ret = KErrNone; 

	ret = iFs.Connect();

	CHECK(ret==KErrNone || ret==KErrAlreadyExists);

	RFile trackFile;

	CHECK(trackFile.Open(iFs,KTrackFileName,EFileShareAny|EFileRead) == KErrNone);

	TInt trackFileSize;	

	trackFile.Size(trackFileSize); 

	wMaxPacketSizeOut = KAudioCDQualityFrequency;  	

	TInt nbChunks = trackFileSize/KChunkSize;

	TInt remainderSize = trackFileSize%KChunkSize; 

	if(remainderSize != 0)

		{

		nbChunks++;

		}

	TInt iChunk = 0;   

	TInt size = KChunkSize;

	// create Transfers

	for(iChunk = 0; iChunk < nbChunks; iChunk++)

		{

		RDebug::Printf("iChunk = %d", iChunk);

		// remainder(last loop)

		if(remainderSize != 0 && (iChunk == nbChunks-1))

			{			

			size = remainderSize;

			}	

		CIsochTransfer* transfer = new (ELeave) CIsochTransfer(iPipeOut,iUsbInterface1,wMaxPacketSizeOut,

					(size/wMaxPacketSizeOut),*this, iChunk);

		CHECK(transfer->RegisterTransferDescriptor() == KErrNone);					

		iOutTransfers.AppendL(transfer);		

		iOutTransferBuf.Zero();    							

		}			

	// Initialise the descriptors for transfer	

	RDebug::Printf("Initialising the transfer descriptors"); 

	CHECK(iUsbInterface1.InitialiseTransferDescriptors() == KErrNone);

	// prepare & send transfers(TODO streaming algorithm with 3 Transfers only, filling 2 while the 3rd is transferring his data)

	size = KChunkSize;

	for(TInt iTransfers = 0; iTransfers < iOutTransfers.Count(); iTransfers++)

		{	

		RDebug::Printf("iTransfers = %d", iTransfers);	

		// remainder(last loop)

		if(remainderSize != 0 && (iTransfers == iOutTransfers.Count()-1))

			{

			RDebug::Printf("remainderSize = %d", remainderSize);

			size = remainderSize;

			}			

		CHECK(trackFile.Read(KChunkSize*iTransfers, iOutTransferBuf, size) == KErrNone);

		CHECK(iOutTransfers[iTransfers]->PrepareTransfer(iOutTransferBuf) == KErrNone);		

		CHECK(iOutTransfers[iTransfers]->TransferOut() == KErrNone);

		iOutTransferBuf.Zero();		

		}												

	}

TBool CUT_PBASE_T_USBDI_0482::ReplayRecordedData()

	{

	LOG_FUNC

	iOutTransferBuf.Zero();	

	// Transfer OUT						

	TInt nbChunks = iDataPolledBuf.Length()/KChunkSize;

	TInt remainderSize = iDataPolledBuf.Length()%KChunkSize; 

	RDebug::Printf("nbChunks = %d", nbChunks);

	RDebug::Printf("remainderSize = %d", remainderSize);

	if(remainderSize != 0) 

		{

		nbChunks++;

		}

	// prepare transfers	

	for(TInt iTransfers = 0; iTransfers < nbChunks; iTransfers++)

		{	

		RDebug::Printf("iTransfers = %d", iTransfers);	

		// remainder(last loop)

		if(remainderSize != 0 && (iTransfers == nbChunks-1))

			{

			RDebug::Printf("remainderSize = %d", remainderSize);

			}		

		CHECK_RET_BOOL(iOutTransfers[iTransfers]->PrepareTransfer(iDataPolledBuf) == KErrNone); // TODO retrieve relevant part of iDataPolledBuf if several chunks

		CHECK_RET_BOOL(iOutTransfers[iTransfers]->TransferOut() == KErrNone);

		iOutTransferBuf.Zero();	

		}

	return ETrue;			

	}

void CUT_PBASE_T_USBDI_0482::TransferCompleteL(TInt aTransferId,TInt aCompletionCode)

	{

	LOG_FUNC

	RDebug::Printf("Transfer completed (id=%d), aCompletionCode = %d",aTransferId, aCompletionCode);

	Cancel();

	if(aCompletionCode != KErrNone)

		{

		RDebug::Printf("<Error %d> Transfer %d not successful",aCompletionCode,aTransferId);

		TestFailed(aCompletionCode);

		return;

		}

	if(aTransferId == KRecordedDataId)

		{

		// data successfully recorded

		// 1. save data recorded

		CHECK(iIsochInTransfer->DataPolled(KRecordedPacketsExpected, iDataPolledBuf));

		// 2. waiting now for the end of the music track

		return;	

		}

	switch(iCaseStep)

		{

		case EWaitEndOfMusicTrack:

			{

			if(aTransferId != iExpectedTransferId)

				{

				RDebug::Printf("unexpected transfer!");

				TestFailed(KErrCorrupt);

				}

			iExpectedTransferId++;		

			// is it the last transfer?

			if(iExpectedTransferId == iOutTransfers.Count())

				{

				RDebug::Printf("last transfer successful! lets replay recorded data");

				iCaseStep = EReplayRecordedData; // assuming that recording is finished

				TSetCurRequest request(KLowSamplingRate ,iEndpointAddressOut);

				iControlEp0->SendRequest(request,this);		

				}			

			}		

			break;

		case EReplayRecordedData:

			{

			TestPassed();	// TODO only one transfer used in this case(few data recorded), cope with several ones	

			}			

			break;

		default:

			TestFailed(KErrDisconnected);

			break;

		}			

	}									   

void CUT_PBASE_T_USBDI_0482::Ep0TransferCompleteL(TInt aCompletionCode)

	{

	LOG_FUNC

	RDebug::Printf("Transfer EP0 completed aCompletionCode = %d", aCompletionCode);

	if(aCompletionCode != KErrNone)

		{

		TBuf<256> msg;

		msg.Format(_L("<Error %d> Transfer to control endpoint 0 was not successful"),aCompletionCode);

		RDebug::Print(msg);			

		return;			

		}	

	switch(iCaseStep)

		{	

		case EWaitEndOfMusicTrack:	

			break;	

		case EReplayRecordedData:	

			{

			CHECK(ReplayRecordedData());		

			}

			break;			

		default:

			RDebug::Printf("<Error> Unknown test step");

			TestFailed(KErrUnknown);

			break;

		}

	}	

void CUT_PBASE_T_USBDI_0482::DeviceRemovedL(TUint aDeviceHandle)

	{

	LOG_FUNC

	// Manual test over	

	switch(iCaseStep)

		{		

		case EFailed:

			TestFailed(KErrCompletion);

			break;

		case EInProgress:

		default:

			TestFailed(KErrDisconnected);

			break;

		}

	}

void CUT_PBASE_T_USBDI_0482::BusErrorL(TInt aError)

	{

	LOG_FUNC	

	// This test case handles no failiures on the bus	

	TestFailed(KErrCompletion);	

	}

void CUT_PBASE_T_USBDI_0482::HostRunL()

	{

	LOG_FUNC

	// Obtain the completion code

	TInt completionCode(iStatus.Int());

	if(completionCode == KErrNone)

		{

		// Action timeout

		RDebug::Printf("<Error> Action timeout");

		TestFailed(KErrTimedOut);

		}

	else

		{

		RDebug::Printf("<Error %d> Timeout timer could not complete",completionCode);

		TestFailed(completionCode);

		}

	}

void CUT_PBASE_T_USBDI_0482::DeviceRunL()

	{	

	}

	}