/*

* Copyright (c) 2007-2010 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 <usb/usblogger.h>

#include "fdf.h"

#include "fdfsession.h"

#include "utils.h"

#endif

#define LOG Log()

#else

#define LOG

#endif

class CFdfSession;

CEventQueue* CEventQueue::NewL(CFdf& aFdf)

	{

	CEventQueue* self = new(ELeave) CEventQueue(aFdf);

	return self;

	}

CEventQueue::CEventQueue(CFdf& aFdf)

:	iFdf(aFdf),

	iDeviceEvents(_FOFF(TDeviceEvent, iLink))

	{

	}

CEventQueue::~CEventQueue()

	{

	// There will be things left on the queue at this time if USBMAN shuts us

	// down without having picked up everything that was on the queue.

	// This is valid behaviour and these events need destroying now.

	TSglQueIter<TDeviceEvent> iter(iDeviceEvents);

	iter.SetToFirst();

	TDeviceEvent* event;

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

		{

		delete event;

		}

	}

// Increments the count of failed attachments.

void CEventQueue::AttachmentFailure(TInt aError)

	{

	TUint index = 0;

	switch ( aError )

		{

	case KErrUsbSetAddrFailed:

		index = KSetAddrFailed;

		break;

	case KErrUsbNoPower:

		index = KNoPower;

		break;

	case KErrBadPower:

		index = KBadPower;

		break;

	case KErrUsbIOError:

		index = KIOError;

		break;

	case KErrUsbTimeout:

		index = KTimeout;

		break;

	case KErrUsbStalled:

		index = KStalled;

		break;

	case KErrNoMemory:

		index = KNoMemory;

		break;

	case KErrUsbConfigurationHasNoInterfaces:

		index = KConfigurationHasNoInterfaces;

		break;

	case KErrUsbInterfaceCountMismatch:

		index = KInterfaceCountMismatch;

		break;

	case KErrUsbDuplicateInterfaceNumbers:

		index = KDuplicateInterfaceNumbers;

		break;

	case KErrBadHandle:

		index = KBadHandle;

		break;

	default:

		// we must deal with every error we are ever given

		index = KAttachmentFailureGeneralError;

		break;

		}

	++(iAttachmentFailureCount[index]);

	PokeSession();

	LOG;

	}

// Called to add an event to the tail of the queue.

// Takes ownership of aEvent.

void CEventQueue::AddDeviceEvent(TDeviceEvent& aEvent)

	{

	LOG;

	iDeviceEvents.AddLast(aEvent);

	PokeSession();

	LOG;

	}

// Poke the session object (if it exists) to complete any outstanding event

// notifications it has.

// It only makes sense to call this function if there's some event to give up.

void CEventQueue::PokeSession()

	{

	// If the session exists, and has a notification outstanding, give them

	// the head event.

	CFdfSession* sess = iFdf.Session();

	if ( sess )

		{

		if ( sess->NotifyDevmonEventOutstanding() )

			{

			TInt event;

			if ( GetDevmonEvent(event) )

				{

				sess->DevmonEvent(event);

				}

			}

		if ( sess->NotifyDeviceEventOutstanding() )

			{

			TDeviceEvent event;

			if ( GetDeviceEvent(event) )

				{

				sess->DeviceEvent(event);

				}

			}

		}

	}

// This is called to get a device event. Attachment failures are given up

// before actual queued events.

// If ETrue is returned, the queued event is destroyed and a copy is delivered

// in aEvent.

TBool CEventQueue::GetDeviceEvent(TDeviceEvent& aEvent)

	{

	LOG;

	TBool ret = EFalse;

	// We need to see if any attachment failures have been collected by us. If

	// there have, report exactly one of them to the client.

	for ( TUint ii = 0 ; ii < KNumberOfAttachmentFailureTypes ; ++ii )

		{

		TUint& errorCount = iAttachmentFailureCount[ii];

		if ( errorCount )

			{

			--errorCount;

			switch ( ii )

				{

			case KSetAddrFailed:

				aEvent.iInfo.iError = KErrUsbSetAddrFailed;

				break;

			case KNoPower:

				aEvent.iInfo.iError = KErrUsbNoPower;

				break;

			case KBadPower:

				aEvent.iInfo.iError = KErrBadPower;

				break;

			case KIOError:

				aEvent.iInfo.iError = KErrUsbIOError;

				break;

			case KTimeout:

				aEvent.iInfo.iError = KErrUsbTimeout;

				break;

			case KStalled:

				aEvent.iInfo.iError = KErrUsbStalled;

				break;

			case KNoMemory:

				aEvent.iInfo.iError = KErrNoMemory;

				break;

			case KConfigurationHasNoInterfaces:

				aEvent.iInfo.iError = KErrUsbConfigurationHasNoInterfaces;

				break;

			case KInterfaceCountMismatch:

				aEvent.iInfo.iError = KErrUsbInterfaceCountMismatch;

				break;

			case KDuplicateInterfaceNumbers:

				aEvent.iInfo.iError = KErrUsbDuplicateInterfaceNumbers;

				break;

			case KBadHandle:

				aEvent.iInfo.iError = KErrBadHandle;

				break;

			case KAttachmentFailureGeneralError:

				aEvent.iInfo.iError = KErrUsbAttachmentFailureGeneralError;

				break;

			case KNumberOfAttachmentFailureTypes:

			default:

				// this switch should deal with every error type we store

				}

			ret = ETrue;

			aEvent.iInfo.iEventType = EDeviceAttachment;

			// Only give the client one error at a time.

			break;

			}

		}

	if ( !ret && !iDeviceEvents.IsEmpty() )

		{

		TDeviceEvent* const event = iDeviceEvents.First();

		iDeviceEvents.Remove(*event);

		(void)Mem::Copy(&aEvent, event, sizeof(TDeviceEvent));

		delete event;

		ret = ETrue;

		}

	LOG;

	return ret;

	}

TBool CEventQueue::GetDevmonEvent(TInt& aEvent)

	{

	TBool ret = EFalse;

	for ( TUint ii = 0 ; ii < KNumberOfDevmonEventTypes ; ++ii )

		{

		TUint& eventCount = iDevmonEventCount[ii];

		if ( eventCount )

			{

			--eventCount;

			switch ( ii )

				{

			case KUsbDeviceRejected:

				aEvent = KErrUsbDeviceRejected;

				break;

			case KUsbDeviceFailed:

				aEvent = KErrUsbDeviceFailed;

				break;

			case KUsbBadDevice:

				aEvent = KErrUsbBadDevice;

				break;

			case KUsbBadHubPosition:

				aEvent = KErrUsbBadHubPosition;

				break;

			case KUsbBadHub:

				aEvent = KErrUsbBadHub;

				break;

			case KUsbEventOverflow:

				aEvent = KErrUsbEventOverflow;

				break;

			case KNumberOfDevmonEventTypes:

			default:

				aEvent = KErrUsbDeviceRejected;

				// this switch should deal with every error type we store

				}

			ret = ETrue;

			// Only give the client one error at a time.

			break;

			}

		}

	LOG;

	return ret;

	}

void CEventQueue::AddDevmonEvent(TInt aEvent)

	{

	TInt index = 0;

	switch ( aEvent )

		{

		case KErrUsbDeviceRejected:

			index = KUsbDeviceRejected;

			break;

		case KErrUsbDeviceFailed:

			index = KUsbDeviceFailed;

			break;

		case KErrUsbBadDevice:

			index = KUsbBadDevice;

			break;

		case KErrUsbBadHubPosition:

			index = KUsbBadHubPosition;

			break;

		case KErrUsbBadHub:

			index = KUsbBadHub;

			break;

		case KErrUsbEventOverflow:

			index = KUsbEventOverflow;

			break;			

		default:

	TUint& eventCount = iDevmonEventCount[index];

	++eventCount;

	PokeSession();

	}

void CEventQueue::Log()

	{

	for ( TUint ii = 0 ; ii < KNumberOfAttachmentFailureTypes ; ++ii )

		{

		const TInt& errorCount = iAttachmentFailureCount[ii];

		if ( errorCount )

			{

		}

	for ( TUint ii = 0 ; ii < KNumberOfDevmonEventTypes ; ++ii )

		{

		const TInt& eventCount = iDevmonEventCount[ii];

		if ( eventCount )

			{

			}

		}

	TUint pos = 0;

	TSglQueIter<TDeviceEvent> iter(iDeviceEvents);

	iter.SetToFirst();

	TDeviceEvent* event;

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

		{

		++pos;

		}

	}