--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/e32test/usbho/t_usbdi/src/FDFActor.cpp	Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,456 @@
+// 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 the License "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:
+// @file fdfactor.cpp
+// @internalComponent
+// 
+//
+
+#include "FDFActor.h"
+#include "testdebug.h"
+#include <Usb.h>
+#include "UsbDescriptorOffsets.h"
+#include "BaseTestCase.h"
+#include <e32property.h>
+
+extern RTest gtest;
+
+namespace NUnitTesting_USBDI
+	{
+static const TUid KWordOfDeathCat = {0x01066600};
+static const TInt KWordOfDeathKey = 0x01066601;
+
+static const TInt KNonExistantStringNumber = 97; //the device does not have a string descriptor associated with the number 97
+
+CActorFDF* CActorFDF::NewL(MUsbBusObserver& aObserver)
+	{
+	CActorFDF* self = new (ELeave) CActorFDF(aObserver);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+
+CActorFDF::CActorFDF(MUsbBusObserver& aObserver)
+:	CActive(EPriorityStandard),
+	iObserver(aObserver)
+	{
+	}
+
+
+void CActorFDF::ConstructL()
+	{
+	LOG_FUNC
+	CActiveScheduler::Add(this);
+	
+	TInt err(iDriver.Open());
+	if(err != KErrNone)
+		{
+		RDebug::Printf("<Error %d> Unable to open driver channel",err);
+		User::Leave(err);
+		}		
+	
+	RDebug::Printf("PBASE-T_USBDI-xxxx: Stack starting");
+	/*
+	@SYMTestCaseID				PBASE-T_USBDI-xxxx
+	@SYMTestCaseDesc			Test for host stack initiation
+	@SYMFssID 
+	@SYMPREQ					1782
+	@SYMREQ						7097 [USBMAN : Activation and deactivation of USB Host functionality]
+	@SYMTestType				UT
+	@SYMTestPriority			1 
+	@SYMTestActions 			
+	@SYMTestExpectedResults	 	KErrNone from RUsbHubDriver::StartHost()
+	@SYMTestStatus				Implemented
+	*/
+	err = iDriver.StartHost();
+	if(err != KErrNone)
+		{
+		// Test case did not run successfully
+		RDebug::Printf("<Error %d> USB Host stack not starting",err);		
+		gtest(EFalse);
+		}
+	  
+	RDebug::Printf("starting t_usbhost_usbman.exe");
+	TInt r = iOtgUsbMan.Create(_L("t_usbhost_usbman.exe"), KNullDesC); //LIT does not seem to work here
+	if(r != KErrNone && r != KErrAlreadyExists)
+		{
+  		RDebug::Printf("can't start t_usbhost_usbman.exe");
+		gtest(EFalse);
+		}
+	
+    // create a publish/subscribe key to allow usbhost_usbman to be killed
+    // cleanly
+    static _LIT_SECURITY_POLICY_PASS(KAllowAllPolicy);
+    r = RProperty::Define(KWordOfDeathCat, KWordOfDeathKey, RProperty::EInt,KAllowAllPolicy, KAllowAllPolicy, 0);
+	if(r != KErrNone && r != KErrAlreadyExists)
+        {
+        RDebug::Printf("Could not create the WordOfDeath P&S   (%d)", r);
+ 		gtest(EFalse);
+        }
+
+	iOtgUsbMan.Resume();	
+	
+	User::After(1500000); //allow time for t_usbhost_usbman.exe to start	
+	}
+
+void KillTest()
+	{
+	RDebug::Printf("BEFORE gtest(EFalse)");
+	gtest(EFalse);
+	RDebug::Printf("AFTER gtest(EFalse)");
+	}
+
+CActorFDF::~CActorFDF()
+	{
+	LOG_FUNC
+	Cancel();
+	
+	// Destroy all test device objects that represented connected devices
+	
+	RHashMap<TUint,CUsbTestDevice*>::TIter it(iDevices);
+	TInt count(0);
+	for(count=0; count<iDevices.Count(); count++)
+		{
+		delete *it.NextValue();
+		}
+
+	RDebug::Printf("killing t_usbhost_usbman.exe");
+	TInt r = RProperty::Set(KWordOfDeathCat, KWordOfDeathKey, KErrAbort);   // Send the word of death
+    if(r != KErrNone)
+        {
+        RDebug::Printf("failed to kill t_usbhost-usbhan  (%d)", r);      
+		RProperty::Delete(KWordOfDeathCat, KWordOfDeathKey); //try to clean this up ready for next test
+		User::After(1000000); //allow time for property to clean up
+		gtest(EFalse);
+       }
+	User::After(1000000); //allow time for t_usbhost_usbman.exe to clean up
+
+	// Stop the USB Hub driver
+		
+	RDebug::Printf("UT-USBD-P1782-TN0001: Hub driver stopping...");
+
+	// Close the channel to the USB Hub driver	
+	iDriver.Close();	
+	
+	User::After(500000);
+	
+    // delete word of death P&S
+    r = RProperty::Delete(KWordOfDeathCat, KWordOfDeathKey);
+    if(r != KErrNone)
+        {
+        //try again
+		User::After(1000000); //allow time for property to clean up
+		r = RProperty::Delete(KWordOfDeathCat, KWordOfDeathKey);
+		if(r != KErrNone)
+			//give up
+			{
+			User::After(1000000); //allow time for property to clean up JUST IN CASE it can despite returning an error!
+	        RDebug::Printf("failed to delete wordofdeath P&S  (%d)", r);
+			gtest(EFalse);
+			}
+        }
+
+	}
+	
+void CActorFDF::DoCancel()
+	{
+	LOG_FUNC
+
+
+	RDebug::Printf("Cancelling bus event notifications");
+	iDriver.CancelWaitForBusEvent();
+	gtest((iStatus == KErrCancel) || (iStatus == KErrNone));	
+	RDebug::Printf("Bus event notifications successfully cancelled");	
+	}
+	
+void CActorFDF::Monitor()
+	{
+	LOG_FUNC
+
+	RDebug::Printf("Monitoring bus events");
+	iDriver.WaitForBusEvent(iBusEvent,iStatus);
+	SetActive();
+	}
+	
+	
+			
+CUsbTestDevice& CActorFDF::DeviceL(TUint aDeviceHandle)
+	{
+	return *iDevices.FindL(aDeviceHandle);
+	}
+	
+void CActorFDF::RunL()
+	{
+	LOG_FUNC
+
+	// Obtain completion code
+	TInt completionCode(iStatus.Int());
+	RDebug::Printf("Completion code  : %d",completionCode);
+	
+	 if(completionCode == KErrNone)
+		{
+		if(iBusEvent.iEventType == RUsbHubDriver::TBusEvent::EDeviceAttached)
+			{
+			// Device Attached
+			RDebug::Printf("Usb device attached: %d",iBusEvent.iDeviceHandle);
+			
+			// Create the test device object
+			iDevices.InsertL(iBusEvent.iDeviceHandle,CUsbTestDevice::NewL(iDriver,iBusEvent.iDeviceHandle,iObserver));
+			
+			// Notify observer
+			iObserver.DeviceInsertedL(iBusEvent.iDeviceHandle);
+			}
+		else if(iBusEvent.iEventType == RUsbHubDriver::TBusEvent::EDeviceRemoved)
+			{
+			// Device Removed
+			RDebug::Printf("Usb device removed: %d",iBusEvent.iDeviceHandle);
+			
+			// Notify observer
+			iObserver.DeviceRemovedL(iBusEvent.iDeviceHandle);
+			
+			// Destroy the device for the handle and remove from the map
+			delete iDevices.FindL(iBusEvent.iDeviceHandle);
+			iDevices.Remove(iBusEvent.iDeviceHandle);
+			}
+		else
+			{
+			// TODO: Upcall for USB Man etc
+			RDebug::Printf("<Warning> Bus event %d occured, still monitoring, reason = %d",iBusEvent.iEventType, iBusEvent.iReason);
+			iDriver.WaitForBusEvent(iBusEvent,iStatus);
+			SetActive();
+			}
+		}
+	else
+		{
+		RDebug::Printf("<Error %d> Bus event %d",completionCode,iBusEvent.iEventType);
+		iObserver.BusErrorL(completionCode);
+		}
+	}
+	
+
+TInt CActorFDF::RunError(TInt aError)
+	{
+	LOG_FUNC
+
+	RDebug::Printf("<Error %d> CActorFDF::RunError",aError);
+	return KErrNone;
+	}
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+	
+CUsbTestDevice* CUsbTestDevice::NewL(RUsbHubDriver& aHubDriver,TUint aDeviceHandle,MUsbBusObserver& aObserver)
+	{
+	CUsbTestDevice* self = new (ELeave) CUsbTestDevice(aHubDriver,aDeviceHandle,aObserver);
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+	return self;
+	}
+	
+CUsbTestDevice::CUsbTestDevice(RUsbHubDriver& aHubDriver,TUint aHandle,MUsbBusObserver& aObserver)
+:	CActive(EPriorityUserInput),
+	iDriver(aHubDriver),
+	iHandle(aHandle),
+	iObserver(aObserver)
+	{
+	LOG_FUNC
+
+	CActiveScheduler::Add(this);
+	}
+	
+CUsbTestDevice::~CUsbTestDevice()
+	{
+	LOG_FUNC
+	Cancel();
+	iDevice.Close();
+	}
+	
+void CUsbTestDevice::ConstructL()
+	{
+	LOG_FUNC
+
+	// Open the usb device object
+	User::LeaveIfError(iDevice.Open(iDriver,iHandle));
+
+	TInt err(iDevice.GetDeviceDescriptor(iDeviceDescriptor));
+	if(err != KErrNone)
+		{
+		RDebug::Printf("<Error %d> Getting device (%d) descriptor",err,iHandle);
+		User::Leave(err);
+		}
+	
+	err = iDevice.GetConfigurationDescriptor(iConfigDescriptor);
+	if(err != KErrNone)
+		{
+		RDebug::Printf("<Error %d> Getting device (%d) configuration descriptor",err,iHandle);
+		User::Leave(err);
+		}
+
+	iDeviceSpec = iDeviceDescriptor.USBBcd();
+	iPid = iDeviceDescriptor.ProductId();
+	iVid = iDeviceDescriptor.VendorId();
+	
+	RDebug::Printf("%dmA configuration maximum power consumption",iConfigDescriptor.MaxPower()*2);
+	RDebug::Printf("%d number of interface(s)",iConfigDescriptor.NumInterfaces());
+	RDebug::Printf("Product Id=0x%04x, Vendor Id=0x%04x",iPid,iVid);
+	RDebug::Printf("TotalLength() = %d",iConfigDescriptor.TotalLength());
+
+	// The manufacturer string
+	err = iDevice.GetStringDescriptor(iManufacturerStringDesc,iManufacturerStringData,iDeviceDescriptor.ManufacturerIndex());
+	if(err != KErrNone)
+		{
+		RDebug::Printf("<Error %d> Getting device (%d) manufacturer string descriptor",err,iHandle);
+		User::Leave(err);
+		}
+	iManufacturerStringDesc->StringData(iManufacturerString);
+	
+	// The product string
+	err = iDevice.GetStringDescriptor(iProductStringDesc,iProductStringData,iDeviceDescriptor.ProductIndex());
+	if(err != KErrNone)
+		{
+		RDebug::Printf("<Error %d> Getting device (%d) product string descriptor",err,iHandle);
+		User::Leave(err);
+		}
+	iProductStringDesc->StringData(iProductString);
+		
+	// The serial number 
+	err = iDevice.GetStringDescriptor(iSerialNumberDesc,iSerialNumberStringData,iDeviceDescriptor.SerialNumberIndex());
+	if(err != KErrNone)
+		{
+		RDebug::Printf("<Error %d> Getting device (%d) serial number string descriptor",err,iHandle);
+		User::Leave(err);
+		}
+	iSerialNumberDesc->StringData(iSerialNumber);
+	
+	// The configuration string
+	err = iDevice.GetStringDescriptor(iConfigStringDesc,iConfigStringData,iConfigDescriptor.ConfigurationIndex());
+	if(err != KErrNone)
+		{
+		RDebug::Printf("<Error %d> Getting device (%d) configuration string descriptor",err,iHandle);
+		User::Leave(err);
+		}
+	iConfigStringDesc->StringData(iConfigString);
+	
+	// Trying to obtain a string descriptor that is not present, expecting a stall	
+	TBuf8<255> nonExistentString;
+	TUsbStringDescriptor* unusedStringDescriptor =  NULL;
+	err = iDevice.GetStringDescriptor(unusedStringDescriptor,nonExistentString,KNonExistantStringNumber);
+	if(err != KErrUsbStalled)
+		{
+		delete unusedStringDescriptor; //in case 'err ==  KErrNone', in which case this will need freeing
+		RDebug::Printf("GetStringDescriptor with nonExistentString didn't return KErrUsbStalled",err,iHandle);
+		User::Leave(err);
+		}
+	RDebug::Printf("String not present error(%d)",err);
+
+	// Get changes in device state
+	iDevice.QueueDeviceStateChangeNotification(iCurrentState,iStatus); // iCurrentState now holds the current device state
+	SetActive();
+	}
+	
+RUsbDevice& CUsbTestDevice::Device()
+	{
+	return iDevice;
+	}
+	
+TUint16 CUsbTestDevice::DeviceSpec() const
+	{
+	return iDeviceSpec;
+	}
+	
+TUint16 CUsbTestDevice::ProductId() const
+	{
+	return iPid;
+	}
+	
+TUint16 CUsbTestDevice::VendorId() const
+	{
+	return iVid;
+	}
+
+const TDesC16& CUsbTestDevice::SerialNumber() const
+	{
+	return iSerialNumber;
+	}
+
+const TDesC16& CUsbTestDevice::Manufacturer() const
+	{
+	return iManufacturerString;
+	}
+	
+const TDesC16& CUsbTestDevice::Product() const
+	{
+	return iProductString;
+	}
+	
+const TDesC16& CUsbTestDevice::ConfigurationString() const
+	{
+	return iConfigString;
+	}
+
+const TUsbConfigurationDescriptor& CUsbTestDevice::ConfigurationDescriptor() const
+	{
+	return iConfigDescriptor;
+	}
+		
+const TUsbDeviceDescriptor& CUsbTestDevice::DeviceDescriptor() const
+	{
+	return iDeviceDescriptor;
+	}
+
+void CUsbTestDevice::DoCancel()
+	{
+	LOG_FUNC
+
+	iDevice.CancelDeviceStateChangeNotification();
+	}
+
+
+void CUsbTestDevice::RunL()
+	{
+	LOG_FUNC
+
+	TInt completionCode(iStatus.Int());
+	RDebug::Printf("CUsbTestDevice::RunL completionCode(%d)",completionCode);
+
+	if(completionCode == KErrNone)
+		{
+		RUsbDevice::TDeviceState newState;
+		iDevice.QueueDeviceStateChangeNotification(newState,iStatus);
+		SetActive();
+		iObserver.DeviceStateChangeL(iCurrentState,newState,completionCode);
+		iCurrentState = newState;
+		}
+	}
+
+
+TInt CUsbTestDevice::RunError(TInt aError)
+	{
+	LOG_FUNC
+
+	RDebug::Printf("<Error %d>",aError);
+	return KErrNone;
+	}
+
+	}
+