/*

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

*

*/

#include "usbviewer.h"

#include <e32cons.h>

#include <e32debug.h>

#include <d32otgdi_errors.h>

#include <d32usbdi_errors.h>

#include <usb/usbshared.h>

// For moving windows using scancode events

#include "e32event.h"

#include "e32svr.h" 

#define PANIC Panic(__LINE__)

#define LOG(A,B) RDebug::Print(_L("UsbViewer: " L##A),B)

#define PNT(A)	 RDebug::Print(_L("UsbViewer: " L##A))

void Panic(TInt aLine)

	{

	RDebug::Printf("UsbViewer: PANIC line=%d", aLine);

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

	}

void RunViewerL()

	{

	CUsbViewer* viewer = CUsbViewer::NewLC();

	viewer->Start();

	CleanupStack::PopAndDestroy(viewer);

	}

TInt E32Main()

	{

	__UHEAP_MARK;

	CTrapCleanup* cleanup = CTrapCleanup::New();

	CActiveScheduler* activeScheduler = new CActiveScheduler;

	TInt err = KErrNoMemory;

	if(cleanup && activeScheduler)

		{

		CActiveScheduler::Install(activeScheduler);

		PNT("*** UsbViewer E32Main ***\n");

		TRAP(err, RunViewerL());

		}

	delete activeScheduler;

	delete cleanup;

	__UHEAP_MARKEND;

	return err;

	}

XUsbViewerEvent::~XUsbViewerEvent()

	{

	iLink.Deque();

	iEvent.Close();

	}

CUsbViewer* CUsbViewer::NewLC()

	{

	PNT("CUsbViewer::NewLC");

	CUsbViewer* self = new(ELeave) CUsbViewer;

	CleanupStack::PushL(self);

	self->ConstructL();

	PNT("CUsbViewer::NewLC - Constructed Viewer");

	return self;

	}

CUsbViewer::~CUsbViewer()

	{

	PNT("CUsbViewer::~CUsbViewer");

	delete iShutdownMonitor;

	delete iMessageWatcher;

	delete iHostEventWatcher;

	delete iOtgStateWatcher;

	delete iConnIdleWatcher;

	delete iVBusWatcher;

	delete iIdPinWatcher;

	delete iDeviceStateWatcher;

	delete iServiceStateWatcher;

	delete iUserMsgQWatcher;

	iUserMsgQ.Close();

	TDblQueIter<XUsbViewerEvent> iter(iEventList);

	XUsbViewerEvent* event = NULL;

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

		{

		delete event;

		} 

	Cancel();

	PNT("Closing USB Session");

	iUsb.Close();

	delete iConsole;

	}

CUsbViewer::CUsbViewer()

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

	, iAutoSrpResponse(EFalse)

	, iDeviceType(ENoDevice)

	, iEventList(_FOFF(XUsbViewerEvent, iLink))

	{

	CActiveScheduler::Add(this);

	}

void CUsbViewer::ConstructL()

	{

	PNT("CUsbViewer::ConstructL");

	iConsole = Console::NewL(KUsbViewerTitle, TSize(KViewerNumCharactersOnLine, KNumLinesInWindow));

	Move(-3, -3);

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

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

		{

        XUsbViewerEvent* nullEvent = new(ELeave) XUsbViewerEvent;

		iEventList.AddFirst(*nullEvent);

		}

	// Open message queue to display user messages

	User::LeaveIfError(iUserMsgQ.OpenGlobal(KControlAppViewerMsgQName));

	iUserMsgQWatcher = CUserMsgQWatcher::NewL(*this);

	iServiceStateWatcher = CServiceStateWatcher::NewL(*this);

	iDeviceStateWatcher = CDeviceStateWatcher::NewL(*this);

	iIdPinWatcher = CIdPinWatcher::NewL(*this);

	iVBusWatcher = CVBusWatcher::NewL(*this);

	iConnIdleWatcher = CConnectionIdleWatcher::NewL(*this);

	iOtgStateWatcher = COtgStateWatcher::NewL(*this);

	iHostEventWatcher = CHostEventWatcher::NewL(*this);

	iMessageWatcher = CMessageWatcher::NewL(*this);

	SetDriverLoading(EUnknown);

	SetDeviceType(ENoDevice);

	iShutdownMonitor = CShutdownMonitor::NewL(*this);

	}

void CUsbViewer::Move(TInt aX, TInt aY)

	{

	TRawEvent event;

	event.Set(TRawEvent::EKeyDown, EStdKeyLeftShift);

	UserSvr::AddEvent(event);

	if (aX)

		{

		if ( aX > 0 )

			{

			// Move to the right...

			for(TInt i=aX; i; i--)

				{

				event.Set(TRawEvent::EKeyDown, EStdKeyRightArrow);

				UserSvr::AddEvent(event);

				event.Set(TRawEvent::EKeyUp, EStdKeyRightArrow);

				UserSvr::AddEvent(event);

				}

			}

		else

			{

			// Move to the Left...

			for(TInt i=aX; i; i++)

				{

				event.Set(TRawEvent::EKeyDown, EStdKeyLeftArrow);

				UserSvr::AddEvent(event);

				event.Set(TRawEvent::EKeyUp, EStdKeyLeftArrow);

				UserSvr::AddEvent(event);

				}

			}

		}

	if (aY)

		{

		if ( aY > 0 )

			{

			// Move downwards...

			for(TInt i=aY; i; i--)

				{

				event.Set(TRawEvent::EKeyDown, EStdKeyDownArrow);

				UserSvr::AddEvent(event);

				event.Set(TRawEvent::EKeyUp, EStdKeyDownArrow);

				UserSvr::AddEvent(event);

				}

			}

		else

			{

			// Move upwards...

			for(TInt i=aY; i; i++)

				{

				event.Set(TRawEvent::EKeyDown, EStdKeyUpArrow);

				UserSvr::AddEvent(event);

				event.Set(TRawEvent::EKeyUp, EStdKeyUpArrow);

				UserSvr::AddEvent(event);

				}

			}

		}

	event.Set(TRawEvent::EKeyUp, EStdKeyLeftShift);

	UserSvr::AddEvent(event);

	}

void CUsbViewer::Start()

	{

	// Get everything running

	CActiveScheduler::Start();

	}

void CUsbViewer::Stop() const

	{

	CActiveScheduler::Stop();

	}

void CUsbViewer::DoCancel()

	{

	// Don't need to do anything as the AO is completed straight away.

	}

void CUsbViewer::RunL()

	{

	__ASSERT_ALWAYS(iStatus.Int() == KErrNone, PANIC);

	Draw();

	}

void CUsbViewer::ScheduleDraw()

	{

	PNT("CUsbViewer::ScheduleDraw");

	if(!IsActive())

		{

		SetActive();

		TRequestStatus* status = &iStatus;

		User::RequestComplete(status, KErrNone);

		TSize size = iConsole->ScreenSize();

		iConsole->SetCursorPosAbs(TPoint(size.iWidth-1, 0));

		iConsole->Write(_L("*"));

		}

	}

RUsb& CUsbViewer::Usb()

	{

	return iUsb;

	}

RMsgQueue<TBuf<KViewerNumCharactersOnLine> >& CUsbViewer::UserMsgQ()

	{

	return iUserMsgQ;

	}

void CUsbViewer::SetServiceState(TUsbServiceState aServiceState)

	{

	switch(aServiceState)

		{

    case EUsbServiceIdle:

    	iServStatus =

    		//  12345678901

			_L("Idle       ");

    	break;

	case EUsbServiceStarting:

    	iServStatus =

    		//  12345678901

			_L("Starting   ");

		break;

	case EUsbServiceStarted:

	    iServStatus =

    		//  12345678901

			_L("Started    ");

		break;

	case EUsbServiceStopping:

    	iServStatus =

    		//  12345678901

			_L("Stopping   ");

		break;

	case EUsbServiceFatalError:

    	iServStatus =

    		//  12345678901

			_L("Error      ");

		break;

	default:

		PANIC;

		break;

		}

	LOG("Service State => %S", &iServStatus);

	ScheduleDraw();

	}

void CUsbViewer::SetDeviceState(TUsbDeviceState aDeviceState)

	{

	switch(aDeviceState)

		{

	case EUsbDeviceStateUndefined:

		iDevStatus =

    		//  12345678901

			_L("Undefined  ");

		break;

	case EUsbDeviceStateDefault:

		iDevStatus =

    		//  12345678901

			_L("Default    ");

		break;

	case EUsbDeviceStateAttached:

		iDevStatus =

    		//  12345678901

			_L("Attached   ");

		break;

	case EUsbDeviceStatePowered:

		iDevStatus =

    		//  12345678901

			_L("Powered    ");

		break;

	case EUsbDeviceStateConfigured:

		iDevStatus =

    		//  12345678901

			_L("Configured ");

		break;

	case EUsbDeviceStateAddress:

		iDevStatus =

    		//  12345678901

			_L("Address    ");

		break;

	case EUsbDeviceStateSuspended:

		iDevStatus =

    		//  12345678901

			_L("Suspended  ");

		break;

	default:

		PANIC;

		break;

		}

	LOG("Device State => %S", &iDevStatus);

	ScheduleDraw();

	}

void CUsbViewer::SetIdPin(TInt aIdPin)

	{

	switch(aIdPin)

		{

	case 0:

		iIdPin =

    		//  12345

			_L("-    ");

		break;

	case 1:

		iIdPin =

    		//  12345

			_L("+    ");

		break;

	default:

		PANIC;

		break;

		}

	LOG("Id Pin => %S", &iIdPin);

	ScheduleDraw();

	}

void CUsbViewer::SetVBus(TInt aVBus)

	{

	switch(aVBus)

		{

	case 0:

		iVBus =

    		//  12345

			_L("-    ");

		break;

	case 1:

		iVBus =

    		//  12345

			_L("+    ");

		break;

	default:

		PANIC;

		break;

		}

	LOG("VBus => %S", &iVBus);

	ScheduleDraw();

	}

void CUsbViewer::SetConnectionIdle(TInt aConnIdle)

	{

	switch(aConnIdle)

		{

	case 0:

		iConnIdle =

    		//  12345

			_L("-    ");

		break;

	case 1:

		iConnIdle =

    		//  12345

			_L("+    ");

		break;

	default:

		PANIC;

		break;

		}

	LOG("Connection Idle => %S", &iConnIdle);

	ScheduleDraw();

	}

void CUsbViewer::SetOtgState(TInt aOtgState)

	{

	switch(aOtgState)

		{

	case 0x01:

		iOtgState =

    		//  123456789012

			_L("Reset       ");

		break;

	case 0x02:

		iOtgState =

    		//  123456789012

			_L("A-Idle      ");

		break;

	case 0x04:

		iOtgState =

    		//  123456789012

			_L("A-Host      ");

		break;

	case 0x08:

		iOtgState =

    		//  1234567890123

			_L("A-Peripheral");

		break;

	case 0x10:

		iOtgState =

    		//  123456789012

			_L("A-Vbus Error");

		break;

	case 0x20:

		iOtgState =

    		//  123456789012

			_L("B-Idle      ");

		break;

	case 0x40:

		iOtgState =

    		//  1234567890123

			_L("B-Peripheral");

		break;

	case 0x80:

		iOtgState =

    		//  1234567890123

			_L("B-Host      ");

		break;

	default:

		iOtgState =

    		//  1234567890123

			_L("Don't Panic!");

		break;

		}

	LOG("OTG State => %S", &iOtgState);

	ScheduleDraw();

	}

void CUsbViewer::SetDriverLoading(TFdfDriverLoadingState aDriverLoading)

	{

	switch(aDriverLoading)

		{

	case EUnknown:

		iDriverLoading =

			//  123

			_L("???");

		break;

	case EDisabled:

		iDriverLoading =

			//  123

			_L("Off");

		break;

	case EEnabled:

		iDriverLoading =

			//  123

			_L("On ");

		break;

	default:

		PANIC;

		break;

		}

	LOG("Driver Loading => %S", &iDriverLoading);

	ScheduleDraw();

	}

void CUsbViewer::SetAttachedDevices(TUint aAttachedDevices)

	{

	if(aAttachedDevices > 999)

		{

		iAttachedDevices =

			//  123