/*

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

*

*/

/**

 @file

 @internalComponent

*/

#include "fdf.h"

#include <usb/usblogger.h>

#include "utils.h"

#include <usbhost/internal/fdcplugin.hrh>

#include "eventqueue.h"

#endif

_LIT(KDriverUsbhubLddFileName,"usbhubdriver");

_LIT(KDriverUsbdiLddFileName,"usbdi");

const TUint KVendorSpecificDeviceClassValue = 0xFF;

const TUint KVendorSpecificInterfaceClassValue = 0xFF;

const TUint KMaxSearchKeyLength = 64; 

// Factory function for TInterfaceInfo objects.

CFdf::TInterfaceInfo* CFdf::TInterfaceInfo::NewL(RPointerArray<CFdf::TInterfaceInfo>& aInterfaces)

	{

	TInterfaceInfo* self = new(ELeave) TInterfaceInfo;

	CleanupStack::PushL(self);

	aInterfaces.AppendL(self);

	CLEANUPSTACK_POP1(self);

	return self;

	}

CFdf* CFdf::NewL()

	{

	CFdf* self = new(ELeave) CFdf;

	CleanupStack::PushL(self);

	self->ConstructL();

	CLEANUPSTACK_POP1(self);

	return self;

	}

CFdf::CFdf()

:	iDevices(_FOFF(CDeviceProxy, iLink)),

	iFunctionDrivers(_FOFF(CFdcProxy, iLink))

	{

	}

void CFdf::ConstructL()

	{

#ifndef __OVER_DUMMYUSBDI__

	// If we're using the DummyUSBDI we don't need the real USBDI.

	TInt err = User::LoadLogicalDevice(KDriverUsbhubLddFileName);

	if ( err != KErrAlreadyExists )

		{

		}

#endif // __OVER_DUMMYUSBDI__

#ifdef __OVER_DUMMYUSBDI__

#endif

	iActiveWaitForBusEvent = CActiveWaitForBusEvent::NewL(iHubDriver, iBusEvent, *this);

	iActiveWaitForBusEvent->Wait();	

	CreateFunctionDriverProxiesL();	

	iActiveWaitForEComEvent = CActiveWaitForEComEvent::NewL(*this);

	iActiveWaitForEComEvent->Wait();

	iEventQueue = CEventQueue::NewL(*this);

	}

void CFdf::CreateFunctionDriverProxiesL()

	{

	REComSession::ListImplementationsL(TUid::Uid(KFdcEcomInterfaceUid), iImplInfoArray);

	const TUint count = iImplInfoArray.Count();

	if ( count == 0 )

		{

	else

		{

		}

#endif

   	for ( TUint i = 0 ; i < count ; ++i )

   		{

   		CFdcProxy* proxy = CFdcProxy::NewL(*this, *iImplInfoArray[i]);

   		// If this proxy is rom based then put it in the first place

   		// this will save time when trying to load the FDC with the rule of 

   		// ROM-based ones have higher priority than installed ones.

   		if (proxy->RomBased())

   			iFunctionDrivers.AddFirst(*proxy);

   		else

   			iFunctionDrivers.AddLast(*proxy);

   		}

	}

CFdf::~CFdf()

	{

	// Mimic the detachment of each attached device.

	TSglQueIter<CDeviceProxy> deviceIter(iDevices);

	deviceIter.SetToFirst();

	CDeviceProxy* device;

	while ( ( device = deviceIter++ ) != NULL )

		{

		const TUint deviceId = device->DeviceId();

		TellFdcsOfDeviceDetachment(deviceId);

		iDevices.Remove(*device);

		delete device;

		}

	// Destroy all the FDC proxies. They should each now have no 'attached

	// devices' and no plugin instance.

	TSglQueIter<CFdcProxy> fdcIter(iFunctionDrivers);

	fdcIter.SetToFirst();

	CFdcProxy* fdc;

	while ( ( fdc = fdcIter++ ) != NULL )

		{

		iFunctionDrivers.Remove(*fdc);

		delete fdc;

		}

	delete iActiveWaitForBusEvent;

	delete iActiveWaitForEComEvent;

	if ( iHubDriver.Handle() )

		{

		iHubDriver.StopHost(); // NB this has no return value

		}

	iHubDriver.Close();

#ifndef __OVER_DUMMYUSBDI__

	//If we're using the DummyUSBDI the real USBDI isn't loaded.

	TInt err = User::FreeLogicalDevice(KDriverUsbhubLddFileName);

	err = User::FreeLogicalDevice(KDriverUsbdiLddFileName);

#endif // __OVER_DUMMYUSBDI__

	delete iEventQueue;

	// This is a worthwhile check to do at this point. If we ever don't clean

	// up iInterfaces at the *right* time, then this will be easier to debug

	// than a memory leak.

	iImplInfoArray.ResetAndDestroy();

	REComSession::FinalClose();

	}

void CFdf::EnableDriverLoading()

	{

	iDriverLoadingEnabled = ETrue;

	}

void CFdf::DisableDriverLoading()

	{

	iDriverLoadingEnabled = EFalse;

	}

void CFdf::SetSession(CFdfSession* aSession)

	{

	iSession = aSession;

	}

CFdfSession* CFdf::Session()

	{

	return iSession;

	}

TBool CFdf::GetDeviceEvent(TDeviceEvent& aEvent)

	{

	return iEventQueue->GetDeviceEvent(aEvent);

	}

TBool CFdf::GetDevmonEvent(TInt& aEvent)

	{

	return iEventQueue->GetDevmonEvent(aEvent);

	}

// An ECom plugin has been installed or removed

void CFdf::EComEventReceived()

	{

	TRAPD(ret, HandleEComEventReceivedL());

	if (ret != KErrNone)

		HandleDevmonEvent(KErrUsbUnableToUpdateFDProxyList);

	}

void CFdf::HandleEComEventReceivedL()

	{

	// There is no way to filter ecom notification to only receive ones we are interested in, also there is no way

	// to query ecom as to what has changed. Hence there is no option but to call ListImplementations().

	iImplInfoArray.ResetAndDestroy();		

	REComSession::ListImplementationsL(TUid::Uid(KFdcEcomInterfaceUid), iImplInfoArray);	

	TUint implementationsCount = iImplInfoArray.Count();

	if ( implementationsCount == 0 )

		{

	TSglQueIter<CFdcProxy> proxiesIterDebug(iFunctionDrivers);

	CFdcProxy* fdcDebug = NULL;		

	while ( ( fdcDebug = proxiesIterDebug++ ) != NULL )

		{

		TUid fdcUid = fdcDebug->ImplUid();

		TInt fdcVersion = fdcDebug->Version();

	for (TInt kk = 0; kk < implementationsCount; ++kk)

		{

		TUid fdcUid2 = iImplInfoArray[kk]->ImplementationUid();

		TInt fdcVersion2 = iImplInfoArray[kk]->Version();

		}

	// See if any relevant FDCs (or upgrades) have been installed or uninstalled:	

	// For each FD in the proxy list compare the uid and version with each FD returned by ECom looking

	// for the removal, upgrade or downgrade of an existing FD 	

	TSglQueIter<CFdcProxy> proxiesIter(iFunctionDrivers);

	proxiesIter.SetToFirst();

	CFdcProxy* fdc = NULL;	

	while ( ( fdc = proxiesIter++ ) != NULL )

		{

		TBool fdcRemoved = ETrue;

		for (TInt ii = 0; ii < implementationsCount; ++ii)

			{

			if (fdc->ImplUid() == iImplInfoArray[ii]->ImplementationUid())

				{			

				// We have found an upgrade, downgrade, or duplicate (a duplicate could occur in the situation

				// where an FD has been installed, then a device attached, then the FD uninstalled and re-installed *while*

				// the device is still attached (meaning the FD's proxy is still in the proxy list but will have been marked

				// for deletion when the uninstallation was detected).

				fdcRemoved = EFalse;

				if (fdc->Version() != iImplInfoArray[ii]->Version())

					{

					// We've found an upgrade or a downgrade. Note that the upgrade FD proxy needs adding to the

					// proxy list, however that isn't done here it is done later in the loop that is searching for

					// new FDs. This is to prevent its possible duplicate addition [consider the situation where

					// there is FDv1 and a device is attached, then while still attached FDv2 gets installed (while will

					// result in FDv1 getting marked for deletion), then another device is attached which will use FDv2.

					// Now if FDv3 is installed before any of the devices were detached there will be two proxies in the 

					// proxy list with the same UID but differing version numbers. If FDv3 is added here it will therefore

					// be added twice].

					if (fdc->DeviceCount())

						{

						// The device using the FD is still attached

						fdc->MarkForDeletion();

						}

					else

						{

						iFunctionDrivers.Remove(*fdc);

						delete fdc;

						}					

					}		

				else

					{

					// we've found an FD being installed which is still currently 

					// active in the proxy list

					fdc->UnmarkForDeletion();

					}	

				// Since we found the plugin with the same implementationUid

				// we could simply bail out to stop the looping;

				break;

				}

			}

		if (fdcRemoved)

			{ 

			// An FDC has been uninstalled - if the FDC isn't in use remove it 

			// otherwise mark it for deletion

			if (fdc->DeviceCount())

				fdc->MarkForDeletion();

			else

				{

				iFunctionDrivers.Remove(*fdc); 

				delete fdc;				

				}			

			}

		}

	// For each FD returned by ECom, search and compare with the FD proxy list 

	// looking for new FDs

	for (TInt ii = 0; ii < implementationsCount; ++ii)

		{

		TBool newFdcFound = ETrue;

		proxiesIter.SetToFirst();

		while ( ( fdc = proxiesIter++ ) != NULL )

			{

			if (fdc->ImplUid() == iImplInfoArray[ii]->ImplementationUid() && fdc->Version() == iImplInfoArray[ii]->Version())

				{

				// No need to create a new proxy if there is one with a matching UID and version.

				newFdcFound = EFalse;

				// We break out this loop for efficiency.

				break;

				}

			}	

		if (newFdcFound)

			{ 

			// A new or upgrade FDC has been installed onto the device

			CFdcProxy* proxy = CFdcProxy::NewL(*this, *iImplInfoArray[ii]);

			// If this proxy is rom based then put it in the first place

	   		// this will save time when trying to load the FDC with the rule that 

	   		// ROM-based ones have higher priority than installed ones.

			if (proxy->RomBased())

				iFunctionDrivers.AddFirst(*proxy);

			else

				iFunctionDrivers.AddLast(*proxy);			

			}

		}

	}

// A bus event has occurred.

void CFdf::MbeoBusEvent()

	{

	switch ( iBusEvent.iEventType )

		{

		case RUsbHubDriver::TBusEvent::EDeviceAttached:

			if ( !iBusEvent.iError )

				{

				// So far, a successful attachment.

				HandleDeviceAttachment(iBusEvent.iDeviceHandle);

				}

			else

				{

				// It was an attachment failure. Simply tell the event queue.

				iEventQueue->AttachmentFailure(iBusEvent.iError);

				}

			break;

		case RUsbHubDriver::TBusEvent::EDeviceRemoved:

			// Device detachments are always 'KErrNone'. If the device was

			// pseudo-detached due to an overcurrent condition (for instance) then

			// the overcurrent condition is indicated through the devmon API (i.e.

			// EDevMonEvent) and the detachment is still 'KErrNone'.

			HandleDeviceDetachment(iBusEvent.iDeviceHandle);

			break;

		case RUsbHubDriver::TBusEvent::EDevMonEvent:

			HandleDevmonEvent(iBusEvent.iError);

			break;

		case RUsbHubDriver::TBusEvent::ENoEvent:

		default:

		break;

		}

	// Only re-post the notification when we've finished examining the

	// TBusEvent from the previous completion. (Otherwise it might get

	// overwritten.)

	iActiveWaitForBusEvent->Wait();

	}

// This is the central handler for device attachment.

// We deal with device attachments in two phases.

// The first phase is confusingly called device attachment.

// The second phase is driver loading.

void CFdf::HandleDeviceAttachment(TUint aDeviceId)

	{

	// This is filled in by HandleDeviceAttachmentL on success.

	CDeviceProxy* device;

	TRAPD(err, HandleDeviceAttachmentL(aDeviceId, device));

	if ( err )

		{

		// There was an attachment failure, so we just increment the count of

		// attachment failures.

		iEventQueue->AttachmentFailure(err);

		// If we failed the attachment phase, we can't try to load drivers for

		// the device.

		}

	else

		{

		// This function always moves the 'driver loading' event from the

		// device proxy created by HandleDeviceAttachmentL to the event queue.

		// This event object is always populated with the correct status and

		// error.

		DoDriverLoading(*device);

		}

	// Finally, clean up the collection of information on the device's

	// interfaces which was populated (maybe only partly) in

	// HandleDeviceAttachmentL.

	iCurrentDevice = NULL;

	iInterfaces.ResetAndDestroy();

	}

// This does the 'device attachment' phase of the new device attachment only.

void CFdf::HandleDeviceAttachmentL(TUint aDeviceId, CDeviceProxy*& aDevice)

	{

	// Create the device proxy

	aDevice = CDeviceProxy::NewL(iHubDriver, aDeviceId);

	CleanupStack::PushL(aDevice);

	iCurrentDevice = aDevice;

	// Get necessary descriptors (for this phase)

	const TUint8 numberOfInterfaces = iCD.NumInterfaces();

	if ( numberOfInterfaces == 0 )

		{

		}

	// Walk the configuration bundle. Collect information on each interface

	// (its number, class, subclass and protocol). This populates iInterfaces.

	ParseL(iCD);

	// Log iInterfaces.

	const TUint interfaceCount = iInterfaces.Count();