1 /*

     2 * Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    17 

    18 #include "usbtestconsole.h"

    19 

    20 #include <e32cons.h>

    21 #include <e32debug.h>

    22 

    23 #include <d32otgdi_errors.h>

    24 #include <d32usbdi_errors.h>

    25 #include <d32usbdi.h>

    26 

    27 #include <usb/usbshared.h>

    28 

    29 static TBool verbose = EFalse;

    30 

    31 const TUint KTimerAWaitBConnect = 30*1000000;  

    32 

    33 #define PANIC Panic(__LINE__)

    34 

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

    36 

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

    38 

    39 void Panic(TInt aLine)

    40 	{

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

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

    43 	}

    44 

    45 _LIT(KArgVerbose, "VERBOSE");

    46 

    47 void RunConsoleL()

    48 	{

    49 	TInt cmdLineLength(User::CommandLineLength());

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

    51 	TPtr cmdLinePtr = cmdLine->Des();

    52 	User::CommandLine(cmdLinePtr);

    53 

    54 	TLex args(*cmdLine);

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

    56 	

    57 	// first arg is the exe name, skip it

    58 	TPtrC cmdToken = args.NextToken();

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

    60 	*tc = cmdToken;

    61 	

    62 	while (tc->Length())

    63 		{

    64 		TInt pos = tc->FindF(KArgVerbose);

    65 		

    66 		if ( pos != KErrNotFound )

    67 			{ 

    68 			verbose = ETrue;

    69 			}

    70 		

    71 		// next parameter

    72 		*tc = args.NextToken();

    73 		}

    74 	CleanupStack::PopAndDestroy(tc);

    75 	CleanupStack::PopAndDestroy(cmdLine);

    76 

    77 	CUsbTestConsole* console = CUsbTestConsole::NewLC();

    78 	console->StartL();

    79 	CleanupStack::PopAndDestroy(console);

    80 	}

    81 

    82 TInt E32Main()

    83 	{

    84 	__UHEAP_MARK;

    85 	CTrapCleanup* cleanup = CTrapCleanup::New();

    86 	CActiveScheduler* activeScheduler = new CActiveScheduler;

    87 	TInt err = KErrNoMemory;

    88 	if(cleanup && activeScheduler)

    89 		{

    90 		CActiveScheduler::Install(activeScheduler);

    91 

    92 		TRAP(err,RunConsoleL());

    93 		}

    94 	delete activeScheduler;

    95 	delete cleanup;

    96 	__UHEAP_MARKEND;

    97 	return err;

    98 	}

    99 

   100 XUsbTestConsoleEvent::~XUsbTestConsoleEvent()

   101 	{

   102 	iLink.Deque();

   103 	iEvent.Close();

   104 	}

   105 	

   106 	

   107 	

   108 	

   109 CUsbTestConsoleKeys* CUsbTestConsoleKeys::NewL(CUsbTestConsole& aTestConsole)

   110 	{

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

   112 	CleanupStack::PushL(self);

   113 	self->ConstructL();

   114 	CleanupStack::Pop(self);

   115 	return self;

   116 	}

   117 

   118 CUsbTestConsoleKeys::~CUsbTestConsoleKeys()

   119 	{

   120 	Cancel();

   121 

   122 	TDblQueIter<CUsbTestConsoleTextEntryBase> iter(iEntryConsoles);

   123 	CUsbTestConsoleTextEntryBase* event = NULL;

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

   125 		{

   126 		delete event;

   127 		}

   128 		

   129 	delete iUsbManStarter;

   130 	delete iUsbManStoper;

   131 	delete iUsbManTryStarter;

   132 	delete iUsbManTryStoper;

   133 	}

   134 

   135 CUsbTestConsoleKeys::CUsbTestConsoleKeys(CUsbTestConsole& aTestConsole)

   136 	: CActive(EPriorityStandard)

   137 	, iTestConsole(aTestConsole)

   138 	, iEntryConsoles(_FOFF(CUsbTestConsoleTextEntryBase, iLink))

   139 	{

   140 	CActiveScheduler::Add(this);

   141 	}

   142 

   143 void CUsbTestConsoleKeys::ConstructL()

   144 	{

   145 	iTestConsole.iConsole->Read(iStatus);

   146 	SetActive();

   147 	}

   148 

   149 void CUsbTestConsoleKeys::DoCancel()

   150 	{

   151 	iTestConsole.iConsole->ReadCancel();

   152 	}

   153 

   154 void CUsbTestConsoleKeys::RunL()

   155 	{

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

   157 	

   158 	switch(iTestConsole.iConsole->KeyCode())

   159 		{

   160 	case '[':

   161 		{

   162 		RUsb sess;

   163 		TInt err = sess.Connect();

   164 		sess.Close();

   165 		

   166 		User::After(4000000);

   167 		

   168 		err = sess.Connect(); 

   169 

   170 		XUsbTestConsoleEvent* event = NewConsoleEventL();

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

   172 		iTestConsole.NotifyEvent(event);

   173 		

   174 		sess.Close();

   175 		}

   176 		break;

   177 	case 'm':

   178 		{

   179 		TInt val = 1;

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

   181 		XUsbTestConsoleEvent* event = NewConsoleEventL();

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

   183 		iTestConsole.NotifyEvent(event);

   184 		}

   185 		break;

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

   187 

   188 		iTestConsole.ScheduleDraw('H');

   189 		break;

   190 

   191 	case 'q': case 'Q':

   192 		iTestConsole.Stop();

   193 		return;

   194 		

   195 	case 's':

   196 		// Toggle Start

   197 		if(!iUsbManStarter)

   198 			{

   199 			CUsbManStarter::NewL(iUsbManStarter, iTestConsole);

   200 			}

   201 		else

   202 			{

   203 			iUsbManStarter->DestroyL();

   204 			}

   205 		break;

   206 		

   207 	case 'S':

   208 		// Toggle Stop

   209 		if(!iUsbManStoper)

   210 			{

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

   212 			// when we shutdown we also automatically disable loading.

   213 			iTestConsole.Usb().DisableFunctionDriverLoading();

   214 			iFunctionDriverLoading = EFalse;

   215 			iTestConsole.SetDriverLoading(CUsbTestConsole::EDisabled);

   216 

   217 			CUsbManStoper::NewL(iUsbManStoper, iTestConsole);

   218 			}

   219 		else

   220 			{

   221 			iUsbManStoper->DestroyL();

   222 			}

   223 		break;

   224 		

   225 	case 't':

   226 		// Toggle TryStart

   227 		if(!iUsbManTryStarter)

   228 			{

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

   230 			}

   231 		else

   232 			{

   233 			iUsbManTryStarter->DestroyL();

   234 			}

   235 		break;

   236 

   237 	case 'T':

   238 		// Toggle TryStop

   239 		if(!iUsbManTryStoper)

   240 			{

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

   242 			// when we shutdown we also automatically disable loading.

   243 			iTestConsole.Usb().DisableFunctionDriverLoading();

   244 			iFunctionDriverLoading = EFalse;

   245 			iTestConsole.SetDriverLoading(CUsbTestConsole::EDisabled);

   246 

   247 			CUsbManTryStoper::NewL(iUsbManTryStoper, iTestConsole);

   248 			}

   249 		else

   250 			{

   251 			iUsbManTryStoper->DestroyL();

   252 			}

   253 		break;

   254 		

   255 	case 'p': case 'P':

   256 		// Enter personality id

   257 			{

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

   259 			iEntryConsoles.AddLast(*entry);

   260 			}

   261 		break;

   262 		

   263 	case 'c': case 'C':

   264 		// Toggle Control Session

   265 			{

   266 			iControlSession = !iControlSession;

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

   268 			if(err != KErrNone)

   269 				{

   270 				iControlSession = !iControlSession;

   271 				}

   272 			else

   273 				{

   274 				iTestConsole.SetControlSession(iControlSession);

   275 				if(!iControlSession)

   276 					{

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

   278 					// someone else could be altering the state.

   279 					iFunctionDriverLoading = EFalse;

   280                     iTestConsole.SetDriverLoading(CUsbTestConsole::EUnknown);

   281 					}

   282 				}

   283 			XUsbTestConsoleEvent* event = NewConsoleEventL();

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

   285 			iTestConsole.NotifyEvent(event);

   286 			}

   287 		break;

   288 

   289 	case 'b':

   290 		// Bus Request

   291 			{

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

   293 			XUsbTestConsoleEvent* event = NewConsoleEventL();

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

   295 			iTestConsole.NotifyEvent(event);

   296 			}

   297 		break;

   298 

   299 	case 'r':

   300 	    // Respond to SRP

   301 			{

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

   303 			XUsbTestConsoleEvent* event = NewConsoleEventL();

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

   305 			iTestConsole.NotifyEvent(event);

   306 			}

   307 			break;

   308 

   309 	case 'R':

   310 		// Auto-respond to SRP

   311 			{

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

   313 			XUsbTestConsoleEvent* event = NewConsoleEventL();

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

   315 			iTestConsole.NotifyEvent(event);

   316 			}

   317 			break;

   318 			

   319 	case 'x': case 'X':

   320 	    // Clear Bus Error State

   321 			{

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

   323 			XUsbTestConsoleEvent* event = NewConsoleEventL();

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

   325 			iTestConsole.NotifyEvent(event);

   326 			}

   327 			break;

   328 

   329 	case 'B':

   330 		// Bus Drop

   331 			{

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

   333 			XUsbTestConsoleEvent* event = NewConsoleEventL();

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

   335 			iTestConsole.NotifyEvent(event);

   336 			}

   337 		break;

   338 		

   339 	case 'e': case 'E':

   340 			{

   341 			TBool functionDriverLoading = !iFunctionDriverLoading;

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

   343 			TInt err = KErrNone;

   344 			if(functionDriverLoading)

   345 				{

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

   347 				}

   348 			else

   349 				{

   350 				iTestConsole.Usb().DisableFunctionDriverLoading();

   351 				}

   352 

   353 			if(err == KErrNone)

   354 				{

   355 				iFunctionDriverLoading = functionDriverLoading;

   356 				iTestConsole.SetDriverLoading(state);

   357 				}

   358 			XUsbTestConsoleEvent* event = NewConsoleEventL();

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

   360 			iTestConsole.NotifyEvent(event);

   361 			}

   362 		break;

   363 

   364 		case 'A': case 'a': 

   365 			{

   366 			XUsbTestConsoleEvent* event = NewConsoleEventL();

   367 			switch( iTestConsole.iDeviceType )

   368 				{

   369 				case CUsbTestConsole::ELogitechHeadset:

   370 					{

   371 												// 12345678901234567890123456789012345678901234567890123

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

   373 					}

   374 					break;

   375 				case CUsbTestConsole::EGenericDevice:

   376 					{

   377 												// 12345678901234567890123456789012345678901234567890123

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

   379 					}

   380 					break;

   381 				case CUsbTestConsole::ENoDevice:

   382 					{

   383 												// 12345678901234567890123456789012345678901234567890123

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

   385 					}

   386 					break;

   387 				}

   388 			iTestConsole.NotifyEvent(event);

   389 			}

   390 		break;

   391 		

   392 	case 'v': case 'V':

   393 		{

   394 		TBool oldVerbose = verbose;

   395 		

   396 		verbose = ETrue;

   397 		

   398 		if (oldVerbose)

   399 			{

   400 			PNT("Switching Logging Off");

   401 			}

   402 		else

   403 			{

   404 			PNT("Switching Logging On");

   405 			}

   406 		

   407 		verbose = !oldVerbose;

   408 

   409 		break;

   410 		}

   411 		

   412 	default:

   413 		// Unrecognised key

   414 		XUsbTestConsoleEvent* event = NewConsoleEventL();

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

   416 		iTestConsole.NotifyEvent(event);

   417 		break;

   418 		}

   419 	iTestConsole.iConsole->Read(iStatus);

   420 	SetActive();

   421 	}

   422 	

   423 XUsbTestConsoleEvent* CUsbTestConsoleKeys::NewConsoleEventL()

   424 	{

   425 	XUsbTestConsoleEvent* event = new(ELeave) XUsbTestConsoleEvent;

   426 	CleanupStack::PushL(event);

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

   428 	CleanupStack::Pop();

   429 	return event;

   430 	}

   431 	

   432 

   433 

   434 CUsbTestConsole* CUsbTestConsole::NewLC()

   435 	{

   436 	CUsbTestConsole* self = new(ELeave) CUsbTestConsole;

   437 	CleanupStack::PushL(self);

   438 	self->ConstructL();

   439 	return self;

   440 	}

   441 	

   442 CUsbTestConsole::~CUsbTestConsole()

   443 	{

   444 	PNT("Closing Console");

   445 

   446 	delete iKeys;

   447 

   448 	TDblQueIter<XUsbTestConsoleEvent> iter(iEventList);

   449 	XUsbTestConsoleEvent* event = NULL;

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

   451 		{

   452 		delete event;

   453 		}

   454 

   455 	delete iMessageWatcher;

   456 	delete iHostEventWatcher;

   457 	delete iOtgStateWatcher;

   458 	delete iVBusWatcher;

   459 	delete iIdPinWatcher;

   460 	delete iDeviceStateWatcher;

   461 	delete iServiceStateWatcher;

   462 	delete iTimer;  

   463 

   464 	Cancel();

   465 

   466 	PNT("Closing USB Session");

   467 

   468 	iUsb.Close();

   469 	

   470 	delete iConsole;

   471 	}

   472 

   473 CUsbTestConsole::CUsbTestConsole()

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

   475 	, iHelp(EFalse)

   476 	, iAutoSrpResponse(EFalse)

   477 	, iDeviceType(ENoDevice)

   478 	, iEventList(_FOFF(XUsbTestConsoleEvent, iLink))

   479 	{

   480 	CActiveScheduler::Add(this);

   481 	}

   482 

   483 void CUsbTestConsole::ConstructL()

   484 	{

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

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

   487 	

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

   489 		{

   490         XUsbTestConsoleEvent* nullEvent = new(ELeave) XUsbTestConsoleEvent;

   491 		iEventList.AddFirst(*nullEvent);

   492 		}

   493 

   494 	iServiceStateWatcher = CServiceStateWatcher::NewL(*this);

   495 	iDeviceStateWatcher = CDeviceStateWatcher::NewL(*this);

   496 	iIdPinWatcher = CIdPinWatcher::NewL(*this);

   497 	iVBusWatcher = CVBusWatcher::NewL(*this);

   498     iConnectionIdleWatcher = CConnectionIdleWatcher::NewL(*this);

   499 	iOtgStateWatcher = COtgStateWatcher::NewL(*this);

   500 	iHostEventWatcher = CHostEventWatcher::NewL(*this);

   501 	iMessageWatcher = CMessageWatcher::NewL(*this);

   502 	iTimer = CUsbTestTimer::NewL(*this);  

   503 	SetDriverLoading(EUnknown);

   504 	SetDeviceType(ENoDevice);

   505 	SetAutoSrpResponseState(EFalse);

   506 

   507 	// After everything else, enable interactivity.

   508 	iKeys = CUsbTestConsoleKeys::NewL(*this);

   509 	}

   510 CUsbTestTimer* CUsbTestConsole::Timer() const

   511 	{

   512 	return iTimer;

   513 	}

   514 

   515 

   516 void CUsbTestConsole::StartL()

   517 	{

   518 	// Get everything running

   519 	CActiveScheduler::Start();

   520 	}

   521 	

   522 void CUsbTestConsole::Stop() const

   523 	{

   524 	CActiveScheduler::Stop();

   525 	}

   526 

   527 void CUsbTestConsole::DoCancel()

   528 	{

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

   530 	}

   531 

   532 void CUsbTestConsole::RunL()

   533 	{

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

   535 	Draw();

   536 	}

   537 

   538 void CUsbTestConsole::ScheduleDraw(TUint aKey)

   539 	{

   540 	if(!IsActive())

   541 		{

   542 		iHelp = (aKey=='H') ? !iHelp : EFalse;

   543 		SetActive();

   544 		TRequestStatus* status = &iStatus;

   545 		User::RequestComplete(status, KErrNone);

   546 

   547 		TSize size = iConsole->ScreenSize();

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

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

   550 		}

   551 	}

   552 	

   553 RUsb& CUsbTestConsole::Usb()

   554 	{

   555 	return iUsb;

   556 	}

   557 	

   558 void CUsbTestConsole::SetServiceState(TUsbServiceState aServiceState)

   559 	{

   560 	switch(aServiceState)

   561 		{

   562     case EUsbServiceIdle:

   563     	iServStatus =

   564     		//  12345678901

   565 			_L("Idle       ");

   566     	break;

   567 

   568 	case EUsbServiceStarting:

   569     	iServStatus =

   570     		//  12345678901

   571 			_L("Starting   ");

   572 		break;

   573 

   574 	case EUsbServiceStarted:

   575 	    iServStatus =

   576     		//  12345678901

   577 			_L("Started    ");

   578 		break;

   579 

   580 	case EUsbServiceStopping:

   581     	iServStatus =

   582     		//  12345678901

   583 			_L("Stopping   ");

   584 		break;

   585 

   586 	case EUsbServiceFatalError:

   587     	iServStatus =

   588     		//  12345678901

   589 			_L("Error      ");

   590 		break;

   591 

   592 	default:

   593 		PANIC;

   594 		break;

   595 		}

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

   597 	ScheduleDraw('E');

   598 	}

   599 	

   600 void CUsbTestConsole::SetDeviceState(TUsbDeviceState aDeviceState)

   601 	{

   602 	switch(aDeviceState)

   603 		{

   604 	case EUsbDeviceStateUndefined:

   605 		iDevStatus =

   606     		//  12345678901

   607 			_L("Undefined  ");

   608 		break;

   609 

   610 	case EUsbDeviceStateDefault:

   611 		iDevStatus =

   612     		//  12345678901

   613 			_L("Default    ");

   614 		break;

   615 

   616 	case EUsbDeviceStateAttached:

   617 		iDevStatus =

   618     		//  12345678901

   619 			_L("Attached   ");

   620 		break;

   621 

   622 	case EUsbDeviceStatePowered:

   623 		iDevStatus =

   624     		//  12345678901

   625 			_L("Powered    ");

   626 		break;

   627 

   628 	case EUsbDeviceStateConfigured:

   629 		iDevStatus =

   630     		//  12345678901

   631 			_L("Configured ");

   632 		break;

   633 

   634 	case EUsbDeviceStateAddress:

   635 		iDevStatus =

   636     		//  12345678901

   637 			_L("Address    ");

   638 		break;

   639 

   640 	case EUsbDeviceStateSuspended:

   641 		iDevStatus =

   642     		//  12345678901

   643 			_L("Suspended  ");

   644 		break;

   645 

   646 	default:

   647 		PANIC;

   648 		break;

   649 		}

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

   651 	ScheduleDraw('E');

   652 	}

   653 	

   654 void CUsbTestConsole::SetConnectionIdle(TInt aConnectionIdle)

   655 	{

   656 	switch(aConnectionIdle)

   657 		{

   658 	case 0:

   659 		iConnectionIdle =

   660     		//  12345

   661 			_L("Busy ");

   662 		break;

   663 

   664 	case 1:

   665 		iConnectionIdle =

   666     		//  12345

   667 			_L("Idle ");

   668 		break;

   669 

   670 	default:

   671 		PANIC;

   672 		break;

   673 		}

   674 	LOG("ConnectionIdle => %S", &iConnectionIdle);

   675 	ScheduleDraw('E');

   676 	}

   677 

   678 void CUsbTestConsole::SetIdPin(TInt aIdPin)

   679 	{

   680 	switch(aIdPin)

   681 		{

   682     case 0:

   683         iIdPin =

   684     		//  12345

   685 			_L("-    ");

   686 		break;

   687 

   688 	case 1:

   689 		iIdPin =

   690     		//  12345

   691 			_L("+    ");

   692 		break;

   693 

   694 	default:

   695 		PANIC;

   696 		break;

   697 		}

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

   699 	ScheduleDraw('E');

   700 	}

   701 	

   702 void CUsbTestConsole::SetVBus(TInt aVBus)

   703 	{

   704 	switch(aVBus)

   705 		{

   706 	case 0:

   707 		iVBus =

   708     		//  12345

   709 			_L("-    ");

   710 		break;

   711 

   712 	case 1:

   713 		iVBus =

   714     		//  12345

   715 			_L("+    ");

   716 		break;

   717 

   718 	default:

   719 		PANIC;

   720 		break;

   721 		}

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

   723 	ScheduleDraw('E');

   724 	}

   725 

   726 void CUsbTestConsole::SetOtgState(TInt aOtgState)

   727 	{

   728 	switch(aOtgState)

   729 		{

   730 	case 0x01:

   731 		iOtgState =

   732     		//  123456789012

   733 			_L("Reset       ");

   734 		break;

   735 

   736 	case 0x02:

   737 		iOtgState =

   738     		//  123456789012

   739 			_L("A-Idle      ");

   740 		break;

   741 

   742 	case 0x04:

   743 		iOtgState =

   744     		//  123456789012

   745 			_L("A-Host      ");

   746 		break;

   747 

   748 	case 0x08:

   749 		iOtgState =

   750     		//  1234567890123

   751 			_L("A-Peripheral");

   752 		break;

   753 

   754 	case 0x10:

   755 		iOtgState =

   756     		//  123456789012

   757 			_L("A-Vbus Error");

   758 		break;

   759 

   760 	case 0x20:

   761 		iOtgState =

   762     		//  123456789012

   763 			_L("B-Idle      ");

   764 		break;

   765 

   766 	case 0x40:

   767 		iOtgState =

   768     		//  1234567890123

   769 			_L("B-Peripheral");

   770 		break;

   771 

   772 	case 0x80:

   773 		iOtgState =

   774     		//  1234567890123

   775 			_L("B-Host      ");

   776 		break;

   777 		

   778 	default:

   779 		iOtgState =

   780     		//  1234567890123

   781 			_L("Don't Panic!");

   782 		break;

   783 		}

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

   785 	ScheduleDraw('E');

   786 	}

   787 

   788 void CUsbTestConsole::SetDriverLoading(TFdfDriverLoadingState aDriverLoading)

   789 	{

   790 	switch(aDriverLoading)

   791 		{

   792 	case EUnknown:

   793 		iDriverLoading =

   794 			//  123

   795 			_L("???");

   796 		break;

   797 	case EDisabled:

   798 		iDriverLoading =

   799 			//  123

   800 			_L("Off");

   801 		break;

   802 	case EEnabled:

   803 		iDriverLoading =

   804 			//  123

   805 			_L("On ");

   806 		break;

   807 	default:

   808 		PANIC;

   809 		break;

   810 		}

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

   812 	ScheduleDraw('E');

   813 	}

   814 	

   815 void CUsbTestConsole::SetAttachedDevices(TUint aAttachedDevices)

   816 	{

   817 	if(aAttachedDevices > 999)

   818 		{

   819 		iAttachedDevices =

   820 			//  123

   821 			_L("xxx");

   822 		}

   823 	else

   824 		{

   825 		iAttachedDevices.NumFixedWidthUC(aAttachedDevices, EDecimal, 3);

   826 		}

   827 	LOG("Attached Devices => %S", &iAttachedDevices);

   828 	ScheduleDraw('E');

   829 	}

   830 	

   831 void CUsbTestConsole::SetControlSession(TBool aControl)

   832 	{

   833 	if(aControl)

   834 		{

   835 		iControlSession =

   836 			//  1234567

   837 			_L("Control");

   838 		}

   839 	else

   840 		{

   841 		iControlSession =

   842 			//  1234567

   843 			_L("       ");

   844 		}

   845 	LOG("Control Session => [%d]", aControl);

   846 	ScheduleDraw('E');

   847 	}

   848 

   849 void CUsbTestConsole::SetDeviceType(TDeviceType aDeviceType)

   850 	{

   851 	iDeviceType = aDeviceType;

   852 

   853 	switch ( aDeviceType )

   854 		{

   855 	case ENoDevice:

   856 		iAttachedDevice =

   857 			//  12345

   858 			_L("     ");

   859 		break;

   860 	case EGenericDevice:

   861 		iAttachedDevice =

   862 			//  12345

   863 			_L("<   >");

   864 		break;

   865 	case ELogitechHeadset:

   866 		iAttachedDevice =

   867 			//  12345

   868 			_L("<<A>>");

   869 		break;

   870 		}

   871 	LOG("Audio Device => [%S]", &iAttachedDevice);

   872 	ScheduleDraw('E');

   873 	}

   874 	

   875 TBool CUsbTestConsole::GetAutoSrpResponseState()

   876 	{

   877 	return iAutoSrpResponse;

   878 	}

   879 	

   880 void CUsbTestConsole::SetAutoSrpResponseState(TBool aAutoSrpResponse)

   881 	{

   882 	iAutoSrpResponse = aAutoSrpResponse;

   883 	

   884 	if ( aAutoSrpResponse )

   885 		{

   886 		iSrpState = _L("Auto");

   887 		}

   888 	else

   889 		{

   890 		iSrpState = _L("    ");

   891 		}

   892 	}

   893 

   894 void CUsbTestConsole::NotifyEvent(XUsbTestConsoleEvent* aEvent)

   895 	{

   896 	__ASSERT_ALWAYS(aEvent, PANIC);

   897 	__ASSERT_ALWAYS(aEvent->iEvent.Length() <= KNumCharactersOnLine, PANIC);

   898 

   899 	iEventList.AddFirst(*aEvent);

   900 	delete iEventList.Last();

   901 	LOG("Event => %S", &(aEvent->iEvent));

   902 	ScheduleDraw('E');

   903 	}

   904 

   905 void CUsbTestConsole::Draw()

   906 	{

   907 	iConsole->ClearScreen();

   908 	

   909 	// First line is the server version number (and session state)

   910 	TVersionName versionName = iVersion.Name();

   911 	iConsole->Printf(_L(

   912 //          1         2         3         4         5

   913 // 12345678901234567890123456789012345678901234567890123

   914   "Server Version: %S   %S\n"

   915 	),

   916 	&versionName, &iControlSession

   917 	);

   918 

   919 	// Print "dash board"

   920 	iConsole->Printf(_L(

   921 //          1         2         3         4         5

   922 // 12345678901234567890123456789012345678901234567890123

   923   "Device              OTG          Host          "L"%S\n"

   924 //          12345678901        12345                123

   925  L"Service: %S"      L"Id Pin: %S"L"Driver Loading: %S\n"

   926  L"Device:  %S"      L"V. Bus: %S"L"Attached Devs:  %S\n"

   927  //           1234567890123           12345

   928  L"OTG State: %S "        L"Device: %S " L"SRP: %S\n"

   929 	),

   930 	&iConnectionIdle,

   931     &iServStatus, &iIdPin, &iDriverLoading,

   932 	&iDevStatus, &iVBus, &iAttachedDevices,

   933 	&iOtgState, &iAttachedDevice, &iSrpState

   934 	);

   935 

   936 	if (iHelp)

   937 		{

   938 		//                     12345678901234567890123456789012345678901234567890123

   939 		iConsole->Printf(_L("\nHelp:Available Command Selections"));

   940 		iConsole->Printf(_L("\n"));

   941 		iConsole->Printf(_L("\n '?'/'h'/'H' = Help (show these menu commands)"));

   942 		iConsole->Printf(_L("\n 'v'/'V' = Toggle 'verbose' logging"));

   943 		iConsole->Printf(_L("\n 'q'/'Q' = Quit application"));

   944 		iConsole->Printf(_L("\n 'c'/'C' = Toggle control session"));

   945 		iConsole->Printf(_L("\n 's' = Start()           'S' = Stop()"));

   946 		iConsole->Printf(_L("\n 't' = TryStart()        'T' = TryStop()"));

   947 		iConsole->Printf(_L("\n 'p'/'P' = Enter personality number (for TryStart())"));

   948 		iConsole->Printf(_L("\n 'e'/'E' = Toggle 'enable driver loading'"));

   949 		iConsole->Printf(_L("\n 'b' = BusRequest()      'B' = BusDrop()"));

   950 		iConsole->Printf(_L("\n 'r' = Respond (positively) to SRP"));

   951 		iConsole->Printf(_L("\n 'R' = Toggle SRP Auto-Response"));

   952 		iConsole->Printf(_L("\n 'x'/'X' = Clear Bus Error (A_VBUS_ERR)"));

   953 		iConsole->Printf(_L("\n 'a'/'A' = Check audio capability"));

   954 		iConsole->Printf(_L("\n '[' = Perform USBMAN test"));

   955 		}

   956 	else

   957 		{

   958 		// Events...

   959 		TDblQueIter<XUsbTestConsoleEvent> iter(iEventList);

   960 		XUsbTestConsoleEvent* event = NULL;

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

   962 			{

   963 			iConsole->Printf(_L("\n"));

   964 			iConsole->Printf(event->iEvent.Left(KNumCharactersOnLine-1));

   965 			}

   966 		}

   967 	}

   968 	

   969 	

   970 

   971 CUsbTestConsoleTextEntryBase::CUsbTestConsoleTextEntryBase()

   972 	: CActive(EPriorityNormal)

   973 	{

   974 	CActiveScheduler::Add(this);

   975 	}

   976 

   977 CUsbTestConsoleTextEntryBase::~CUsbTestConsoleTextEntryBase()

   978 	{

   979 	Cancel();

   980 	iLink.Deque();

   981 	delete iEntryConsole;

   982 	iChars.Close();

   983 	}

   984 

   985 void CUsbTestConsoleTextEntryBase::ConstructL(const TDesC& aEntryField)

   986 	{

   987 	User::LeaveIfError(iChars.Create(KMaxNumOfChars));

   988 	iEntryConsole = Console::NewL(_L("UsbTestConsole Entry Console"), TSize(-1,-1));

   989 	iEntryConsole->Printf(aEntryField);

   990 	iEntryConsole->Printf(_L(": "));

   991 	iEntryConsole->Read(iStatus);

   992 	SetActive();

   993 	}

   994 

   995 void CUsbTestConsoleTextEntryBase::DoCancel()

   996 	{

   997 	iEntryConsole->ReadCancel();

   998 	}

   999 

  1000 void CUsbTestConsoleTextEntryBase::RunL()

  1001 	{

  1002 	TKeyCode code = iEntryConsole->KeyCode();

  1003 	switch(code)

  1004 		{

  1005 		case EKeyEnter:

  1006 				{

  1007 				TRAPD(err, ConvertAndSetL());

  1008 				if(err == KErrNone)

  1009 					{

  1010 					delete this;

  1011 					return;

  1012 					}

  1013 				}

  1014 			break;

  1015 		case EKeyEscape:

  1016 			delete this;

  1017 			return;

  1018 		case EKeyBackspace:

  1019 			if(iChars.Length() > 0)

  1020 				{

  1021 				iEntryConsole->SetCursorPosRel(TPoint(-1, 0));

  1022 				iEntryConsole->ClearToEndOfLine();

  1023 				iChars.SetLength(iChars.Length()-1);

  1024 				}

  1025 			break;

  1026 		default:

  1027 			iChars.Append(code);

  1028 			iEntryConsole->Printf(_L("%c"), code);

  1029 			break;

  1030 		}

  1031 	iEntryConsole->Read(iStatus);

  1032 	SetActive();

  1033 	}

  1034 

  1035 

  1036 template<typename T>

  1037 CUsbTestConsoleTextEntry<T>* CUsbTestConsoleTextEntry<T>::NewL(T& aValue, const TDesC& aEntryField)

  1038 	{

  1039 	CUsbTestConsoleTextEntry<T>* self = new(ELeave) CUsbTestConsoleTextEntry<T>(aValue);

  1040 	CleanupStack::PushL(self);

  1041 	self->ConstructL(aEntryField);

  1042 	CleanupStack::Pop(self);

  1043 	return self;

  1044 	}

  1045 

  1046 template<typename T>

  1047 CUsbTestConsoleTextEntry<T>::~CUsbTestConsoleTextEntry()

  1048 	{

  1049 	}

  1050 

  1051 template<typename T>

  1052 CUsbTestConsoleTextEntry<T>::CUsbTestConsoleTextEntry(T& aValue)

  1053 	: CUsbTestConsoleTextEntryBase()

  1054 	, iValue(aValue)

  1055 	{

  1056 	}

  1057 

  1058 template<>

  1059 void CUsbTestConsoleTextEntry<TUint>::ConvertAndSetL()

  1060 	{

  1061 	TLex lex(iChars);

  1062 	

  1063 	lex.SkipSpaceAndMark();

  1064 

  1065 	TBool hex = ETrue;

  1066 	if (lex.Get() != '0' || lex.Get() != 'x')

  1067 		{

  1068 		lex.UnGetToMark();

  1069 		hex = EFalse;

  1070 		}

  1071 		

  1072 	TUint val;

  1073 	TRadix rad = hex ? EHex : EDecimal;

  1074 	User::LeaveIfError(lex.Val(val, rad));

  1075 	

  1076 	iValue = val;

  1077 	}

  1078 	

  1079 template<>

  1080 void CUsbTestConsoleTextEntry<TInt>::ConvertAndSetL()

  1081 	{

  1082 	TLex lex(iChars);

  1083 	

  1084 	lex.SkipSpaceAndMark();

  1085 

  1086 	TUint val;

  1087 	User::LeaveIfError(lex.Val(val, EDecimal));

  1088 	

  1089 	iValue = val;

  1090 	}

  1091 

  1092 

  1093 

  1094 

  1095 

  1096 

  1097 

  1098 

  1099 	

  1100 

  1101 

  1102 CEventNotifier::CEventNotifier(TInt aPriority)

  1103 	: CActive(aPriority)

  1104 	{

  1105 	}

  1106 

  1107 XUsbTestConsoleEvent* CEventNotifier::NewConsoleEventL()

  1108 	{

  1109 	XUsbTestConsoleEvent* event = new(ELeave) XUsbTestConsoleEvent;

  1110 	CleanupStack::PushL(event);

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

  1112 	CleanupStack::Pop();

  1113 	return event;

  1114 	}

  1115 

  1116 void CEventNotifier::RunL()

  1117 	{

  1118 	DoRunL(NewConsoleEventL());

  1119 	}

  1120 

  1121 

  1122 CServiceStateWatcher* CServiceStateWatcher::NewL(CUsbTestConsole& aTestConsole)

  1123 	{

  1124 	CServiceStateWatcher* self = new(ELeave) CServiceStateWatcher(aTestConsole);

  1125 	CleanupStack::PushL(self);

  1126 	self->ConstructL();

  1127 	CleanupStack::Pop(self);

  1128 	return self;

  1129 	}

  1130 CServiceStateWatcher::~CServiceStateWatcher()

  1131 	{

  1132 	Cancel();

  1133 	}

  1134