diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgrtest/usbcontrolapp/usbviewer/usbviewer.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgrtest/usbcontrolapp/usbviewer/usbviewer.cpp Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,1553 @@ +/* +* 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 +#include + +#include +#include +#include +// 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 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 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 >& 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 + _L("xxx"); + } + else + { + iAttachedDevices.NumFixedWidthUC(aAttachedDevices, EDecimal, 3); + } + LOG("Attached Devices => %S", &iAttachedDevices); + ScheduleDraw(); + } + +void CUsbViewer::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(); + } + +void CUsbViewer::NotifyEvent(XUsbViewerEvent* aEvent) + { + LOG("CUsbViewer::NotifyEvent event length = %d", aEvent->iEvent.Length()); + __ASSERT_ALWAYS(aEvent, PANIC); + __ASSERT_ALWAYS(aEvent->iEvent.Length() <= KViewerNumCharactersOnLine, PANIC); + + iEventList.AddFirst(*aEvent); + delete iEventList.Last(); + + LOG("Event => %S", &(aEvent->iEvent)); + ScheduleDraw(); + } + +void CUsbViewer::Draw() + { + PNT("CUsbViewer::Draw"); + iConsole->ClearScreen(); + + iConsole->Printf(_L( +// 1 2 3 +// 12345678901234567890123456789012 +// +// 12345 12345678901 + "IdPin: %S" L"SrvSt : %S\n" +// 12345 12345678901 + L"VBus : %S" L"DevSt : %S\n" +// 123 123 + L"DLoad: %S " L"# Devs: %S\n" +// 12345 1234 + L"Dev : %S" L" \n" +// 12345 1234567890123 + L"C.Idl: %S" L"OTG : %S \n" + ), + &iIdPin, &iServStatus, + &iVBus, &iDevStatus, + &iDriverLoading, &iAttachedDevices, + &iAttachedDevice, + &iConnIdle, &iOtgState + ); + + // Events... + TDblQueIter iter(iEventList); + XUsbViewerEvent* event = NULL; + while((event = iter++) != NULL) + { + iConsole->Printf(_L("\n")); + iConsole->Printf(event->iEvent.Left(KViewerNumCharactersOnLine)); + } + } + + + +CShutdownMonitor* CShutdownMonitor::NewL(MShutdownInterface& aParentUsbViewer) + { + CShutdownMonitor* self = new(ELeave) CShutdownMonitor(aParentUsbViewer); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +CShutdownMonitor::CShutdownMonitor(MShutdownInterface& aParentUsbViewer) + : CActive(EPriorityLow) // Low so all notifications that want to be serviced will be done first + , iParentUsbViewer(aParentUsbViewer) + { + CActiveScheduler::Add(this); + } + +void CShutdownMonitor::ConstructL() + { + // Monitor the KUsbControlAppShutdownKey property to tell us when to shut down + TInt err = iShutdownProp.Attach(KUidUsbControlAppCategory, KUsbControlAppShutdownKey); + LOG("CShutdownMonitor::ConstructL iShutdownProp.Attach() => %d", err); + User::LeaveIfError(err); + iShutdownProp.Subscribe(iStatus); + SetActive(); + TInt val; + // Make sure the cuurent value is 0 - shut down when this changes to 1 + err = iShutdownProp.Get(val); + LOG("CShutdownMonitor::ConstructL() iShutdownProp.Get(val) val => %d", val); + LOG("CShutdownMonitor::ConstructL() iShutdownProp.Get(val) err => %d", err); + User::LeaveIfError(err); + __ASSERT_ALWAYS(val==0, PANIC); + } + +CShutdownMonitor::~CShutdownMonitor() + { + iShutdownProp.Close(); + } + +void CShutdownMonitor::RunL() + { + // Request to shut everything down made in USB Aware App + TInt val; + TInt err = iShutdownProp.Get(val); + LOG("CShutdownMonitor::RunL iShutdownProp.Get(val) err => %d", err); + LOG("CShutdownMonitor::RunL iShutdownProp.Get(val) val => %d", val); + Cancel(); // Not interested in any more notifications + iParentUsbViewer.Stop(); // Stopping Active Scheduler will results in the destructor getting called + } + +void CShutdownMonitor::DoCancel() + { + iShutdownProp.Cancel(); + } + + + +CEventNotifier::CEventNotifier(TInt aPriority) + : CActive(aPriority) + { + } + +XUsbViewerEvent* CEventNotifier::NewViewerEventL() + { + XUsbViewerEvent* event = new(ELeave) XUsbViewerEvent; + CleanupStack::PushL(event); + User::LeaveIfError(event->iEvent.Create(KViewerNumCharactersOnLine)); + CleanupStack::Pop(); + return event; + } + +void CEventNotifier::RunL() + { + DoRunL(NewViewerEventL()); + } + + + + +CServiceStateWatcher* CServiceStateWatcher::NewL(CUsbViewer& aUsbViewer) + { + CServiceStateWatcher* self = new(ELeave) CServiceStateWatcher(aUsbViewer); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +CServiceStateWatcher::~CServiceStateWatcher() + { + Cancel(); + } + +CServiceStateWatcher::CServiceStateWatcher(CUsbViewer& aUsbViewer) + : CEventNotifier(EPriorityStandard) + , iUsbViewer(aUsbViewer) + , iServiceState(EUsbServiceIdle) + { + CActiveScheduler::Add(this); + } + +void CServiceStateWatcher::ConstructL() + { + iUsbViewer.Usb().ServiceStateNotification(iServiceState, iStatus); + SetActive(); + + TUsbServiceState serviceState; + User::LeaveIfError(iUsbViewer.Usb().GetServiceState(serviceState)); + iUsbViewer.SetServiceState(serviceState); + } + +void CServiceStateWatcher::DoCancel() + { + iUsbViewer.Usb().ServiceStateNotificationCancel(); + } + +void CServiceStateWatcher::DoRunL(XUsbViewerEvent* aEvent) + { + iUsbViewer.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; + } + + iUsbViewer.Usb().ServiceStateNotification(iServiceState, iStatus); + SetActive(); +// 16 8 1 -> 25 + aEvent->iEvent.AppendFormat(_L("D:ServiceState [%S]"), &res); + iUsbViewer.NotifyEvent(aEvent); + + // RunL call may have been delayed: ensure viewer has the very latest information + TUsbServiceState serviceState; + User::LeaveIfError(iUsbViewer.Usb().GetServiceState(serviceState)); + + iUsbViewer.SetServiceState(serviceState); + } + + +CDeviceStateWatcher* CDeviceStateWatcher::NewL(CUsbViewer& aUsbViewer) + { + CDeviceStateWatcher* self = new(ELeave) CDeviceStateWatcher(aUsbViewer); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +CDeviceStateWatcher::~CDeviceStateWatcher() + { + Cancel(); + } + +CDeviceStateWatcher::CDeviceStateWatcher(CUsbViewer& aUsbViewer) + : CEventNotifier(EPriorityStandard) + , iUsbViewer(aUsbViewer) + { + CActiveScheduler::Add(this); + } + +void CDeviceStateWatcher::ConstructL() + { + iUsbViewer.Usb().DeviceStateNotification(0xffffffff, iDeviceState, iStatus); + SetActive(); + + TUsbDeviceState deviceState; + User::LeaveIfError(iUsbViewer.Usb().GetDeviceState(deviceState)); + iUsbViewer.SetDeviceState(deviceState); + } + +void CDeviceStateWatcher::DoCancel() + { + iUsbViewer.Usb().DeviceStateNotificationCancel(); + } + +void CDeviceStateWatcher::DoRunL(XUsbViewerEvent* aEvent) + { + iUsbViewer.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; + } + + iUsbViewer.Usb().DeviceStateNotification(0xffffffff, iDeviceState, iStatus); + SetActive(); +// 15 10 1 -> 26 + aEvent->iEvent.AppendFormat(_L("D:DeviceState [%S]"), &res); + iUsbViewer.NotifyEvent(aEvent); + + // RunL call may have been delayed: ensure viewer has the very latest information + TUsbDeviceState deviceState; + User::LeaveIfError(iUsbViewer.Usb().GetDeviceState(deviceState)); + + iUsbViewer.SetDeviceState(deviceState); + } + + +CIdPinWatcher* CIdPinWatcher::NewL(CUsbViewer& aUsbViewer) + { + CIdPinWatcher* self = new(ELeave) CIdPinWatcher(aUsbViewer); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +CIdPinWatcher::~CIdPinWatcher() + { + Cancel(); + iIdPinProp.Close(); + } + +CIdPinWatcher::CIdPinWatcher(CUsbViewer& aUsbViewer) + : CEventNotifier(EPriorityStandard) + , iUsbViewer(aUsbViewer) + { + 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); + iUsbViewer.SetIdPin(val); + } + +void CIdPinWatcher::DoCancel() + { + iIdPinProp.Cancel(); + } + +void CIdPinWatcher::DoRunL(XUsbViewerEvent* 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(); +// 9 8 1 -> 18 + aEvent->iEvent.AppendFormat(_L("O:IdPin [%S]"), &res); + iUsbViewer.SetIdPin(val); + iUsbViewer.NotifyEvent(aEvent); + } + + +CVBusWatcher* CVBusWatcher::NewL(CUsbViewer& aUsbViewer) + { + CVBusWatcher* self = new(ELeave) CVBusWatcher(aUsbViewer); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +CVBusWatcher::~CVBusWatcher() + { + Cancel(); + iVBusProp.Close(); + } + +CVBusWatcher::CVBusWatcher(CUsbViewer& aUsbViewer) + : CEventNotifier(EPriorityStandard) + , iUsbViewer(aUsbViewer) + { + CActiveScheduler::Add(this); + } + +void CVBusWatcher::ConstructL() + { + User::LeaveIfError(iVBusProp.Attach(KUidUsbManCategory, KUsbOtgVBusPoweredProperty)); + iVBusProp.Subscribe(iStatus); + SetActive(); + + TInt val; + User::LeaveIfError(iVBusProp.Get(val)); + iUsbViewer.SetVBus(val); + } + +void CVBusWatcher::DoCancel() + { + iVBusProp.Cancel(); + } + +void CVBusWatcher::DoRunL(XUsbViewerEvent* 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: + res.Set(KVBusDropped); + break; + + case 1: + res.Set(KVBusRaised); + break; + + default: + PANIC; + break; + } + CleanupStack::Pop(); +// 8 7 1 -> 16 + aEvent->iEvent.AppendFormat(_L("O:VBus [%S]"), &res); + iUsbViewer.SetVBus(val); + iUsbViewer.NotifyEvent(aEvent); + } + + +CConnectionIdleWatcher* CConnectionIdleWatcher::NewL(CUsbViewer& aUsbViewer) + { + CConnectionIdleWatcher* self = new(ELeave) CConnectionIdleWatcher(aUsbViewer); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +CConnectionIdleWatcher::~CConnectionIdleWatcher() + { + Cancel(); + iConnIdleProp.Close(); + } + +CConnectionIdleWatcher::CConnectionIdleWatcher(CUsbViewer& aUsbViewer) + : CEventNotifier(EPriorityStandard) + , iUsbViewer(aUsbViewer) + { + CActiveScheduler::Add(this); + } + +void CConnectionIdleWatcher::ConstructL() + { + User::LeaveIfError(iConnIdleProp.Attach(KUidUsbManCategory, KUsbOtgConnectionIdleProperty)); + iConnIdleProp.Subscribe(iStatus); + SetActive(); + + TInt val; + TInt err = iConnIdleProp.Get(val); + LOG("CConnectionIdleWatcher::ConstructL iConnIdleProp.Get(val) => %d",err); + User::LeaveIfError(err); + iUsbViewer.SetConnectionIdle(val); + } + +void CConnectionIdleWatcher::DoCancel() + { + iConnIdleProp.Cancel(); + } + +void CConnectionIdleWatcher::DoRunL(XUsbViewerEvent* aEvent) + { + CleanupStack::PushL(aEvent); + + iConnIdleProp.Subscribe(iStatus); + SetActive(); + + TInt val; + User::LeaveIfError(iConnIdleProp.Get(val)); + + TPtrC res(NULL, 0); + _LIT(KConnIdle, "Idle"); + _LIT(KConnActive, "Active"); + switch(val) + { + case 0: + res.Set(KConnActive); + break; + + case 1: + res.Set(KConnIdle); + break; + + default: + PANIC; + break; + } + CleanupStack::Pop(); +// 12 6 1 -> 19 + aEvent->iEvent.AppendFormat(_L("O:ConnIdle [%S]"), &res); + iUsbViewer.SetConnectionIdle(val); + iUsbViewer.NotifyEvent(aEvent); + } + + +COtgStateWatcher* COtgStateWatcher::NewL(CUsbViewer& aUsbViewer) + { + COtgStateWatcher* self = new(ELeave) COtgStateWatcher(aUsbViewer); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +COtgStateWatcher::~COtgStateWatcher() + { + Cancel(); + iOtgStateProp.Close(); + } + +COtgStateWatcher::COtgStateWatcher(CUsbViewer& aUsbViewer) + : CEventNotifier(EPriorityStandard) + , iUsbViewer(aUsbViewer) + { + CActiveScheduler::Add(this); + } + +void COtgStateWatcher::ConstructL() + { + User::LeaveIfError(iOtgStateProp.Attach(KUidUsbManCategory, KUsbOtgStateProperty)); + iOtgStateProp.Subscribe(iStatus); + SetActive(); + + TInt val; + User::LeaveIfError(iOtgStateProp.Get(val)); + iUsbViewer.SetOtgState(val); + } + +void COtgStateWatcher::DoCancel() + { + iOtgStateProp.Cancel(); + } + +void COtgStateWatcher::DoRunL(XUsbViewerEvent* 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: + 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(); + +// 12 12 1 -> 25 + aEvent->iEvent.AppendFormat(_L("O:OtgState [%S]"), &res); + iUsbViewer.SetOtgState(val); + iUsbViewer.NotifyEvent(aEvent); + } + +CHostEventWatcher* CHostEventWatcher::NewL(CUsbViewer& aUsbViewer) + { + CHostEventWatcher* self = new(ELeave) CHostEventWatcher(aUsbViewer); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +CHostEventWatcher::~CHostEventWatcher() + { + Cancel(); + } + +CHostEventWatcher::CHostEventWatcher(CUsbViewer& aUsbViewer) + : CEventNotifier(EPriorityStandard) + , iUsbViewer(aUsbViewer) + { + CActiveScheduler::Add(this); + } + +void CHostEventWatcher::ConstructL() + { + iUsbViewer.Usb().HostEventNotification(iStatus, iDeviceInfo); + SetActive(); + iUsbViewer.SetAttachedDevices(0); + } + +void CHostEventWatcher::DoCancel() + { + iUsbViewer.Usb().HostEventNotificationCancel(); + } + +void CHostEventWatcher::DoRunL(XUsbViewerEvent* aEvent) + { + CleanupStack::PushL(aEvent); + + switch(iDeviceInfo.iEventType) + { + case EDeviceAttachment: + { + if(iDeviceInfo.iError == KErrNone) + { + User::LeaveIfError(iAttachedDevices.Append(iDeviceInfo.iDeviceId)); + } +// 5 8 6 4 1 4 1 -> 29 + aEvent->iEvent.AppendFormat(_L("H:At[%.08x] V,P[%.04x,%.04x]"), iDeviceInfo.iDeviceId, iDeviceInfo.iVid, iDeviceInfo.iPid); + + if ( (iDeviceInfo.iVid == 0x046D) + &&(iDeviceInfo.iPid == 0x0A02) + ) + { + iUsbViewer.SetDeviceType(CUsbViewer::ELogitechHeadset); + } + else + { + iUsbViewer.SetDeviceType(CUsbViewer::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; + } +// 7 8 6 3 5 1 1 -> 31 + aEvent->iEvent.AppendFormat(_L("H:Load[%.08x] Err[%.3d] St[%1S]"), iDeviceInfo.iDeviceId, iDeviceInfo.iError, &res); + } + break; + + case EDeviceDetachment: + { +// 10 8 1 -> 19 + 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); + iUsbViewer.SetDeviceType(CUsbViewer::ENoDevice); + } + break; + default: + PANIC; + break; + } + CleanupStack::Pop(); + iUsbViewer.SetAttachedDevices(iAttachedDevices.Count()); + iUsbViewer.NotifyEvent(aEvent); + iUsbViewer.Usb().HostEventNotification(iStatus, iDeviceInfo); + SetActive(); + } + + +CMessageWatcher* CMessageWatcher::NewL(CUsbViewer& aUsbViewer) + { + CMessageWatcher* self = new(ELeave) CMessageWatcher(aUsbViewer); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +CMessageWatcher::~CMessageWatcher() + { + Cancel(); + } + +CMessageWatcher::CMessageWatcher(CUsbViewer& aUsbViewer) + : CEventNotifier(EPriorityStandard) + , iUsbViewer(aUsbViewer) + { + CActiveScheduler::Add(this); + } + +void CMessageWatcher::ConstructL() + { + iUsbViewer.Usb().MessageNotification(iStatus, iMessage); + SetActive(); + } + +void CMessageWatcher::DoCancel() + { + iUsbViewer.Usb().MessageNotificationCancel(); + } + +void CMessageWatcher::DoRunL(XUsbViewerEvent* aEvent) + { + TInt err = iStatus.Int(); + + if (err) + { + aEvent->iEvent.AppendFormat(_L("O:Err! [%d] [%d]"), iMessage, err); // 32 chars max + } + 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(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" ); + + // 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 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; + + // 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; + } // switch(iMessage) + + // The message number can be positive (USBMAN) or negative (OTGDI/USBDI) + + LOG("CMessageWatcher::DoRunL iMessage = [%d]",iMessage); + LOG("CMessageWatcher::DoRunL text = [%S]",&text); + + if ( iMessage > 0 ) + { + // 4 1 4 3 19 1 -> 32 + aEvent->iEvent.AppendFormat(_L("Msg[+%4.4d] [%.19S]"), iMessage, &text); // 32 chars max + } + else + { + // 4 1 4 3 19 1 -> 32 + aEvent->iEvent.AppendFormat(_L("Msg[-%4.4d] [%.19S]"), -iMessage, &text); // 32 chars max + } + } // else + + iUsbViewer.Usb().MessageNotification(iStatus, iMessage); + SetActive(); + iUsbViewer.NotifyEvent(aEvent); + } + + + + +CUserMsgQWatcher* CUserMsgQWatcher::NewL(CUsbViewer& aUsbViewer) + { + CUserMsgQWatcher* self = new(ELeave) CUserMsgQWatcher(aUsbViewer); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +CUserMsgQWatcher::~CUserMsgQWatcher() + { + Cancel(); + } + +CUserMsgQWatcher::CUserMsgQWatcher(CUsbViewer& aUsbViewer) + : CEventNotifier(EPriorityStandard) + , iUsbViewer(aUsbViewer) + { + CActiveScheduler::Add(this); + } + +void CUserMsgQWatcher::ConstructL() + { + iUsbViewer.UserMsgQ().NotifyDataAvailable(iStatus); + SetActive(); + } + +void CUserMsgQWatcher::DoCancel() + { + iUsbViewer.UserMsgQ().CancelDataAvailable(); + } + +void CUserMsgQWatcher::DoRunL(XUsbViewerEvent* aEvent) + { + CleanupStack::PushL(aEvent); + + User::LeaveIfError(iUsbViewer.UserMsgQ().Receive(iUserMsgLine)); + LOG("CUserMsgQWatcher::DoRunL iUsbViewer.UserMsgQ().Receive => %S", &iUserMsgLine); + CleanupStack::Pop(); + + aEvent->iEvent.AppendFormat(_L("%S"), &iUserMsgLine); + iUsbViewer.NotifyEvent(aEvent); + + iUsbViewer.UserMsgQ().NotifyDataAvailable(iStatus); // Re-subscribe + SetActive(); + } +