/*

* 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 "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:

*

*/

#include "usbtestconsole.h"

#include <e32cons.h>

#include <e32debug.h>

#include <d32otgdi_errors.h>

#include <d32usbdi_errors.h>

#include <d32usbdi.h>

#include <usb/usbshared.h>

static TBool verbose = EFalse;

const TUint KTimerAWaitBConnect = 30*1000000;  

#define PANIC Panic(__LINE__)

#define LOG(A,B) if (verbose) RDebug::Print(_L("UsbTestConsole: " L##A),B)

#define PNT(A)	 if (verbose) RDebug::Print(_L("UsbTestConsole: " L##A))

void Panic(TInt aLine)

	{

	if (verbose) RDebug::Printf("UsbTestConsole: PANIC line=%d", aLine);

	User::Panic(_L("USBTESTCONSOLE"), aLine);

	}

_LIT(KArgVerbose, "VERBOSE");

void RunConsoleL()

	{

	TInt cmdLineLength(User::CommandLineLength());

	HBufC* cmdLine = HBufC::NewMaxLC(cmdLineLength);

	TPtr cmdLinePtr = cmdLine->Des();

	User::CommandLine(cmdLinePtr);

	TLex args(*cmdLine);

	args.SkipSpace(); // args are separated by spaces

	// first arg is the exe name, skip it

	TPtrC cmdToken = args.NextToken();

	HBufC* tc = HBufC::NewLC(80);

	*tc = cmdToken;

	while (tc->Length())

		{

		TInt pos = tc->FindF(KArgVerbose);

		if ( pos != KErrNotFound )

			{ 

			verbose = ETrue;

			}

		// next parameter

		*tc = args.NextToken();

		}

	CleanupStack::PopAndDestroy(tc);

	CleanupStack::PopAndDestroy(cmdLine);

	CUsbTestConsole* console = CUsbTestConsole::NewLC();

	console->StartL();

	CleanupStack::PopAndDestroy(console);

	}

TInt E32Main()

	{

	__UHEAP_MARK;

	CTrapCleanup* cleanup = CTrapCleanup::New();

	CActiveScheduler* activeScheduler = new CActiveScheduler;

	TInt err = KErrNoMemory;

	if(cleanup && activeScheduler)

		{

		CActiveScheduler::Install(activeScheduler);

		TRAP(err,RunConsoleL());

		}

	delete activeScheduler;

	delete cleanup;

	__UHEAP_MARKEND;

	return err;

	}

XUsbTestConsoleEvent::~XUsbTestConsoleEvent()

	{

	iLink.Deque();

	iEvent.Close();

	}

CUsbTestConsoleKeys* CUsbTestConsoleKeys::NewL(CUsbTestConsole& aTestConsole)

	{

	CUsbTestConsoleKeys* self = new(ELeave) CUsbTestConsoleKeys(aTestConsole);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CUsbTestConsoleKeys::~CUsbTestConsoleKeys()

	{

	Cancel();

	TDblQueIter<CUsbTestConsoleTextEntryBase> iter(iEntryConsoles);

	CUsbTestConsoleTextEntryBase* event = NULL;

	while((event = iter++) != NULL)

		{

		delete event;

		}

	delete iUsbManStarter;

	delete iUsbManStoper;

	delete iUsbManTryStarter;

	delete iUsbManTryStoper;

	}

CUsbTestConsoleKeys::CUsbTestConsoleKeys(CUsbTestConsole& aTestConsole)

	: CActive(EPriorityStandard)

	, iTestConsole(aTestConsole)

	, iEntryConsoles(_FOFF(CUsbTestConsoleTextEntryBase, iLink))

	{

	CActiveScheduler::Add(this);

	}

void CUsbTestConsoleKeys::ConstructL()

	{

	iTestConsole.iConsole->Read(iStatus);

	SetActive();

	}

void CUsbTestConsoleKeys::DoCancel()

	{

	iTestConsole.iConsole->ReadCancel();

	}

void CUsbTestConsoleKeys::RunL()

	{

	User::LeaveIfError(iStatus.Int());

	switch(iTestConsole.iConsole->KeyCode())

		{

	case '[':

		{

		RUsb sess;

		TInt err = sess.Connect();

		sess.Close();

		User::After(4000000);

		err = sess.Connect(); 

		XUsbTestConsoleEvent* event = NewConsoleEventL();

		event->iEvent.AppendFormat(_L("T:USBMAN Test Err[%d]"), err);

		iTestConsole.NotifyEvent(event);

		sess.Close();

		}

		break;

	case 'm':

		{

		TInt val = 1;

		TInt err = RProperty::Set(KUidUsbManCategory,KUsbRequestSessionProperty,val);

		XUsbTestConsoleEvent* event = NewConsoleEventL();

		event->iEvent.AppendFormat(_L("T:USBMAN VBus marshalling - err=[%d]"),err);

		iTestConsole.NotifyEvent(event);

		}

		break;

	case 'H': case 'h': case '?': 

		iTestConsole.ScheduleDraw('H');

		break;

	case 'q': case 'Q':

		iTestConsole.Stop();

		return;

	case 's':

		// Toggle Start

		if(!iUsbManStarter)

			{

			CUsbManStarter::NewL(iUsbManStarter, iTestConsole);

			}

		else

			{

			iUsbManStarter->DestroyL();

			}

		break;

	case 'S':

		// Toggle Stop

		if(!iUsbManStoper)

			{

			// Because we cannot tell query the actual state of Function Driver loading

			// when we shutdown we also automatically disable loading.

			iTestConsole.Usb().DisableFunctionDriverLoading();

			iFunctionDriverLoading = EFalse;

			iTestConsole.SetDriverLoading(CUsbTestConsole::EDisabled);

			CUsbManStoper::NewL(iUsbManStoper, iTestConsole);

			}

		else

			{

			iUsbManStoper->DestroyL();

			}

		break;

	case 't':

		// Toggle TryStart

		if(!iUsbManTryStarter)

			{

			CUsbManTryStarter::NewL(iUsbManTryStarter, iTestConsole, iPersonalityId);

			}

		else

			{

			iUsbManTryStarter->DestroyL();

			}

		break;

	case 'T':

		// Toggle TryStop

		if(!iUsbManTryStoper)

			{

			// Because we cannot tell query the actual state of Function Driver loading

			// when we shutdown we also automatically disable loading.

			iTestConsole.Usb().DisableFunctionDriverLoading();

			iFunctionDriverLoading = EFalse;

			iTestConsole.SetDriverLoading(CUsbTestConsole::EDisabled);

			CUsbManTryStoper::NewL(iUsbManTryStoper, iTestConsole);

			}

		else

			{

			iUsbManTryStoper->DestroyL();

			}

		break;

	case 'p': case 'P':

		// Enter personality id

			{

			CUsbTestConsoleTextEntryBase* entry = CUsbTestConsoleTextEntry<TInt>::NewL(iPersonalityId, _L("Personality Id"));

			iEntryConsoles.AddLast(*entry);

			}

		break;

	case 'c': case 'C':

		// Toggle Control Session

			{

			iControlSession = !iControlSession;

			TInt err = iTestConsole.Usb().SetCtlSessionMode(iControlSession);

			if(err != KErrNone)

				{

				iControlSession = !iControlSession;

				}

			else

				{

				iTestConsole.SetControlSession(iControlSession);

				if(!iControlSession)

					{

					// This is set to unknown because as soon as we relinquish the controlling session

					// someone else could be altering the state.

					iFunctionDriverLoading = EFalse;

                    iTestConsole.SetDriverLoading(CUsbTestConsole::EUnknown);

					}

				}

			XUsbTestConsoleEvent* event = NewConsoleEventL();

			event->iEvent.AppendFormat(_L("G:SetControlSession:Err[%d]"), err);

			iTestConsole.NotifyEvent(event);

			}

		break;

	case 'b':

		// Bus Request

			{

			TInt err = iTestConsole.Usb().BusRequest();

			XUsbTestConsoleEvent* event = NewConsoleEventL();

			event->iEvent.AppendFormat(_L("G:BusRequest:Err[%d]"), err);

			iTestConsole.NotifyEvent(event);

			}

		break;

	case 'r':

	    // Respond to SRP

			{

			TInt err = iTestConsole.Usb().BusRespondSrp();

			XUsbTestConsoleEvent* event = NewConsoleEventL();

			event->iEvent.AppendFormat(_L("G:BusRespondSrp:Err[%d]"), err);

			iTestConsole.NotifyEvent(event);

			}

			break;

	case 'R':

		// Auto-respond to SRP

			{

			iTestConsole.SetAutoSrpResponseState( !iTestConsole.GetAutoSrpResponseState() );

			XUsbTestConsoleEvent* event = NewConsoleEventL();

			event->iEvent.AppendFormat(_L("G:Auto-Respond to SRP (%d)"), iTestConsole.GetAutoSrpResponseState());

			iTestConsole.NotifyEvent(event);

			}

			break;

	case 'x': case 'X':

	    // Clear Bus Error State

			{

			TInt err = iTestConsole.Usb().BusClearError();

			XUsbTestConsoleEvent* event = NewConsoleEventL();

			event->iEvent.AppendFormat(_L("G:BusClearError:Err[%d]"), err);

			iTestConsole.NotifyEvent(event);

			}

			break;

	case 'B':

		// Bus Drop

			{

			TInt err = iTestConsole.Usb().BusDrop();

			XUsbTestConsoleEvent* event = NewConsoleEventL();

			event->iEvent.AppendFormat(_L("G:BusDrop:Err[%d]"), err);

			iTestConsole.NotifyEvent(event);

			}

		break;

	case 'e': case 'E':

			{

			TBool functionDriverLoading = !iFunctionDriverLoading;

			CUsbTestConsole::TFdfDriverLoadingState state = functionDriverLoading ? CUsbTestConsole::EEnabled : CUsbTestConsole::EDisabled;

			TInt err = KErrNone;

			if(functionDriverLoading)

				{

				err = iTestConsole.Usb().EnableFunctionDriverLoading();

				}

			else

				{

				iTestConsole.Usb().DisableFunctionDriverLoading();

				}

			if(err == KErrNone)

				{

				iFunctionDriverLoading = functionDriverLoading;

				iTestConsole.SetDriverLoading(state);

				}

			XUsbTestConsoleEvent* event = NewConsoleEventL();

			event->iEvent.AppendFormat(_L("H:FunctionDriverLoading[%d] Err[%d]"), functionDriverLoading, err);

			iTestConsole.NotifyEvent(event);

			}

		break;

		case 'A': case 'a': 

			{

			XUsbTestConsoleEvent* event = NewConsoleEventL();

			switch( iTestConsole.iDeviceType )

				{

				case CUsbTestConsole::ELogitechHeadset:

					{

												// 12345678901234567890123456789012345678901234567890123

					event->iEvent.AppendFormat(_L("G:Audio will play OK on this Logitech headset"));

					}

					break;

				case CUsbTestConsole::EGenericDevice:

					{

												// 12345678901234567890123456789012345678901234567890123

					event->iEvent.AppendFormat(_L("G:Audio on this device is not supported"));

					}

					break;

				case CUsbTestConsole::ENoDevice:

					{

												// 12345678901234567890123456789012345678901234567890123

					event->iEvent.AppendFormat(_L("G:There is no device connected!"));

					}

					break;

				}

			iTestConsole.NotifyEvent(event);

			}

		break;

	case 'v': case 'V':

		{

		TBool oldVerbose = verbose;

		verbose = ETrue;

		if (oldVerbose)

			{

			PNT("Switching Logging Off");

			}

		else

			{

			PNT("Switching Logging On");

			}

		verbose = !oldVerbose;

		break;

		}

	default:

		// Unrecognised key

		XUsbTestConsoleEvent* event = NewConsoleEventL();

		event->iEvent.AppendFormat(_L("G:Unknown:Key[%c]"), iTestConsole.iConsole->KeyCode());

		iTestConsole.NotifyEvent(event);

		break;

		}

	iTestConsole.iConsole->Read(iStatus);

	SetActive();

	}

XUsbTestConsoleEvent* CUsbTestConsoleKeys::NewConsoleEventL()

	{

	XUsbTestConsoleEvent* event = new(ELeave) XUsbTestConsoleEvent;

	CleanupStack::PushL(event);

	User::LeaveIfError(event->iEvent.Create(CUsbTestConsole::KNumCharactersOnLine-1));

	CleanupStack::Pop();

	return event;

	}

CUsbTestConsole* CUsbTestConsole::NewLC()

	{

	CUsbTestConsole* self = new(ELeave) CUsbTestConsole;

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CUsbTestConsole::~CUsbTestConsole()

	{

	PNT("Closing Console");

	delete iKeys;

	TDblQueIter<XUsbTestConsoleEvent> iter(iEventList);

	XUsbTestConsoleEvent* event = NULL;

	while((event = iter++) != NULL)

		{

		delete event;

		}

	delete iMessageWatcher;

	delete iHostEventWatcher;

	delete iOtgStateWatcher;

	delete iVBusWatcher;

	delete iIdPinWatcher;

	delete iDeviceStateWatcher;

	delete iServiceStateWatcher;

	delete iTimer;  

	Cancel();

	PNT("Closing USB Session");

	iUsb.Close();

	delete iConsole;

	}

CUsbTestConsole::CUsbTestConsole()

	: CActive(EPriorityLow) // Low so all notifications that want to be serviced will be done first

	, iHelp(EFalse)

	, iAutoSrpResponse(EFalse)

	, iDeviceType(ENoDevice)

	, iEventList(_FOFF(XUsbTestConsoleEvent, iLink))

	{

	CActiveScheduler::Add(this);

	}

void CUsbTestConsole::ConstructL()

	{

	iConsole = Console::NewL(KUsbTestConsoleTitle, TSize(-1,-1));

	User::LeaveIfError(iUsb.Connect());

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

		{

        XUsbTestConsoleEvent* nullEvent = new(ELeave) XUsbTestConsoleEvent;

		iEventList.AddFirst(*nullEvent);

		}

	iServiceStateWatcher = CServiceStateWatcher::NewL(*this);

	iDeviceStateWatcher = CDeviceStateWatcher::NewL(*this);

	iIdPinWatcher = CIdPinWatcher::NewL(*this);

	iVBusWatcher = CVBusWatcher::NewL(*this);

    iConnectionIdleWatcher = CConnectionIdleWatcher::NewL(*this);

	iOtgStateWatcher = COtgStateWatcher::NewL(*this);

	iHostEventWatcher = CHostEventWatcher::NewL(*this);

	iMessageWatcher = CMessageWatcher::NewL(*this);

	iTimer = CUsbTestTimer::NewL(*this);  

	SetDriverLoading(EUnknown);

	SetDeviceType(ENoDevice);

	SetAutoSrpResponseState(EFalse);

	// After everything else, enable interactivity.

	iKeys = CUsbTestConsoleKeys::NewL(*this);

	}

CUsbTestTimer* CUsbTestConsole::Timer() const

	{

	return iTimer;

	}

void CUsbTestConsole::StartL()

	{

	// Get everything running

	CActiveScheduler::Start();

	}

void CUsbTestConsole::Stop() const

	{

	CActiveScheduler::Stop();

	}

void CUsbTestConsole::DoCancel()

	{