/*

* Copyright (c) 1997-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:

* Implements a Session of a Symbian OS server for the RUsb API

*

*/

/**

 @file

*/

#include <usbstates.h>

#include <usberrors.h>

#include <usb/usbshared.h>

#include <usb/usblogger.h>

#include "CUsbSession.h"

#include "CUsbDevice.h"

#include "CUsbServer.h"

#ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV

#include "CUsbOtg.h"

#include "cusbhost.h"

#endif // SYMBIAN_ENABLE_USB_OTG_HOST_PRIV

#include "CPersonality.h"

#include "rusb.h"

#include "UsbSettings.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "CUsbSessionTraces.h"

#endif

#ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV

CUsbSession* CUsbSession::iCtlSession = NULL;

#endif // SYMBIAN_ENABLE_USB_OTG_HOST_PRIV

/**

 * Construct a Symbian OS session object.

 *

 * @internalComponent

 * @param	aServer		Service the session will be a member of

 *

 * @return	A new CUsbSession object

 */

CUsbSession* CUsbSession::NewL(CUsbServer* aServer)

	{

	OstTraceFunctionEntry0( CUSBSESSION_NEWL_ENTRY );

	//this class has moved away from standard NewL() semantics

	//and now uses the virtual CSession2::CreateL() function

	//[instead of ConstructL()] which is called by CServer2

	//and finalises the construction of the session

	return (new (ELeave) CUsbSession(aServer));

	}

/**

 * Constructor.

 *

 * @internalComponent

 * @param	aServer	Service the session will be a member of

 */

CUsbSession::CUsbSession(CUsbServer* aServer)

	: iUsbServer(aServer)

	{

	OstTraceFunctionEntry0( CUSBSESSION_CUSBSESSION_CONS_ENTRY );

	iUsbServer->IncrementSessionCount();

	OstTraceFunctionExit0( CUSBSESSION_CUSBSESSION_CONS_EXIT );

	}

/**

 * Destructor.

 */

CUsbSession::~CUsbSession()

	{

	OstTraceFunctionEntry0( CUSBSESSION_CUSBSESSION_DES_ENTRY );

	OstTrace1( TRACE_NORMAL, CUSBSESSION_CUSBSESSION, "CUsbSession::~CUsbSession;About to Device().DeRegisterObserver(%08x)", this );

	iUsbServer->Device().DeRegisterObserver(*this);

#ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV

	OstTrace1( TRACE_NORMAL, CUSBSESSION_CUSBSESSION_DUP1, "CUsbSession::~CUsbSession;About to Otg().DeRegisterObserver(%08x)", this );

	iUsbServer->Otg().DeRegisterObserver(*this);

	OstTrace1( TRACE_NORMAL, CUSBSESSION_CUSBSESSION_DUP2, "CUsbSession::~CUsbSession;About to Host().DeRegisterObserver(%08x)", this );

	iUsbServer->Host().DeregisterObserver(*this);

	if ( iCtlSession && (iCtlSession == this) )

		{

		iCtlSession = NULL;

		}

#endif // SYMBIAN_ENABLE_USB_OTG_HOST_PRIV

	OstTrace0( TRACE_NORMAL, CUSBSESSION_CUSBSESSION_DUP3, "CUsbSession::~CUsbSession;About to iUsbServer->DecrementSessionCount()" );

	iUsbServer->DecrementSessionCount();

	OstTraceFunctionExit0( CUSBSESSION_CUSBSESSION_DES_EXIT );

	}

/**

 * Called when a message is received from the client.

 *

 * @param	aMessage	Message received from the client

 */

void CUsbSession::ServiceL(const RMessage2& aMessage)

	{

	OstTraceFunctionEntry0( CUSBSESSION_SERVICEL_ENTRY );

	DispatchMessageL(aMessage);

	OstTraceFunctionExit0( CUSBSESSION_SERVICEL_EXIT );

	}

/**

 * Handles 2nd Phase Construction.  Implementation of the virtual method defined in CSession2 and called from

 * CServer2::DoConnectL() which executes when the client makes a connection request through CServer2::Connect().  If

 * a Leave occurs at any point the CUsbSession object is cleaned up in CServer2::DoConnect().

 */

void CUsbSession::CreateL()

	{

	OstTraceFunctionEntry0( CUSBSESSION_CREATEL_ENTRY );

	// This code originally existed in the typical non-virtual ConstructL() method.

	// However it was moved to this method for minor optimisation reasons [three less

	// function calls and several lines less code in the NewL() method].

	iPersonalityCfged = iUsbServer->Device().isPersonalityCfged();

    OstTrace0( TRACE_NORMAL, CUSBSESSION_CREATEL, "CUsbSession::CreateL;Registering Device Observer" );

	iUsbServer->Device().RegisterObserverL(*this);

#ifdef SYMBIAN_ENABLE_USB_OTG_HOST_PRIV

	OstTrace0( TRACE_NORMAL, CUSBSESSION_CREATEL_DUP1, "CUsbSession::CreateL;Registering OTG Observer" );

	iUsbServer->Otg().RegisterObserverL(*this);

	OstTrace0( TRACE_NORMAL, CUSBSESSION_CREATEL_DUP2, "CUsbSession::CreateL;Registering HOST Observer" );

	iUsbServer->Host().RegisterObserverL(*this);

#endif // SYMBIAN_ENABLE_USB_OTG_HOST_PRIV

	OstTraceFunctionExit0( CUSBSESSION_CREATEL_EXIT );

	}

/**

 * Called by CUsbDevice when the service state changes.

 * CUsbSession is an observer of the device.

 *

 * @param	aLastError	The last error happened

 * @param	aOldState	The device's service state just before it changed

 * @param	aNewState	The device's new and current service state

 */

void CUsbSession::UsbServiceStateChange(TInt aLastError, TUsbServiceState aOldState,

										TUsbServiceState aNewState)

	{

	OstTraceFunctionEntry0( CUSBSESSION_USBSERVICESTATECHANGE_ENTRY );

	OstTraceExt2( TRACE_NORMAL, CUSBSESSION_USBSERVICESTATECHANGE, "CUsbSession::UsbServiceStateChange;aOldState=0x%X, aNewState=0x%X", aOldState, aNewState );

	(void) aOldState; // a-void build warning in UREL

	// Note that it's possible to have both a start and a stop outstanding!

	if (iStartOutstanding)

		{

		HandleServiceStateChangeWhileStarting(aLastError, aNewState);

		}

	if (iStopOutstanding)

		{

		HandleServiceStateChangeWhileStopping(aLastError, aNewState);

		}

	// Check whether we have an observer of the service state.

	if (iServiceObserverOutstanding)

		{

		TPckg<TUint32> pckg(aNewState);

		iServiceObserverOutstanding = EFalse;

		const TInt err = iServiceObserverMessage.Write(0, pckg);

		iServiceObserverMessage.Complete(err);

		}

	OstTraceFunctionExit0( CUSBSESSION_USBSERVICESTATECHANGE_EXIT );

	}

/**

 * Handles a state change while a start request is currently outstanding.

 *

 * @param aLastError The last error happened

 * @param aNewState The state we've moved to

 */

void CUsbSession::HandleServiceStateChangeWhileStarting(TInt aLastError,

												 TUsbServiceState aNewState)

	{

	OstTraceFunctionEntry0( CUSBSESSION_HANDLESERVICESTATECHANGEWHILESTARTING_ENTRY );

	switch (aNewState)

		{

	case EUsbServiceStarted:

		OstTrace0( TRACE_NORMAL, CUSBSESSION_HANDLESERVICESTATECHANGEWHILESTARTING, "CUsbSession::HandleServiceStateChangeWhileStarting    Completing Start successfully" );

		// If the user has tried to cancel the start, they're too late!

		if (iCancelOutstanding)

			{

			OstTrace0( TRACE_NORMAL, CUSBSESSION_HANDLESERVICESTATECHANGEWHILESTARTING_DUP1, "CUsbSession::HandleServiceStateChangeWhileStarting    Completing cancel request with KErrNone" );

			iCancelOutstanding = EFalse;

			iCancelMessage.Complete(KErrNone);

			}

		iStartMessage.Complete(KErrNone);

		iStartOutstanding = EFalse;

		break;

	case EUsbServiceIdle:

		OstTrace1( TRACE_NORMAL, CUSBSESSION_HANDLESERVICESTATECHANGEWHILESTARTING_DUP2, "CUsbSession::HandleServiceStateChangeWhileStarting;    Completing Start with error=%d", aLastError );

		// If there hasn't actually been an error, but we're in an unexpected

		// state now, that means that this client cancelled the request, or

		// another client stopped the service.

		if (aLastError == KErrNone)

			{

			// If there's a cancel outstanding, then that message succeeded, but

			// the start message should be completed with KErrCancel.

			if (iCancelOutstanding)

				{

				OstTrace0( TRACE_NORMAL, CUSBSESSION_HANDLESERVICESTATECHANGEWHILESTARTING_DUP3, "CUsbSession::HandleServiceStateChangeWhileStarting    Completing original message with KErrCancel" );

				iCancelOutstanding = EFalse;

				iCancelMessage.Complete(KErrNone);

				iStartMessage.Complete(KErrCancel);

				}

			else

				{

				iStartMessage.Complete(KErrUsbServiceStopped);

				}

			}

		else

			{

			// There's been some kind of error, so complete the original message

			// with the right error code.

			if (iCancelOutstanding)

				{

				iCancelOutstanding = EFalse;

				iCancelMessage.Complete(KErrNone);

				}

			iStartMessage.Complete(aLastError);

			}

		iStartOutstanding = EFalse;

		break;

	default:

		break;

		}

	OstTraceFunctionExit0( CUSBSESSION_HANDLESERVICESTATECHANGEWHILESTARTING_EXIT );

	}

/**

 * Handles a state change while a stop request is currently outstanding.

 *

 * @param aLastError The last error happened

 * @param aNewState The state we've moved to

 */

void CUsbSession::HandleServiceStateChangeWhileStopping(TInt aLastError,

												 TUsbServiceState aNewState)

	{

	OstTraceFunctionEntry0( CUSBSESSION_HANDLESERVICESTATECHANGEWHILESTOPPING_ENTRY );

	switch (aNewState)

		{

	case EUsbServiceStarted:

		OstTrace1( TRACE_NORMAL, CUSBSESSION_HANDLESERVICESTATECHANGEWHILESTOPPING, "CUsbSession::HandleServiceStateChangeWhileStopping;    Completing Stop with error=%d", aLastError );

		// If there hasn't actually been an error, but we're in an unexpected

		// state now, that means that this client cancelled the request, or

		// another client has started the service.

		if (aLastError == KErrNone)

			{

			// If there's a cancel outstanding, then that message succeeded, but

			// the stop message should be completed with KErrCancel.

			if (iCancelOutstanding)

				{

				OstTrace0( TRACE_NORMAL, CUSBSESSION_HANDLESERVICESTATECHANGEWHILESTOPPING_DUP1, "CUsbSession::HandleServiceStateChangeWhileStopping;    Completing original message with KErrCancel" );

				iCancelOutstanding = EFalse;

				iCancelMessage.Complete(KErrNone);

				iStopMessage.Complete(KErrCancel);

				}

			else

				{

				iStopMessage.Complete(KErrUsbServiceStarted);

				}

			}

		else

			{

			// There's been some kind of error, so complete the original message

			// with the right error code.

			if (iCancelOutstanding)

				{

				iCancelOutstanding = EFalse;

				iCancelMessage.Complete(KErrNone);

				}

			iStopMessage.Complete(aLastError);

			}

		iStopOutstanding = EFalse;

		break;

	case EUsbServiceIdle:

		OstTrace0( TRACE_NORMAL, CUSBSESSION_HANDLESERVICESTATECHANGEWHILESTOPPING_DUP2, "CUsbSession::HandleServiceStateChangeWhileStopping    Completing Stop with KErrNone" );

		// If the user has tried to cancel the stop, they're too late!

		if (iCancelOutstanding)

			{

			OstTrace0( TRACE_NORMAL, CUSBSESSION_HANDLESERVICESTATECHANGEWHILESTOPPING_DUP3, "CUsbSession::HandleServiceStateChangeWhileStopping    Completing cancel request with KErrNone" );

			iCancelOutstanding = EFalse;

			iCancelMessage.Complete(KErrNone);

			}

		iStopMessage.Complete(KErrNone);

		iStopOutstanding = EFalse;

		break;

	default:

		break;

		}

	OstTraceFunctionExit0( CUSBSESSION_HANDLESERVICESTATECHANGEWHILESTOPPING_EXIT );

	}

/**

 * Called by CUsbDevice when it state change. CUsbSession is an observer of

 * the device. If the client has an Observer outstanding then complete it,

 * otherwise put it in a circular queue.

 *

 * @internalComponent

 * @param	aLastError	The last error happened

 * @param	aOldState	The device's state just before it changed

 * @param	aNewState	The device's new and current state

 */

void CUsbSession::UsbDeviceStateChange(TInt /*aLastError*/, TUsbDeviceState /*aOldState*/,

									   TUsbDeviceState aNewState)

	{

	OstTraceFunctionEntry0( CUSBSESSION_USBDEVICESTATECHANGE_ENTRY );

	// can we bypass the queue?

 	if ((iDeviceObserverOutstanding) && (iDevStateQueueHead == iDevStateQueueTail))

		{

		if ((iDeviceObserverMessage.Int0() & aNewState) ||

			(aNewState == EUsbDeviceStateUndefined))

			{

			TPckg<TUint32> pckg(aNewState);

			iNotifiedDevState = aNewState;

			iDeviceObserverOutstanding = EFalse;

			const TInt err = iDeviceObserverMessage.Write(1, pckg);

			iDeviceObserverMessage.Complete(err);

			}

		}

	else if (iObserverQueueEvents)

		{

		TBool addToQueue = ETrue;

 		// Search queue for similar event, truncate event queue if found

 		if (aNewState == EUsbDeviceStateUndefined)

 			{

 			// erase Event queue, just want this event - not interested in how we got here

 			iDevStateQueueTail = iDevStateQueueHead;

 			// if this is also the event mostly recently notified then don't bother to queue it

 			if(aNewState == iNotifiedDevState)

 				addToQueue = EFalse;

 			}

 		else

 			{

 			TInt queuePtr = iDevStateQueueTail;

 			// search forward from tail to head

 			while (queuePtr != iDevStateQueueHead)

 				{

 				if (aNewState == iDeviceStateQueue[queuePtr])

 					{

 					// Event is already queued; discard the duplicate and in-between events

 					OstTraceExt2( TRACE_NORMAL, CUSBSESSION_USBDEVICESTATECHANGE, "CUsbSession::UsbDeviceStateChange;--- collapsing queue head (%d, %d)", iDevStateQueueHead, ((queuePtr + 1) % KDeviceStatesQueueSize) );

 					// queue head moved to position following the match

 					iDevStateQueueHead = (queuePtr + 1) % KDeviceStatesQueueSize;

 					addToQueue = EFalse;

 					break;

 					}

 				// work our way through queue

 				queuePtr = (queuePtr + 1) % KDeviceStatesQueueSize;

 				}

 			}

 		// still want to add to queue?

 		if (addToQueue)

 			{

 			// add event to head of queue

 			iDeviceStateQueue[iDevStateQueueHead] = aNewState;

 			iDevStateQueueHead = (iDevStateQueueHead + 1) % KDeviceStatesQueueSize;

 			OstTraceExt2( TRACE_NORMAL, CUSBSESSION_USBDEVICESTATECHANGE_DUP1, "CUsbSession::UsbDeviceStateChange;+++ addqueue (%d, %d)", iDevStateQueueHead, iDevStateQueueTail );

 			}

 		// UsbDeviceDequeueEvent() will read from queue when RegisterObserver()

		// is next called.

		}

	OstTraceFunctionExit0( CUSBSESSION_USBDEVICESTATECHANGE_EXIT );

	}

/**

 * Dequeues an event and completes the observer's request with it.

 */

void CUsbSession::UsbDeviceDequeueEvent()

 	{

	OstTraceFunctionEntry0( CUSBSESSION_USBDEVICEDEQUEUEEVENT_ENTRY );

 	// Work our way through the queue, until we reach the end

 	// OR we find an event the current observer wants.

 	while ((iDeviceObserverOutstanding) && (iDevStateQueueHead != iDevStateQueueTail))

 		{

 		// inform the observer of state changes they are interested in AND

 		// if the cable is pulled out (EUsbDeviceStateUndefined)

 		TUsbDeviceState newState = iDeviceStateQueue[iDevStateQueueTail];

 		// advance tail towards the head

 		iDevStateQueueTail = (iDevStateQueueTail + 1) % KDeviceStatesQueueSize;

 		// is this state one the Observer wants?

 		if ((iDeviceObserverMessage.Int0() & newState) ||

			(newState == EUsbDeviceStateUndefined))

 			{

 			TPckg<TUint32> pckg(newState);

 			iNotifiedDevState = newState;

 			OstTraceExt2( TRACE_NORMAL, CUSBSESSION_USBDEVICEDEQUEUEEVENT, "CUsbSession::UsbDeviceDequeueEvent;dequeued event #%d (0x%x)", iDevStateQueueTail, newState );

  			iDeviceObserverOutstanding = EFalse;

			const TInt err = iDeviceObserverMessage.Write(1, pckg);

 			iDeviceObserverMessage.Complete(err);

 			break;

   			}

   		}

   	OstTraceFunctionExit0( CUSBSESSION_USBDEVICEDEQUEUEEVENT_EXIT );

   	}

/**

 * Handles the request (in the form of a the message) received from the client

 *

 * @internalComponent

 * @param	aMessage	The received message

 */

void CUsbSession::DispatchMessageL(const RMessage2& aMessage)

	{

	OstTraceFunctionEntry0( CUSBSESSION_DISPATCHMESSAGEL_ENTRY );

	TBool complete = ETrue;

	TInt ret = KErrNone;

	OstTrace1( TRACE_NORMAL, CUSBSESSION_DISPATCHMESSAGEL, "CUsbSession::DispatchMessageL;func#=%d", aMessage.Function() );

	switch (aMessage.Function())

		{

	case EUsbStart:

		ret = StartDeviceL(aMessage, complete);

		break;

	case EUsbStop:

		ret = StopDeviceL(aMessage, complete);

		break;

	case EUsbGetCurrentState:

		ret = GetCurrentServiceState(aMessage);

		break;

	case EUsbGetCurrentDeviceState:

		ret = GetCurrentDeviceState(aMessage);

		break;

	case EUsbRegisterServiceObserver:

		ret = RegisterServiceObserver(aMessage, complete);

		break;

	case EUsbRegisterObserver:

		ret = RegisterDeviceObserver(aMessage, complete);

		break;

	case EUsbStartCancel:

		ret = StartCancel(aMessage, complete);

		break;

	case EUsbStopCancel:

		ret = StopCancel(aMessage, complete);

		break;

	case EUsbCancelServiceObserver:

		ret = DeRegisterServiceObserver();

		break;

	case EUsbCancelObserver:

		ret = DeRegisterDeviceObserver();

		break;

	case EUsbTryStart:

		ret = TryStartDeviceL(aMessage, complete);

		break;

	case EUsbTryStop:

		ret = TryStopDeviceL(aMessage, complete);

		break;

	case EUsbCancelInterest:

		ret = CancelInterest(aMessage);

		break;

	case EUsbGetCurrentPersonalityId:

		ret = GetCurrentPersonalityId(aMessage);

		break;

	case EUsbGetSupportedClasses:

		ret = GetSupportedClasses(aMessage);

		break;