diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgrtest/usbtestconsole/usbtestconsole.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgrtest/usbtestconsole/usbtestconsole.cpp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,2192 @@ +/* +* 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 +#include + +#include +#include +#include + +#include + +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 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::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 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; iScreenSize(); + iConsole->SetCursorPosAbs(TPoint(size.iWidth-1, 0)); + iConsole->Write(_L("*")); + } + } + +RUsb& CUsbTestConsole::Usb() + { + return iUsb; + } + +void CUsbTestConsole::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('E'); + } + +void CUsbTestConsole::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('E'); + } + +void CUsbTestConsole::SetConnectionIdle(TInt aConnectionIdle) + { + switch(aConnectionIdle) + { + case 0: + iConnectionIdle = + // 12345 + _L("Busy "); + break; + + case 1: + iConnectionIdle = + // 12345 + _L("Idle "); + break; + + default: + PANIC; + break; + } + LOG("ConnectionIdle => %S", &iConnectionIdle); + ScheduleDraw('E'); + } + +void CUsbTestConsole::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('E'); + } + +void CUsbTestConsole::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('E'); + } + +void CUsbTestConsole::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('E'); + } + +void CUsbTestConsole::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('E'); + } + +void CUsbTestConsole::SetAttachedDevices(TUint aAttachedDevices) + { + if(aAttachedDevices > 999) + { + iAttachedDevices = + // 123 + _L("xxx"); + } + else + { + iAttachedDevices.NumFixedWidthUC(aAttachedDevices, EDecimal, 3); + } + LOG("Attached Devices => %S", &iAttachedDevices); + ScheduleDraw('E'); + } + +void CUsbTestConsole::SetControlSession(TBool aControl) + { + if(aControl) + { + iControlSession = + // 1234567 + _L("Control"); + } + else + { + iControlSession = + // 1234567 + _L(" "); + } + LOG("Control Session => [%d]", aControl); + ScheduleDraw('E'); + } + +void CUsbTestConsole::SetDeviceType(TDeviceType aDeviceType) + { + iDeviceType = aDeviceType; + + switch ( aDeviceType ) + { + case ENoDevice: + iAttachedDevice = + // 12345 + _L(" "); + break; + case EGenericDevice: + iAttachedDevice = + // 12345 + _L("< >"); + break; + case ELogitechHeadset: + iAttachedDevice = + // 12345 + _L("<>"); + break; + } + LOG("Audio Device => [%S]", &iAttachedDevice); + ScheduleDraw('E'); + } + +TBool CUsbTestConsole::GetAutoSrpResponseState() + { + return iAutoSrpResponse; + } + +void CUsbTestConsole::SetAutoSrpResponseState(TBool aAutoSrpResponse) + { + iAutoSrpResponse = aAutoSrpResponse; + + if ( aAutoSrpResponse ) + { + iSrpState = _L("Auto"); + } + else + { + iSrpState = _L(" "); + } + } + +void CUsbTestConsole::NotifyEvent(XUsbTestConsoleEvent* aEvent) + { + __ASSERT_ALWAYS(aEvent, PANIC); + __ASSERT_ALWAYS(aEvent->iEvent.Length() <= KNumCharactersOnLine, PANIC); + + iEventList.AddFirst(*aEvent); + delete iEventList.Last(); + LOG("Event => %S", &(aEvent->iEvent)); + ScheduleDraw('E'); + } + +void CUsbTestConsole::Draw() + { + iConsole->ClearScreen(); + + // First line is the server version number (and session state) + TVersionName versionName = iVersion.Name(); + iConsole->Printf(_L( +// 1 2 3 4 5 +// 12345678901234567890123456789012345678901234567890123 + "Server Version: %S %S\n" + ), + &versionName, &iControlSession + ); + + // Print "dash board" + iConsole->Printf(_L( +// 1 2 3 4 5 +// 12345678901234567890123456789012345678901234567890123 + "Device OTG Host "L"%S\n" +// 12345678901 12345 123 + L"Service: %S" L"Id Pin: %S"L"Driver Loading: %S\n" + L"Device: %S" L"V. Bus: %S"L"Attached Devs: %S\n" + // 1234567890123 12345 + L"OTG State: %S " L"Device: %S " L"SRP: %S\n" + ), + &iConnectionIdle, + &iServStatus, &iIdPin, &iDriverLoading, + &iDevStatus, &iVBus, &iAttachedDevices, + &iOtgState, &iAttachedDevice, &iSrpState + ); + + if (iHelp) + { + // 12345678901234567890123456789012345678901234567890123 + iConsole->Printf(_L("\nHelp:Available Command Selections")); + iConsole->Printf(_L("\n")); + iConsole->Printf(_L("\n '?'/'h'/'H' = Help (show these menu commands)")); + iConsole->Printf(_L("\n 'v'/'V' = Toggle 'verbose' logging")); + iConsole->Printf(_L("\n 'q'/'Q' = Quit application")); + iConsole->Printf(_L("\n 'c'/'C' = Toggle control session")); + iConsole->Printf(_L("\n 's' = Start() 'S' = Stop()")); + iConsole->Printf(_L("\n 't' = TryStart() 'T' = TryStop()")); + iConsole->Printf(_L("\n 'p'/'P' = Enter personality number (for TryStart())")); + iConsole->Printf(_L("\n 'e'/'E' = Toggle 'enable driver loading'")); + iConsole->Printf(_L("\n 'b' = BusRequest() 'B' = BusDrop()")); + iConsole->Printf(_L("\n 'r' = Respond (positively) to SRP")); + iConsole->Printf(_L("\n 'R' = Toggle SRP Auto-Response")); + iConsole->Printf(_L("\n 'x'/'X' = Clear Bus Error (A_VBUS_ERR)")); + iConsole->Printf(_L("\n 'a'/'A' = Check audio capability")); + iConsole->Printf(_L("\n '[' = Perform USBMAN test")); + } + else + { + // Events... + TDblQueIter iter(iEventList); + XUsbTestConsoleEvent* event = NULL; + while((event = iter++) != NULL) + { + iConsole->Printf(_L("\n")); + iConsole->Printf(event->iEvent.Left(KNumCharactersOnLine-1)); + } + } + } + + + +CUsbTestConsoleTextEntryBase::CUsbTestConsoleTextEntryBase() + : CActive(EPriorityNormal) + { + CActiveScheduler::Add(this); + } + +CUsbTestConsoleTextEntryBase::~CUsbTestConsoleTextEntryBase() + { + Cancel(); + iLink.Deque(); + delete iEntryConsole; + iChars.Close(); + } + +void CUsbTestConsoleTextEntryBase::ConstructL(const TDesC& aEntryField) + { + User::LeaveIfError(iChars.Create(KMaxNumOfChars)); + iEntryConsole = Console::NewL(_L("UsbTestConsole Entry Console"), TSize(-1,-1)); + iEntryConsole->Printf(aEntryField); + iEntryConsole->Printf(_L(": ")); + iEntryConsole->Read(iStatus); + SetActive(); + } + +void CUsbTestConsoleTextEntryBase::DoCancel() + { + iEntryConsole->ReadCancel(); + } + +void CUsbTestConsoleTextEntryBase::RunL() + { + TKeyCode code = iEntryConsole->KeyCode(); + switch(code) + { + case EKeyEnter: + { + TRAPD(err, ConvertAndSetL()); + if(err == KErrNone) + { + delete this; + return; + } + } + break; + case EKeyEscape: + delete this; + return; + case EKeyBackspace: + if(iChars.Length() > 0) + { + iEntryConsole->SetCursorPosRel(TPoint(-1, 0)); + iEntryConsole->ClearToEndOfLine(); + iChars.SetLength(iChars.Length()-1); + } + break; + default: + iChars.Append(code); + iEntryConsole->Printf(_L("%c"), code); + break; + } + iEntryConsole->Read(iStatus); + SetActive(); + } + + +template +CUsbTestConsoleTextEntry* CUsbTestConsoleTextEntry::NewL(T& aValue, const TDesC& aEntryField) + { + CUsbTestConsoleTextEntry* self = new(ELeave) CUsbTestConsoleTextEntry(aValue); + CleanupStack::PushL(self); + self->ConstructL(aEntryField); + CleanupStack::Pop(self); + return self; + } + +template +CUsbTestConsoleTextEntry::~CUsbTestConsoleTextEntry() + { + } + +template +CUsbTestConsoleTextEntry::CUsbTestConsoleTextEntry(T& aValue) + : CUsbTestConsoleTextEntryBase() + , iValue(aValue) + { + } + +template<> +void CUsbTestConsoleTextEntry::ConvertAndSetL() + { + TLex lex(iChars); + + lex.SkipSpaceAndMark(); + + TBool hex = ETrue; + if (lex.Get() != '0' || lex.Get() != 'x') + { + lex.UnGetToMark(); + hex = EFalse; + } + + TUint val; + TRadix rad = hex ? EHex : EDecimal; + User::LeaveIfError(lex.Val(val, rad)); + + iValue = val; + } + +template<> +void CUsbTestConsoleTextEntry::ConvertAndSetL() + { + TLex lex(iChars); + + lex.SkipSpaceAndMark(); + + TUint val; + User::LeaveIfError(lex.Val(val, EDecimal)); + + iValue = val; + } + + + + + + + + + + + +CEventNotifier::CEventNotifier(TInt aPriority) + : CActive(aPriority) + { + } + +XUsbTestConsoleEvent* CEventNotifier::NewConsoleEventL() + { + XUsbTestConsoleEvent* event = new(ELeave) XUsbTestConsoleEvent; + CleanupStack::PushL(event); + User::LeaveIfError(event->iEvent.Create(CUsbTestConsole::KNumCharactersOnLine-1)); + CleanupStack::Pop(); + return event; + } + +void CEventNotifier::RunL() + { + DoRunL(NewConsoleEventL()); + } + + +CServiceStateWatcher* CServiceStateWatcher::NewL(CUsbTestConsole& aTestConsole) + { + CServiceStateWatcher* self = new(ELeave) CServiceStateWatcher(aTestConsole); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } +CServiceStateWatcher::~CServiceStateWatcher() + { + Cancel(); + } + +CServiceStateWatcher::CServiceStateWatcher(CUsbTestConsole& aTestConsole) + : CEventNotifier(EPriorityStandard) + , iTestConsole(aTestConsole) + , iServiceState(EUsbServiceIdle) + { + CActiveScheduler::Add(this); + } + +void CServiceStateWatcher::ConstructL() + { + iTestConsole.Usb().ServiceStateNotification(iServiceState, iStatus); + SetActive(); + + TUsbServiceState serviceState; + User::LeaveIfError(iTestConsole.Usb().GetServiceState(serviceState)); + iTestConsole.SetServiceState(serviceState); + } + +void CServiceStateWatcher::DoCancel() + { + iTestConsole.Usb().ServiceStateNotificationCancel(); + } + +void CServiceStateWatcher::DoRunL(XUsbTestConsoleEvent* aEvent) + { + iTestConsole.SetServiceState(iServiceState); + TPtrC res(NULL, 0); + _LIT(KIdle, "Idle"); + _LIT(KStarting, "Starting"); + _LIT(KStarted, "Started"); + _LIT(KStopping, "Stopping"); + _LIT(KError, "Error"); + switch(iServiceState) + { + case EUsbServiceIdle: + res.Set(KIdle); + break; + case EUsbServiceStarting: + res.Set(KStarting); + break; + case EUsbServiceStarted: + res.Set(KStarted); + break; + case EUsbServiceStopping: + res.Set(KStopping); + break; + case EUsbServiceFatalError: + res.Set(KError); + break; + default: + PANIC; + break; + } + + iTestConsole.Usb().ServiceStateNotification(iServiceState, iStatus); + SetActive(); + + aEvent->iEvent.AppendFormat(_L("D:ServiceState [%S]"), &res); + iTestConsole.NotifyEvent(aEvent); + + // Seems like there can be race conditions + TUsbServiceState serviceState; + User::LeaveIfError(iTestConsole.Usb().GetServiceState(serviceState)); + + iTestConsole.SetServiceState(serviceState); + } + + +CDeviceStateWatcher* CDeviceStateWatcher::NewL(CUsbTestConsole& aTestConsole) + { + CDeviceStateWatcher* self = new(ELeave) CDeviceStateWatcher(aTestConsole); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } +CDeviceStateWatcher::~CDeviceStateWatcher() + { + Cancel(); + } + +CDeviceStateWatcher::CDeviceStateWatcher(CUsbTestConsole& aTestConsole) + : CEventNotifier(EPriorityStandard) + , iTestConsole(aTestConsole) + { + CActiveScheduler::Add(this); + } + +void CDeviceStateWatcher::ConstructL() + { + iTestConsole.Usb().DeviceStateNotification(0xffffffff, iDeviceState, iStatus); + SetActive(); + + TUsbDeviceState deviceState; + User::LeaveIfError(iTestConsole.Usb().GetDeviceState(deviceState)); + iTestConsole.SetDeviceState(deviceState); + } + +void CDeviceStateWatcher::DoCancel() + { + iTestConsole.Usb().DeviceStateNotificationCancel(); + } + +void CDeviceStateWatcher::DoRunL(XUsbTestConsoleEvent* aEvent) + { + iTestConsole.SetDeviceState(iDeviceState); + TPtrC res(NULL, 0); + _LIT(KUndefined, "Undefined"); + _LIT(KDefault, "Default"); + _LIT(KAttached, "Attached"); + _LIT(KPowered, "Powered"); + _LIT(KConfigured, "Configured"); + _LIT(KAddress, "Address"); + _LIT(KSuspended, "Suspended"); + switch(iDeviceState) + { + case EUsbDeviceStateUndefined: + res.Set(KUndefined); + break; + case EUsbDeviceStateDefault: + res.Set(KDefault); + break; + case EUsbDeviceStateAttached: + res.Set(KAttached); + break; + case EUsbDeviceStatePowered: + res.Set(KPowered); + break; + case EUsbDeviceStateConfigured: + res.Set(KConfigured); + break; + case EUsbDeviceStateAddress: + res.Set(KAddress); + break; + case EUsbDeviceStateSuspended: + res.Set(KSuspended); + break; + default: + PANIC; + break; + } + + iTestConsole.Usb().DeviceStateNotification(0xffffffff, iDeviceState, iStatus); + SetActive(); + + aEvent->iEvent.AppendFormat(_L("D:DeviceState [%S]"), &res); + iTestConsole.NotifyEvent(aEvent); + + // Seems like there can be race conditions + TUsbDeviceState deviceState; + User::LeaveIfError(iTestConsole.Usb().GetDeviceState(deviceState)); + + iTestConsole.SetDeviceState(deviceState); + } + +CConnectionIdleWatcher* CConnectionIdleWatcher::NewL(CUsbTestConsole& aTestConsole) + { + CConnectionIdleWatcher * self = new(ELeave) CConnectionIdleWatcher (aTestConsole); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } +CConnectionIdleWatcher::~CConnectionIdleWatcher() + { + Cancel(); + iConnectionIdleProp.Close(); + } + +CConnectionIdleWatcher::CConnectionIdleWatcher(CUsbTestConsole& aTestConsole) + : CEventNotifier(EPriorityStandard) + , iTestConsole(aTestConsole) + { + CActiveScheduler::Add(this); + } + +void CConnectionIdleWatcher::ConstructL() + { + User::LeaveIfError(iConnectionIdleProp.Attach(KUidUsbManCategory, KUsbOtgConnectionIdleProperty)); + iConnectionIdleProp.Subscribe(iStatus); + SetActive(); + + TInt val; + TInt err = iConnectionIdleProp.Get(val); + LOG("CConnectionIdleWatcher::ConstructL iConnectionIdleProp.Get(val) => val=%d", val); + User::LeaveIfError(err); + iTestConsole.SetConnectionIdle(val); + } + +void CConnectionIdleWatcher::DoCancel() + { + iConnectionIdleProp.Cancel(); + } + +void CConnectionIdleWatcher::DoRunL(XUsbTestConsoleEvent* aEvent) + { + CleanupStack::PushL(aEvent); + + iConnectionIdleProp.Subscribe(iStatus); + SetActive(); + + TInt val; + User::LeaveIfError(iConnectionIdleProp.Get(val)); + + TPtrC res(NULL, 0); + _LIT(KConnectionIdle, "Idle"); + _LIT(KConnectionBusy, "Busy"); + switch(val) + { + case 0: + res.Set(KConnectionBusy); + break; + + case 1: + res.Set(KConnectionIdle); + break; + + default: + PANIC; + break; + } + CleanupStack::Pop(); + + aEvent->iEvent.AppendFormat(_L("O:ConnectionIdle [%S]"), &res); + iTestConsole.SetConnectionIdle(val); + iTestConsole.NotifyEvent(aEvent); + } + + +CIdPinWatcher* CIdPinWatcher::NewL(CUsbTestConsole& aTestConsole) + { + CIdPinWatcher* self = new(ELeave) CIdPinWatcher(aTestConsole); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } +CIdPinWatcher::~CIdPinWatcher() + { + Cancel(); + iIdPinProp.Close(); + } + +CIdPinWatcher::CIdPinWatcher(CUsbTestConsole& aTestConsole) + : CEventNotifier(EPriorityStandard) + , iTestConsole(aTestConsole) + { + CActiveScheduler::Add(this); + } + +void CIdPinWatcher::ConstructL() + { + User::LeaveIfError(iIdPinProp.Attach(KUidUsbManCategory, KUsbOtgIdPinPresentProperty)); + iIdPinProp.Subscribe(iStatus); + SetActive(); + + TInt val; + TInt err = iIdPinProp.Get(val); + LOG("CIdPinWatcher::ConstructL iIdPinProp.Get(val) => %d",err); + User::LeaveIfError(err); + iTestConsole.SetIdPin(val); + } + +void CIdPinWatcher::DoCancel() + { + iIdPinProp.Cancel(); + } + +void CIdPinWatcher::DoRunL(XUsbTestConsoleEvent* aEvent) + { + CleanupStack::PushL(aEvent); + + iIdPinProp.Subscribe(iStatus); + SetActive(); + + TInt val; + User::LeaveIfError(iIdPinProp.Get(val)); + + TPtrC res(NULL, 0); + _LIT(KIdPinInserted, "Inserted"); + _LIT(KIdPinRemoved, "Removed"); + switch(val) + { + case 0: + res.Set(KIdPinRemoved); + break; + + case 1: + res.Set(KIdPinInserted); + break; + + default: + PANIC; + break; + } + CleanupStack::Pop(); + + aEvent->iEvent.AppendFormat(_L("O:IdPin [%S]"), &res); + iTestConsole.SetIdPin(val); + iTestConsole.NotifyEvent(aEvent); + } + + +CVBusWatcher* CVBusWatcher::NewL(CUsbTestConsole& aTestConsole) + { + CVBusWatcher* self = new(ELeave) CVBusWatcher(aTestConsole); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } +CVBusWatcher::~CVBusWatcher() + { + Cancel(); + iVBusProp.Close(); + } + +CVBusWatcher::CVBusWatcher(CUsbTestConsole& aTestConsole) + : CEventNotifier(EPriorityStandard) + , iTestConsole(aTestConsole) + { + CActiveScheduler::Add(this); + } + +void CVBusWatcher::ConstructL() + { + User::LeaveIfError(iVBusProp.Attach(KUidUsbManCategory, KUsbOtgVBusPoweredProperty)); + iVBusProp.Subscribe(iStatus); + SetActive(); + + TInt val; + User::LeaveIfError(iVBusProp.Get(val)); + iTestConsole.SetVBus(val); + } + +void CVBusWatcher::DoCancel() + { + iVBusProp.Cancel(); + } + +void CVBusWatcher::DoRunL(XUsbTestConsoleEvent* aEvent) + { + CleanupStack::PushL(aEvent); + + iVBusProp.Subscribe(iStatus); + SetActive(); + + TInt val; + User::LeaveIfError(iVBusProp.Get(val)); + + TPtrC res(NULL, 0); + _LIT(KVBusRaised, "Raised"); + _LIT(KVBusDropped, "Dropped"); + switch(val) + { + case 0: + { + if ( iTestConsole.GetAutoSrpResponseState() ) + { + (iTestConsole.Timer())->Cancel(); + } + res.Set(KVBusDropped); + break; + } + case 1: + res.Set(KVBusRaised); + break; + + default: + PANIC; + break; + } + CleanupStack::Pop(); + + aEvent->iEvent.AppendFormat(_L("O:VBus [%S]"), &res); + iTestConsole.SetVBus(val); + iTestConsole.NotifyEvent(aEvent); + } + +COtgStateWatcher* COtgStateWatcher::NewL(CUsbTestConsole& aTestConsole) + { + COtgStateWatcher* self = new(ELeave) COtgStateWatcher(aTestConsole); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +COtgStateWatcher::~COtgStateWatcher() + { + Cancel(); + iOtgStateProp.Close(); + } + +COtgStateWatcher::COtgStateWatcher(CUsbTestConsole& aTestConsole) + : CEventNotifier(EPriorityStandard) + , iTestConsole(aTestConsole) + { + CActiveScheduler::Add(this); + } + +void COtgStateWatcher::ConstructL() + { + User::LeaveIfError(iOtgStateProp.Attach(KUidUsbManCategory, KUsbOtgStateProperty)); + iOtgStateProp.Subscribe(iStatus); + SetActive(); + + TInt val; + User::LeaveIfError(iOtgStateProp.Get(val)); + iTestConsole.SetOtgState(val); + } + +void COtgStateWatcher::DoCancel() + { + iOtgStateProp.Cancel(); + } + +void COtgStateWatcher::DoRunL(XUsbTestConsoleEvent* aEvent) + { + CleanupStack::PushL(aEvent); + + iOtgStateProp.Subscribe(iStatus); + SetActive(); + + TInt val; + User::LeaveIfError(iOtgStateProp.Get(val)); + + TPtrC res(NULL, 0); + + _LIT(KReset, "Reset" ); + + _LIT(KAIdle, "A-Idle" ); + _LIT(KAHost, "A-Host" ); + _LIT(KAPeripheral, "A-Peripheral" ); + _LIT(KABusError, "A-Bus Error" ); + + _LIT(KBIdle, "B-Idle" ); + _LIT(KBPeripheral, "B-Peripheral" ); + _LIT(KBHost, "B-Host" ); + + _LIT(KUnknown, "Unknown" ); + + switch(val) + { + case EUsbOtgStateReset: + res.Set(KReset); + break; + + case EUsbOtgStateAIdle: + res.Set(KAIdle); + break; + + case EUsbOtgStateAHost: + if ( iTestConsole.GetAutoSrpResponseState() ) + { + (iTestConsole.Timer())->Cancel(); + } + res.Set(KAHost); + break; + + case EUsbOtgStateAPeripheral: + res.Set(KAPeripheral); + break; + + case EUsbOtgStateAVbusError: + res.Set(KABusError); + break; + + case EUsbOtgStateBIdle: + res.Set(KBIdle); + break; + + case EUsbOtgStateBPeripheral: + res.Set(KBPeripheral); + break; + + case EUsbOtgStateBHost: + res.Set(KBHost); + break; + + default: + res.Set(KUnknown); + break; + } + CleanupStack::Pop(); + + aEvent->iEvent.AppendFormat(_L("O:OtgState [%S]"), &res); + iTestConsole.SetOtgState(val); + iTestConsole.NotifyEvent(aEvent); + } + +CHostEventWatcher* CHostEventWatcher::NewL(CUsbTestConsole& aTestConsole) + { + CHostEventWatcher* self = new(ELeave) CHostEventWatcher(aTestConsole); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +CHostEventWatcher::~CHostEventWatcher() + { + Cancel(); + } + +CHostEventWatcher::CHostEventWatcher(CUsbTestConsole& aTestConsole) + : CEventNotifier(EPriorityStandard) + , iTestConsole(aTestConsole) + { + CActiveScheduler::Add(this); + } + +void CHostEventWatcher::ConstructL() + { + iTestConsole.Usb().HostEventNotification(iStatus, iDeviceInfo); + SetActive(); + iTestConsole.SetAttachedDevices(0); + } + +void CHostEventWatcher::DoCancel() + { + iTestConsole.Usb().HostEventNotificationCancel(); + } + +void CHostEventWatcher::DoRunL(XUsbTestConsoleEvent* aEvent) + { + CleanupStack::PushL(aEvent); + + switch(iDeviceInfo.iEventType) + { + case EDeviceAttachment: + { + if(iDeviceInfo.iError == KErrNone) + { + User::LeaveIfError(iAttachedDevices.Append(iDeviceInfo.iDeviceId)); + } + aEvent->iEvent.AppendFormat(_L("H:Attach[%08x] Err[%d] VidPid[%04x,%04x]"), iDeviceInfo.iDeviceId, iDeviceInfo.iError, iDeviceInfo.iVid, iDeviceInfo.iPid); + + if ( (iDeviceInfo.iVid == 0x046D) + &&(iDeviceInfo.iPid == 0x0A02) + ) + { + iTestConsole.SetDeviceType(CUsbTestConsole::ELogitechHeadset); + } + else + { + iTestConsole.SetDeviceType(CUsbTestConsole::EGenericDevice); + } + } + break; + + case EDriverLoad: + { + TPtrC res(NULL, 0); + _LIT(KDriverLoadSuccess, "Success"); + _LIT(KDriverLoadPartialSuccess, "Warning"); + _LIT(KDriverLoadFailure, "Failure"); + switch(iDeviceInfo.iDriverLoadStatus) + { + case EDriverLoadSuccess: + res.Set(KDriverLoadSuccess); + break; + case EDriverLoadPartialSuccess: + res.Set(KDriverLoadPartialSuccess); + break; + case EDriverLoadFailure: + res.Set(KDriverLoadFailure); + break; + default: + PANIC; + break; + } + aEvent->iEvent.AppendFormat(_L("H:Load[%08x] Err[%d] Status[%S]"), iDeviceInfo.iDeviceId, iDeviceInfo.iError, &res); + } + break; + + case EDeviceDetachment: + { + aEvent->iEvent.AppendFormat(_L("H:Detach [%08x]"), iDeviceInfo.iDeviceId); + TInt ix = iAttachedDevices.Find(iDeviceInfo.iDeviceId); + if(ix == KErrNotFound) + { + // This is probably caused by starting a new instance of the test console. + break; + } + iAttachedDevices.Remove(ix); + iTestConsole.SetDeviceType(CUsbTestConsole::ENoDevice); + } + break; + default: + PANIC; + break; + } + CleanupStack::Pop(); + iTestConsole.SetAttachedDevices(iAttachedDevices.Count()); + iTestConsole.NotifyEvent(aEvent); + iTestConsole.Usb().HostEventNotification(iStatus, iDeviceInfo); + SetActive(); + } + + +CMessageWatcher* CMessageWatcher::NewL(CUsbTestConsole& aTestConsole) + { + CMessageWatcher* self = new(ELeave) CMessageWatcher(aTestConsole); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } +CMessageWatcher::~CMessageWatcher() + { + Cancel(); + } + +CMessageWatcher::CMessageWatcher(CUsbTestConsole& aTestConsole) + : CEventNotifier(EPriorityStandard) + , iTestConsole(aTestConsole) + { + CActiveScheduler::Add(this); + } + +void CMessageWatcher::ConstructL() + { + iTestConsole.Usb().MessageNotification(iStatus, iMessage); + SetActive(); + } + +void CMessageWatcher::DoCancel() + { + iTestConsole.Usb().MessageNotificationCancel(); + } + +void CMessageWatcher::DoRunL(XUsbTestConsoleEvent* aEvent) + { + TInt err = iStatus.Int(); + + if (err) + { + aEvent->iEvent.AppendFormat(_L("O:Message[%d] Err[%d]"), iMessage, err); + } + else + { + TPtrC text(NULL, 0); + + // OTGDI + _LIT(KMessOtgdiEventQueueOverflow, "O:Event Queue Overflow" ); + _LIT(KMessOtgdiStateQueueOverflow, "O:State Queue Overflow" ); + _LIT(KMessOtgdiMessageQueueOverflow, "O:Message Queue Overflow" ); + _LIT(KMessOtgdiBadState, "O:Bad State" ); + _LIT(KMessOtgdiStackNotStarted, "O:Stack Not Started" ); + _LIT(KMessOtgdiVbusAlreadyRaised, "O:VBUS Already Raised" ); + _LIT(KMessOtgdiSrpForbidden, "O:SRP Forbidden" ); + _LIT(KMessOtgdiBusControlProblem, "O:Bus Control Problem" ); + _LIT(KMessOtgdiVbusPowerUpError, "O:VBUS Power Up Error" ); + _LIT(KMessOtgdiHnpEnableProblem, "O:HNP Enable Problem" ); + _LIT(KMessOtgdiPeriphNotSupported, "O:Peripheral Not Supported" ); + _LIT(KMessOtgdiVbusError, "O:VBUS Error" ); + _LIT(KMessOtgdiSrpTimeout, "O:SRP Timeout" ); + _LIT(KMessOtgdiSrpActive, "O:SRP Already Active" ); + _LIT(KMessOtgdiSrpNotPermitted, "O:SRP Not Permitted" ); + _LIT(KMessOtgdiHnpNotPermitted, "O:HNP Not Permitted" ); + _LIT(KMessOtgdiHnpNotEnabled, "O:HNP Not Enabled" ); + _LIT(KMessOtgdiHnpNotSuspended, "O:HNP Not Suspended" ); + _LIT(KMessOtgdiVbusPowerUpNotPermitted, "O:VBUS Power Up Not Permitted" ); + _LIT(KMessOtgdiVbusPowerDownNotPermitted, "O:VBUS Power Down Not Permitted" ); + _LIT(KMessOtgdiVbusClearErrorNotPermitted, "O:VBUS Clear Error Not Permitted" ); + _LIT(KMessOtgdiHnpNotResponding, "O:HNP Not Responding" ); + _LIT(KMessOtgdiHnpBusDrop, "O:VBUS Drop During HNP!" ); + + // USBDI - Main + + _LIT(KMessUsbdiRequestsPending, "U:Requests Pending" ); + _LIT(KMessUsbdiBadAddress, "U:Bad Address" ); + _LIT(KMessUsbdiNoAddress, "U:No Address" ); + _LIT(KMessUsbdiSetAddrFailed, "U:Set Address Failed" ); + _LIT(KMessUsbdiNoPower, "U:No Power" ); + _LIT(KMessUsbdiTooDeep, "U:Too Deep" ); + _LIT(KMessUsbdiIOError, "U:IO Error" ); + _LIT(KMessUsbdiNotConfigured, "U:Not Configured" ); + _LIT(KMessUsbdiTimeout, "U:Timeout" ); + _LIT(KMessUsbdiStalled, "U:Stalled" ); + _LIT(KMessUsbdiTestFailure, "U:Test Failure" ); + _LIT(KMessUsbdiBadState, "U:Bad State" ); + _LIT(KMessUsbdiDeviceSuspended, "U:Device Suspended" ); + + // USBDI - Descriptors + + _LIT(KMessUsbdiBadDescriptorTopology, "U:Bad Descriptor Topology" ); + + // USBDI - DevMon + + _LIT(KMessUsbdiDeviceRejected, "U:Device Rejected" ); + _LIT(KMessUsbdiDeviceFailed, "U:Device failed" ); + _LIT(KMessUsbdiBadDevice, "U:Bad Device" ); + _LIT(KMessUsbdiBadHubPosition, "U:Bad Hub Position" ); + _LIT(KMessUsbdiBadHub, "U:Bad Hub" ); + _LIT(KMessUsbdiEventOverflow, "U:Event Overflow" ); + + // USBMAN + + _LIT(KMessUsbmanSrpInitiated, "M:SRP Initiated" ); + _LIT(KMessUsbmanSrpReceived, "M:SRP Received" ); + _LIT(KMessUsbmanHnpDisabled, "M:HNP Disabled" ); + _LIT(KMessUsbmanHnpEnabled, "M:HNP Enabled" ); + _LIT(KMessUsbmanVbusRaised, "M:VBUS Raised" ); + _LIT(KMessUsbmanVbusDropped, "M:VBUS Dropped" ); + _LIT(KMessUsbmanRequestSession, "M:Request Session" ); + + _LIT(KMessUnknown, "*:Unknown" ); + + switch(iMessage) + { + // OTGDI + + case KErrUsbOtgEventQueueOverflow: text.Set(KMessOtgdiEventQueueOverflow); break; + case KErrUsbOtgStateQueueOverflow: text.Set(KMessOtgdiStateQueueOverflow); break; + case KErrUsbOtgMessageQueueOverflow: text.Set(KMessOtgdiMessageQueueOverflow); break; + case KErrUsbOtgBadState: text.Set(KMessOtgdiBadState); break; + case KErrUsbOtgStackNotStarted: text.Set(KMessOtgdiStackNotStarted); break; + case KErrUsbOtgVbusAlreadyRaised: text.Set(KMessOtgdiVbusAlreadyRaised); break; + case KErrUsbOtgSrpForbidden: text.Set(KMessOtgdiSrpForbidden); break; + case KErrUsbOtgBusControlProblem: text.Set(KMessOtgdiBusControlProblem); break; + case KErrUsbOtgVbusPowerUpError: text.Set(KMessOtgdiVbusPowerUpError); break; + case KErrUsbOtgHnpEnableProblem: text.Set(KMessOtgdiHnpEnableProblem); break; + case KErrUsbOtgPeriphNotSupported: text.Set(KMessOtgdiPeriphNotSupported); break; + case KErrUsbOtgVbusError: text.Set(KMessOtgdiVbusError); break; + case KErrUsbOtgSrpTimeout: text.Set(KMessOtgdiSrpTimeout); break; + case KErrUsbOtgSrpActive: text.Set(KMessOtgdiSrpActive); break; + case KErrUsbOtgSrpNotPermitted: text.Set(KMessOtgdiSrpNotPermitted); break; + case KErrUsbOtgHnpNotPermitted: text.Set(KMessOtgdiHnpNotPermitted); break; + case KErrUsbOtgHnpNotEnabled: text.Set(KMessOtgdiHnpNotEnabled); break; + case KErrUsbOtgHnpNotSuspended: text.Set(KMessOtgdiHnpNotSuspended); break; + case KErrUsbOtgVbusPowerUpNotPermitted: text.Set(KMessOtgdiVbusPowerUpNotPermitted); break; + case KErrUsbOtgVbusPowerDownNotPermitted: text.Set(KMessOtgdiVbusPowerDownNotPermitted); break; + case KErrUsbOtgVbusClearErrorNotPermitted: text.Set(KMessOtgdiVbusClearErrorNotPermitted); break; + case KErrUsbOtgHnpNotResponding: text.Set(KMessOtgdiHnpNotResponding); break; + case KErrUsbOtgHnpBusDrop: text.Set(KMessOtgdiHnpBusDrop); break; + + // USBDI - Main + + case KErrUsbRequestsPending: text.Set(KMessUsbdiRequestsPending); break; + case KErrUsbBadAddress: text.Set(KMessUsbdiBadAddress); break; + case KErrUsbNoAddress: text.Set(KMessUsbdiNoAddress); break; + case KErrUsbSetAddrFailed: text.Set(KMessUsbdiSetAddrFailed); break; + case KErrUsbNoPower: text.Set(KMessUsbdiNoPower); break; + case KErrUsbTooDeep: text.Set(KMessUsbdiTooDeep); break; + case KErrUsbIOError: text.Set(KMessUsbdiIOError); break; + case KErrUsbNotConfigured: text.Set(KMessUsbdiNotConfigured); break; + case KErrUsbTimeout: text.Set(KMessUsbdiTimeout); break; + case KErrUsbStalled: text.Set(KMessUsbdiStalled); break; + case KErrUsbTestFailure: text.Set(KMessUsbdiTestFailure); break; + case KErrUsbBadState: text.Set(KMessUsbdiBadState); break; + case KErrUsbDeviceSuspended: text.Set(KMessUsbdiDeviceSuspended); break; + + // USBDI - Descriptors + + case KErrUsbBadDescriptorTopology: text.Set(KMessUsbdiBadDescriptorTopology); break; + + // USBDI - DevMon + + case KErrUsbDeviceRejected: text.Set(KMessUsbdiDeviceRejected); break; + case KErrUsbDeviceFailed: text.Set(KMessUsbdiDeviceFailed); break; + case KErrUsbBadDevice: text.Set(KMessUsbdiBadDevice); break; + case KErrUsbBadHubPosition: text.Set(KMessUsbdiBadHubPosition); break; + case KErrUsbBadHub: text.Set(KMessUsbdiBadHub); break; + case KErrUsbEventOverflow: text.Set(KMessUsbdiEventOverflow); break; + + // USBMAN + + case KUsbMessageSrpInitiated: text.Set(KMessUsbmanSrpInitiated); break; + case KUsbMessageSrpReceived: text.Set(KMessUsbmanSrpReceived); break; + case KUsbMessageHnpDisabled: text.Set(KMessUsbmanHnpDisabled); break; + case KUsbMessageHnpEnabled: text.Set(KMessUsbmanHnpEnabled); break; + case KUsbMessageVbusRaised: text.Set(KMessUsbmanVbusRaised); break; + case KUsbMessageVbusDropped: text.Set(KMessUsbmanVbusDropped); break; + case KUsbMessageRequestSession: text.Set(KMessUsbmanRequestSession); break; + + default: text.Set(KMessUnknown); break; + } + + aEvent->iEvent.AppendFormat(_L("O:Message[%d] [%S]"), iMessage, &text); + + if ( ( iMessage == KUsbMessageSrpReceived ) + && ( iTestConsole.GetAutoSrpResponseState() ) + ) + { + iTestConsole.Usb().BusRespondSrp(); + iTestConsole.Timer()->Start(KTimerAWaitBConnect); + } + else if ( iMessage == KUsbMessageRequestSession ) + { + iTestConsole.Usb().BusRequest(); + } + } + + iTestConsole.Usb().MessageNotification(iStatus, iMessage); + SetActive(); + + iTestConsole.NotifyEvent(aEvent); + } + + + +void CUsbManStarter::NewL(CUsbManStarter*& aSelf, CUsbTestConsole& aTestConsole) + { + aSelf = NULL; + CUsbManStarter* self = new(ELeave) CUsbManStarter(aSelf, aTestConsole); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + aSelf = self; + } + +CUsbManStarter::~CUsbManStarter() + { + Cancel(); + iSelf = NULL; + } + +CUsbManStarter::CUsbManStarter(CUsbManStarter*& aSelf, CUsbTestConsole& aTestConsole) + : CEventNotifier(EPriorityStandard) + , iSelf(aSelf) + , iTestConsole(aTestConsole) + { + CActiveScheduler::Add(this); + } + +void CUsbManStarter::ConstructL() + { + iTestConsole.Usb().Start(iStatus); + SetActive(); + } + +void CUsbManStarter::DoCancel() + { + iTestConsole.Usb().StartCancel(); + } + +void CUsbManStarter::DoRunL(XUsbTestConsoleEvent* aEvent) + { + aEvent->iEvent.AppendFormat(_L("G:Start:Err[%d]"), iStatus.Int()); + iTestConsole.NotifyEvent(aEvent); + delete this; + } + +void CUsbManStarter::DestroyL() + { + XUsbTestConsoleEvent* event = NewConsoleEventL(); + event->iEvent.Append(_L("G:StartCancel")); + iTestConsole.NotifyEvent(event); + delete this; + } + + +void CUsbManStoper::NewL(CUsbManStoper*& aSelf, CUsbTestConsole& aTestConsole) + { + aSelf = NULL; + CUsbManStoper* self = new(ELeave) CUsbManStoper(aSelf, aTestConsole); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + aSelf = self; + } + +CUsbManStoper::~CUsbManStoper() + { + Cancel(); + iSelf = NULL; + } + +CUsbManStoper::CUsbManStoper(CUsbManStoper*& aSelf, CUsbTestConsole& aTestConsole) + : CEventNotifier(EPriorityStandard) + , iSelf(aSelf) + , iTestConsole(aTestConsole) + { + CActiveScheduler::Add(this); + } + +void CUsbManStoper::ConstructL() + { + iTestConsole.Usb().Stop(iStatus); + SetActive(); + } + +void CUsbManStoper::DoCancel() + { + iTestConsole.Usb().StopCancel(); + } + +void CUsbManStoper::DoRunL(XUsbTestConsoleEvent* aEvent) + { + aEvent->iEvent.AppendFormat(_L("G:Stop:Err[%d]"), iStatus.Int()); + iTestConsole.NotifyEvent(aEvent); + delete this; + } + +void CUsbManStoper::DestroyL() + { + XUsbTestConsoleEvent* event = NewConsoleEventL(); + event->iEvent.Append(_L("G:StopCancel")); + iTestConsole.NotifyEvent(event); + delete this; + } + + + +void CUsbManTryStarter::NewL(CUsbManTryStarter*& aSelf, CUsbTestConsole& aTestConsole, TInt aPersonalityId) + { + aSelf = NULL; + CUsbManTryStarter* self = new(ELeave) CUsbManTryStarter(aSelf, aTestConsole, aPersonalityId); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + aSelf = self; + } + +CUsbManTryStarter::~CUsbManTryStarter() + { + Cancel(); + iSelf = NULL; + } + +CUsbManTryStarter::CUsbManTryStarter(CUsbManTryStarter*& aSelf, CUsbTestConsole& aTestConsole, TInt aPersonalityId) + : CEventNotifier(EPriorityStandard) + , iSelf(aSelf) + , iTestConsole(aTestConsole) + , iPersonalityId(aPersonalityId) + { + CActiveScheduler::Add(this); + } + +void CUsbManTryStarter::ConstructL() + { + iTestConsole.Usb().TryStart(iPersonalityId, iStatus); + SetActive(); + } + +void CUsbManTryStarter::DoCancel() + { + iTestConsole.Usb().StartCancel(); + } + +void CUsbManTryStarter::DoRunL(XUsbTestConsoleEvent* aEvent) + { + aEvent->iEvent.AppendFormat(_L("G:TryStart:Err[%d]"), iStatus.Int()); + iTestConsole.NotifyEvent(aEvent); + delete this; + } + +void CUsbManTryStarter::DestroyL() + { + XUsbTestConsoleEvent* event = NewConsoleEventL(); + event->iEvent.Append(_L("G:StartCancel")); + iTestConsole.NotifyEvent(event); + delete this; + } + + +void CUsbManTryStoper::NewL(CUsbManTryStoper*& aSelf, CUsbTestConsole& aTestConsole) + { + aSelf = NULL; + CUsbManTryStoper* self = new(ELeave) CUsbManTryStoper(aSelf, aTestConsole); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + aSelf = self; + } + +CUsbManTryStoper::~CUsbManTryStoper() + { + Cancel(); + iSelf = NULL; + } + +CUsbManTryStoper::CUsbManTryStoper(CUsbManTryStoper*& aSelf, CUsbTestConsole& aTestConsole) + : CEventNotifier(EPriorityStandard) + , iSelf(aSelf) + , iTestConsole(aTestConsole) + { + CActiveScheduler::Add(this); + } + +void CUsbManTryStoper::ConstructL() + { + iTestConsole.Usb().TryStop(iStatus); + SetActive(); + } + +void CUsbManTryStoper::DoCancel() + { + iTestConsole.Usb().StopCancel(); + } + +void CUsbManTryStoper::DoRunL(XUsbTestConsoleEvent* aEvent) + { + aEvent->iEvent.AppendFormat(_L("G:TryStop:Err[%d]"), iStatus.Int()); + iTestConsole.NotifyEvent(aEvent); + delete this; + } + +void CUsbManTryStoper::DestroyL() + { + XUsbTestConsoleEvent* event = NewConsoleEventL(); + event->iEvent.Append(_L("G:StopCancel")); + iTestConsole.NotifyEvent(event); + delete this; + } + +CUsbTestTimer* CUsbTestTimer::NewL(CUsbTestConsole& aUsb) + { + CUsbTestTimer* self = new(ELeave) CUsbTestTimer(aUsb); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +CUsbTestTimer::~CUsbTestTimer() + { + Cancel(); + } + +void CUsbTestTimer::ConstructL() + { + CTimer::ConstructL(); + CActiveScheduler::Add(this); + } + +CUsbTestTimer::CUsbTestTimer(CUsbTestConsole& aUsb) +: CTimer(EPriorityStandard) +, iTestConsole(aUsb) + { + } + +void CUsbTestTimer::Start(TTimeIntervalMicroSeconds32 aTime) + { + After(aTime); + } + +void CUsbTestTimer::RunL() + { + XUsbTestConsoleEvent* event = new(ELeave) XUsbTestConsoleEvent; + CleanupStack::PushL(event); + User::LeaveIfError(event->iEvent.Create(CUsbTestConsole::KNumCharactersOnLine-1)); + CleanupStack::Pop(); + + TPtrC res(NULL, 0); + _LIT(KErrMsg, "Device Not Responding"); + + res.Set(KErrMsg); + event->iEvent.AppendFormat(_L("T:Timer Message [%S]"), &res); + iTestConsole.NotifyEvent(event); + } + +void CUsbTestTimer::DoCancel() + { + CTimer::DoCancel(); + }